Diff [0536612b984ce2c8b8a40764dec0e670e5235230:f658288f133dcc442f158f3300ad89beb49113e2] for / – aubio

examples/aubiomfcc.c

-                      r0536612
+                      rf658288
 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) {
+      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);
+      }
+      /* write input to datanew */
+      fvec_write_sample(ibuf, input[0][j], pos);
+      /* put synthnew in output */
+      output[0][j] = fvec_read_sample(obuf, 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, 0, coef_cnt) );
+            outmsg("%f ", fvec_read_sample (mfcc_out, coef_cnt) );
+        }
         outmsg("\n");
 …
   /* phase vocoder */
   pv = new_aubio_pvoc (buffer_size, overlap_size, channels);
+  pv = new_aubio_pvoc (buffer_size, overlap_size);
   fftgrain = new_cvec (buffer_size, channels);
+  fftgrain = new_cvec (buffer_size);
   //populating the filter
   mfcc = new_aubio_mfcc(buffer_size, n_filters, n_coefs, samplerate);
   mfcc_out = new_fvec(n_coefs,channels);
+  mfcc_out = new_fvec(n_coefs);
   //process

examples/aubionotes.c

-                      r0536612
+                      rf658288
 */
 #define AUBIO_UNSTABLE 1 // for fvec_median_channel
+#define AUBIO_UNSTABLE 1 // for fvec_median
 #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) {
+      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);
+      }
+      /* write input to datanew */
+      fvec_write_sample(ibuf, input[0][j], pos);
+      /* put synthnew in output */
+      output[0][j] = fvec_read_sample(obuf, pos);
+    }
     /*time for fft*/
 …
       aubio_pitch_do (pitchdet, ibuf, pitch_obuf);
       pitch = fvec_read_sample(pitch_obuf, 0, 0);
+      pitch = fvec_read_sample(pitch_obuf, 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, 0)) {
+      if (fvec_read_sample(onset, 0)) {
               /* test for silence */
               if (curlevel == 1.) {
 …
                       for (pos = 0; pos < overlap_size; pos++){
                               obuf->data[0][pos] = woodblock->data[0][pos];
+                              obuf->data[pos] = woodblock->data[pos];
+                      }
+              }
 …
               } // if median
         for (pos = 0; pos < overlap_size; pos++)
           obuf->data[0][pos] = 0.;
+          obuf->data[pos] = 0.;
+      }
       /* end of block loop */
 …
   uint_t i = 0;
   for (i = 0; i < note_buffer->length - 1; i++) {
     note_buffer->data[0][i] = note_buffer->data[0][i + 1];
+    note_buffer->data[i] = note_buffer->data[i + 1];
+  }
   note_buffer->data[0][note_buffer->length - 1] = curnote;
+  note_buffer->data[note_buffer->length - 1] = curnote;
   return;
+}
 …
   uint_t i;
   for (i = 0; i < note_buffer->length; i++) {
     note_buffer2->data[0][i] = note_buffer->data[0][i];
+    note_buffer2->data[i] = note_buffer->data[i];
+  }
   return fvec_median_channel (note_buffer2, 0);
+  return fvec_median (note_buffer2);
+}
 …
   examples_common_init(argc,argv);
+  o = new_aubio_onset (onset_mode, buffer_size, overlap_size, channels,
+          samplerate);
+  o = new_aubio_onset (onset_mode, buffer_size, overlap_size, samplerate);
   if (threshold != 0.) aubio_onset_set_threshold (o, threshold);
   onset = new_fvec (1, channels);
+  onset = new_fvec (1);
   pitchdet = new_aubio_pitch (pitch_mode, buffer_size * 4,
           overlap_size, channels, samplerate);
+          overlap_size, samplerate);
   aubio_pitch_set_tolerance (pitchdet, 0.7);
   pitch_obuf = new_fvec (1, channels);
+  pitch_obuf = new_fvec (1);
   if (median) {
       note_buffer = new_fvec (median, 1);
       note_buffer2 = new_fvec (median, 1);
+      note_buffer = new_fvec (median);
+      note_buffer2 = new_fvec (median);
+  }

examples/aubioonset.c

-                      r0536612
+                      rf658288
   for (j=0;j<(unsigned)nframes;j++) {
     if(usejack) {
+      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);
+      }
+      /* write input to datanew */
+      fvec_write_sample(ibuf, input[0][j], pos);
+      /* put synthnew in output */
+      output[0][j] = fvec_read_sample(obuf, 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, 0)) {
+      if ( fvec_read_sample(onset, 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, 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);
+  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, channels,
+          samplerate);
+  o = new_aubio_onset (onset_mode, buffer_size, overlap_size, samplerate);
   if (threshold != 0.) aubio_onset_set_threshold (o, threshold);
   onset = new_fvec (1, channels);
+  onset = new_fvec (1);
   examples_common_process(aubio_process,process_print);

examples/aubiopitch.c

-                      r0536612
+                      rf658288
 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) {
+      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);
+      }
+      /* write input to datanew */
+      fvec_write_sample(ibuf, input[0][j], pos);
+      /* put synthnew in output */
+      output[0][j] = fvec_read_sample(obuf, pos);
+    }
     /*time for fft*/
 …
       /* block loop */
       aubio_pitch_do (o, ibuf, pitch);
       if (fvec_read_sample(pitch, 0, 0)) {
+      if (fvec_read_sample(pitch, 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, 0);
+      smpl_t pitch_found = fvec_read_sample(pitch, 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, channels,
+          samplerate);
+  pitch = new_fvec (1, channels);
+  o = new_aubio_pitch (onset_mode, buffer_size, overlap_size, samplerate);
+  pitch = new_fvec (1);
   examples_common_process(aubio_process,process_print);

examples/aubioquiet.c

-                      r0536612
+                      rf658288
 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) {
+      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);
+      }
+      /* write input to datanew */
+      fvec_write_sample(ibuf, input[0][j], pos);
+      /* put synthnew in output */
+      output[0][j] = fvec_read_sample(obuf, 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;
+      }

examples/aubiotrack.c

-                      r0536612
+                      rf658288
 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) {
+      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);
+      }
+      /* write input to datanew */
+      fvec_write_sample(ibuf, input[0][j], pos);
+      /* put synthnew in output */
+      output[0][j] = fvec_read_sample(obuf, pos);
+    }
     /*time for fft*/
 …
       /* block loop */
       aubio_tempo_do (bt,ibuf,tempo_out);
       istactus = fvec_read_sample (tempo_out, 0, 0);
       isonset = fvec_read_sample (tempo_out, 0, 1);
+      istactus = fvec_read_sample (tempo_out, 0);
+      isonset = fvec_read_sample (tempo_out, 1);
       if (istactus > 0.) {
         fvec_copy (woodblock, obuf);
 …
   examples_common_init(argc,argv);
   tempo_out = new_fvec(2,channels);
   bt = new_aubio_tempo(onset_mode,buffer_size,overlap_size,channels, samplerate);
+  tempo_out = new_fvec(2);
+  bt = new_aubio_tempo(onset_mode,buffer_size,overlap_size, samplerate);
   if (threshold != 0.) aubio_tempo_set_threshold (bt, threshold);

examples/sndfileio.c

-                      r0536612
+                      rf658288
         aubio_sndfile_t * f = AUBIO_NEW(aubio_sndfile_t);
         f->samplerate    = fmodel->samplerate;
         f->channels      = fmodel->channels;
+        f->channels      = 1; //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_channel(read,i);
+                pread = (smpl_t *)fvec_get_data(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_channel(write,i);
+                pwrite = (smpl_t *)fvec_get_data(write[i]);
                 for (j=0; j<frames; j++) {
                         f->tmpdata[channels*j+i] = (float)pwrite[j];

examples/sndfileio.h

-                      r0536612
+                      rf658288
  * 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

examples/utils.c

-                      r0536612
+                      rf658288
 uint_t buffer_size = 512;       //1024;
 uint_t overlap_size = 256;      //512;
-uint_t channels = 1;
 uint_t samplerate = 44100;
 …
   parse_args (argc, argv);
   woodblock = new_fvec (buffer_size, 1);
+  woodblock = new_fvec (overlap_size);
   if (output_filename || usejack) {
     /* dummy assignement to keep egcs happy */
 …
   if (onsetfile) {
     /* read the output sound once */
     aubio_sndfile_read (onsetfile, overlap_size, woodblock);
+    aubio_sndfile_read_mono (onsetfile, overlap_size, woodblock);
+  }
 …
     if (verbose)
       aubio_sndfile_info (file);
-    channels = aubio_sndfile_channels (file);
     samplerate = aubio_sndfile_samplerate (file);
     if (output_filename != NULL)
 …
 #endif /* HAVE_LASH */
+  ibuf = new_fvec (overlap_size, channels);
+  obuf = new_fvec (overlap_size, channels);
+  uint_t i;
+  ibuf = new_fvec (overlap_size);
+  obuf = new_fvec (overlap_size);
+}
 …
 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 (channels, channels,
+    jack_setup = new_aubio_jack (1, 1,
 , 1, (aubio_process_func_t) process_func);
     debug ("Jack activation ...\n");
 …
     frames = 0;
     while ((signed) overlap_size == aubio_sndfile_read (file, overlap_size,
             ibuf)) {
       process_func (ibuf->data, obuf->data, overlap_size);
+    while ((signed) overlap_size ==
+        aubio_sndfile_read_mono (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 ();
+  }

examples/utils.h

r0536612	rf658288
74	74	extern uint_t buffer_size;
75	75	extern uint_t overlap_size;
76		~~extern uint_t channels;~~
77	76	extern uint_t samplerate;
78	77

interfaces/python/aubio-types.h

-                      r0536612
+                      rf658288
 #include <aubio.h>
 #define Py_default_vector_length   1024
 #define Py_default_vector_channels 1
+#define Py_default_vector_length 1024
+#define Py_default_vector_height 1
 #define Py_aubio_default_samplerate 44100
 …
 */
-#define AUBIO_DO_CASTING 0
 typedef struct
 …
   fvec_t * o;
   uint_t length;
-  uint_t channels;
 } Py_fvec;
 extern PyTypeObject Py_fvecType;
 …
 extern PyObject *PyAubio_CFvecToArray (fvec_t * self);
 extern Py_fvec *PyAubio_ArrayToFvec (PyObject * self);
+typedef struct
+{
+  PyObject_HEAD
+  fmat_t * o;
+  uint_t length;
+  uint_t height;
+} Py_fmat;
+extern PyTypeObject Py_fmatType;
+extern PyObject *PyAubio_FmatToArray (Py_fmat * self);
+extern PyObject *PyAubio_CFmatToArray (fmat_t * self);
+extern Py_fmat *PyAubio_ArrayToFmat (PyObject * self);
 typedef struct

interfaces/python/aubiomodule.c

-                      r0536612
+                      rf658288
   if ((PyType_Ready (&Py_fvecType) < 0)
+      || (PyType_Ready (&Py_fmatType) < 0)
       || (PyType_Ready (&Py_cvecType) < 0)
       || (PyType_Ready (&Py_filterType) < 0)
 …
   Py_INCREF (&Py_fvecType);
   PyModule_AddObject (m, "fvec", (PyObject *) & Py_fvecType);
+  Py_INCREF (&Py_fmatType);
+  PyModule_AddObject (m, "fmat", (PyObject *) & Py_fmatType);
   Py_INCREF (&Py_cvecType);
   PyModule_AddObject (m, "cvec", (PyObject *) & Py_cvecType);

interfaces/python/aubiowraphell.h

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

interfaces/python/gen_pyobject.py

-                      r0536612
+                      rf658288
 # move into the C library at some point.
 defaultsizes = {
     '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'),
+    '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',
+}
 …
     '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
 …
     newparams = get_params_types_names(newfunc)
     # self->param1, self->param2, self->param3
+    selfparams = ', self->'.join([p[1] for p in newparams])
+    if len(newparams):
+        selfparams = ', self->'+', self->'.join([p[1] for p in newparams])
+    else:
+        selfparams = ''
     # "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
     s += """\
   Py_%(name)s *self;
+    if len(paramnames):
+        s += """\
   static char *kwlist[] = { %(paramnames)s, NULL };
 …
     return NULL;
+  }
+""" % locals()
+    s += """\
   self = (Py_%(name)s *) pytype->tp_alloc (pytype, 0);
 …
+}
 AUBIO_INIT(%(name)s, self->%(selfparams)s)
+AUBIO_INIT(%(name)s %(selfparams)s)
 AUBIO_DEL(%(name)s)
 …
         outputvecs = "\n  ".join([aubio2pyaubio[p[0]]+" * " + p[-1] + ";" for p in outputparams])
         outputcreate = "\n  ".join(["""\
 AUBIO_NEW_VEC(%(name)s, %(pytype)s, %(length)s, %(channels)s)
   %(name)s->o = new_%(autype)s (%(length)s, %(channels)s);""" % \
+AUBIO_NEW_VEC(%(name)s, %(pytype)s, %(length)s)
+  %(name)s->o = new_%(autype)s (%(length)s);""" % \
     {'name': p[-1], 'pytype': aubio2pyaubio[p[0]], 'autype': p[0][:-3],
         'length': defaultsizes[name][0], 'channels': defaultsizes[name][1]} \
+        'length': defaultsizes[name]} \
         for p in outputparams])
         if len(outputparams) > 1:

interfaces/python/py-cvec.c

-                      r0536612
+                      rf658288
 class cvec():
     def __init__(self, length = 1024, channels = 1):
+    def __init__(self, length = 1024):
         self.length = length
         self.channels = channels
         self.norm = array(length, channels)
+        self.phas = array(length, channels)
+        self.norm = array(length)
+        self.phas = array(length)
 */
 static char Py_cvec_doc[] = "cvec object";
 …
 Py_cvec_new (PyTypeObject * type, PyObject * args, PyObject * kwds)
+{
   int length= 0, channels = 0;
+  int length= 0;
   Py_cvec *self;
   static char *kwlist[] = { "length", "channels", NULL };
   if (!PyArg_ParseTupleAndKeywords (args, kwds, "|II", kwlist,
           &length, &channels)) {
+  static char *kwlist[] = { "length", NULL };
+  if (!PyArg_ParseTupleAndKeywords (args, kwds, "|I", kwlist,
+          &length)) {
     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->channels);
+  self->o = new_cvec ((self->length - 1) * 2);
   if (self->o == NULL) {
     return -1;
 …
   PyObject *result = NULL;
   format = PyString_FromString ("aubio cvec of %d elements with %d channels");
+  format = PyString_FromString ("aubio cvec of %d elements");
   if (format == NULL) {
     goto fail;
+  }
   args = Py_BuildValue ("II", self->length, self->channels);
+  args = Py_BuildValue ("I", self->length);
   if (args == NULL) {
     goto fail;
+  }
   //cvec_print ( self->o );
+  cvec_print ( self->o );
   result = PyString_Format (format, args);
 …
   PyObject *array;
   Py_cvec *vec;
+  uint_t i;
+  if (input == NULL) {
+    PyErr_SetString (PyExc_ValueError, "input array is not a python object");
+    goto fail;
+  }
   // parsing input object into a Py_cvec
   if (PyObject_TypeCheck (input, &Py_cvecType)) {
 …
       PyErr_SetString (PyExc_ValueError, "input array is a scalar");
       goto fail;
+    } else if (PyArray_NDIM (input) > 1) {
+      PyErr_SetString (PyExc_ValueError,
+          "input array has more than one dimensions");
+      goto fail;
+    }
+    if (!PyArray_ISFLOAT (input)) {
+      PyErr_SetString (PyExc_ValueError, "input array should be float");
+      goto fail;
+    } else if (PyArray_TYPE (input) != AUBIO_NPY_SMPL) {
+      PyErr_SetString (PyExc_ValueError, "input array should be float32");
+      goto fail;
+    } 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) != 2) {
+      PyErr_SetString (PyExc_ValueError,
+          "input array should be have exactly two rows for norm and phas");
+      goto fail;
+    } else {
+      vec->length = PyArray_SIZE (array);
+    }
+    // no need to really allocate cvec, just its struct member
+    // vec->o = new_cvec (vec->length);
+    vec->o = (cvec_t *)malloc(sizeof(cvec_t));
+    vec->o->length = vec->length;
+    // have norm and phas point to array rows
+    vec->o->norm = (smpl_t *) PyArray_GETPTR1 (array, 0);
+    vec->o->phas = (smpl_t *) PyArray_GETPTR1 (array, 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;
+  npy_intp dims[] = { self->o->length, 1 };
+  PyObject *concat = PyList_New (0), *tmp = NULL;
+  tmp = PyArray_SimpleNewFromData (1, dims, NPY_FLOAT, self->o->norm);
+  PyList_Append (concat, tmp);
+  Py_DECREF (tmp);
+  tmp = PyArray_SimpleNewFromData (1, dims, NPY_FLOAT, self->o->phas);
+  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)
+{
+  npy_intp dims[] = { self->o->length, 1 };
+  return PyArray_SimpleNewFromData (1, dims, NPY_FLOAT, self->o->norm);
+}
+PyObject *
+PyAubio_CvecPhasToArray (Py_cvec * self)
+{
+  npy_intp dims[] = { self->o->length, 1 };
+  return PyArray_SimpleNewFromData (1, dims, NPY_FLOAT, self->o->phas);
+}
+PyObject *
+PyAubio_ArrayToCvecPhas (PyObject * self)
+{
+  return NULL;
+}
+PyObject *
+Py_cvec_get_norm (Py_cvec * self, void *closure)
+{
+  return PyAubio_CvecNormToArray(self);
+}
+PyObject *
+Py_cvec_get_phas (Py_cvec * self, void *closure)
+{
+  return PyAubio_CvecPhasToArray(self);
+}
+static int
+Py_cvec_set_norm (Py_cvec * vec, PyObject *input, void * closure)
+{
+  PyObject * array;
+  if (input == NULL) {
+    PyErr_SetString (PyExc_ValueError, "input array is not a python object");
+    goto fail;
+  }
+  if (PyArray_Check(input)) {
+    // we got an array, convert it to a cvec.norm
+    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,
 …
       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
+    }
+    array = input;
+    // 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 {
-      // 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 };
-  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;
+}
-PyObject *
-PyAubio_CvecPhasToArray (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->phas[i]);
-    PyList_Append (concat, tmp);
-    Py_DECREF (tmp);
+  }
-  array = PyArray_FromObject (concat, NPY_FLOAT, 2, 2);
-  Py_DECREF (concat);
-  return array;
+}
-PyObject *
-PyAubio_ArrayToCvecPhas (PyObject * self)
+{
-  return NULL;
+}
-PyObject *
-Py_cvec_get_norm (Py_cvec * self, void *closure)
+{
-  return PyAubio_CvecNormToArray(self);
+}
-PyObject *
-Py_cvec_get_phas (Py_cvec * self, void *closure)
+{
-  return PyAubio_CvecPhasToArray(self);
+}
-static int
-Py_cvec_set_norm (Py_cvec * vec, PyObject *input, void * closure)
+{
-  uint_t i;
-  PyObject * array;
-  if (input == NULL) {
-    PyErr_SetString (PyExc_ValueError, "input array is not a python object");
-    goto fail;
+  }
-  if (PyArray_Check(input)) {
-    // we got an array, convert it to a cvec.norm
-    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;
-    } else if (PyArray_TYPE (input) != AUBIO_NPY_SMPL) {
-      PyErr_SetString (PyExc_ValueError, "input array should be float32");
-      goto fail;
+    }
-    array = input;
-    // check input array dimensions
-    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;
+      }
+    } 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);
+    }
+    }
+    vec->o->norm = (smpl_t *) PyArray_GETPTR1 (array, 0);
   } 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) {
       if (vec->channels != 1) {
           PyErr_SetString (PyExc_ValueError,
                   "input array should have more than one channel");
           goto fail;
+      }
+    if (PyArray_NDIM (array) != 1) {
+      PyErr_Format (PyExc_ValueError,
+          "input array has %d dimensions, not 1",
+          PyArray_NDIM (array));
+      goto fail;
+    } else {
       if (vec->o->length != PyArray_SIZE (array)) {
           PyErr_Format (PyExc_ValueError,
 …
           goto fail;
+      }
+    } 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);
+    }
+    }
+    vec->o->phas = (smpl_t *) PyArray_GETPTR1 (array, 0);
   } 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 */
 };
 …
   {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           */

interfaces/python/py-fft.c

-                      r0536612
+                      rf658288
 static char Py_fft_doc[] = "fft object";
 AUBIO_DECLARE(fft, uint_t win_s; uint_t channels)
+AUBIO_DECLARE(fft, uint_t win_s)
 //AUBIO_NEW(fft)
 …
 Py_fft_new (PyTypeObject * type, PyObject * args, PyObject * kwds)
+{
   int win_s = 0, channels = 0;
+  int win_s = 0;
   Py_fft *self;
   static char *kwlist[] = { "win_s", "channels", NULL };
+  static char *kwlist[] = { "win_s", NULL };
   if (!PyArg_ParseTupleAndKeywords (args, kwds, "|II", kwlist,
           &win_s, &channels)) {
+  if (!PyArg_ParseTupleAndKeywords (args, kwds, "|I", kwlist,
+          &win_s)) {
     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, self->channels)
+AUBIO_INIT(fft, self->win_s)
 AUBIO_DEL(fft)
 …
   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);
+  output->o = new_cvec(((Py_fft *) self)->win_s);
   // compute the function
 …
   {"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)
 …
   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);
+  output->o = new_fvec(output->length);
   // compute the function

interfaces/python/py-filter.c

-                      r0536612
+                      rf658288
   aubio_filter_t * o;
   uint_t order;
-  uint_t channels;
 } Py_filter;
 …
 Py_filter_new (PyTypeObject * type, PyObject * args, PyObject * kwds)
+{
   int order= 0, channels = 0;
+  int order= 0;
   Py_filter *self;
   static char *kwlist[] = { "order", "channels", NULL };
+  static char *kwlist[] = { "order", NULL };
   if (!PyArg_ParseTupleAndKeywords (args, kwds, "|II", kwlist,
           &order, &channels)) {
+          &order)) {
     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->channels);
+  self->o = new_aubio_filter (self->order);
   if (self->o == NULL) {
     return -1;
 …
 #if 1
   aubio_filter_do (((Py_filter *)self)->o, vec->o);
   Py_INCREF(vec);
+  PyArray_INCREF((PyArrayObject*)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);
+  copy->o = new_fvec(vec->o->length);
   aubio_filter_do_outplace (((Py_filter *)self)->o, vec->o, copy->o);
   return (PyObject *)copy;
 …
   {"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 */
 };

interfaces/python/py-filterbank.c

-                      r0536612
+                      rf658288
   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);
+  output->o = new_fvec(self->n_filters);
   // compute the function
 …
 Py_filterbank_get_coeffs (Py_filterbank * self, PyObject *unused)
+{
+  Py_fvec *output = (Py_fvec *) PyObject_New (Py_fvec, &Py_fvecType);
+  output->channels = self->n_filters;
+  output->length = self->win_s / 2 + 1;
+  Py_fmat *output = (Py_fmat *) PyObject_New (Py_fmat, &Py_fvecType);
   output->o = aubio_filterbank_get_coeffs (self->o);
   return (PyObject *)PyAubio_FvecToArray(output);
+  return (PyObject *)PyAubio_FmatToArray(output);
+}

interfaces/python/py-fvec.c

-                      r0536612
+                      rf658288
 class fvec():
     def __init__(self, length = 1024, channels = 1):
+    def __init__(self, length = 1024):
         self.length = length
+        self.channels = channels
+        self.data = array(length, channels)
+        self.data = array(length)
 */
 …
 Py_fvec_new (PyTypeObject * type, PyObject * args, PyObject * kwds)
+{
   int length= 0, channels = 0;
+  int length= 0;
   Py_fvec *self;
+  static char *kwlist[] = { "length", "channels", NULL };
+  if (!PyArg_ParseTupleAndKeywords (args, kwds, "|II", kwlist,
+          &length, &channels)) {
+    return NULL;
+  }
+  static char *kwlist[] = { "length", NULL };
+  if (!PyArg_ParseTupleAndKeywords (args, kwds, "|I", kwlist,
+          &length)) {
+    return NULL;
+  }
   self = (Py_fvec *) type->tp_alloc (type, 0);
   self->length = 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 channels");
-    return NULL;
+  }
   return (PyObject *) self;
+}
 …
 Py_fvec_init (Py_fvec * self, PyObject * args, PyObject * kwds)
+{
   self->o = new_fvec (self->length, self->channels);
+  self->o = new_fvec (self->length);
   if (self->o == NULL) {
     return -1;
 …
 Py_fvec_repr (Py_fvec * self, PyObject * unused)
+{
+#if 0
   PyObject *format = NULL;
   PyObject *args = NULL;
   PyObject *result = NULL;
   format = PyString_FromString ("aubio fvec of %d elements with %d channels");
+  format = PyString_FromString ("aubio fvec of %d elements");
   if (format == NULL) {
     goto fail;
+  }
   args = Py_BuildValue ("II", self->length, self->channels);
+  args = Py_BuildValue ("I", self->length);
   if (args == NULL) {
     goto fail;
 …
   result = PyString_Format (format, args);
+fail:
+  Py_XDECREF (format);
+  Py_XDECREF (args);
+  return result;
+#endif
+  PyObject *format = NULL;
+  PyObject *args = NULL;
+  PyObject *result = NULL;
+  format = PyString_FromString ("%s");
+  if (format == NULL) {
+    goto fail;
+  }
+  args = Py_BuildValue ("O", PyAubio_FvecToArray (self));
+  if (args == NULL) {
+    goto fail;
+  }
+  result = PyString_Format (format, args);
 fail:
   Py_XDECREF (format);
 …
   PyObject *array;
   Py_fvec *vec;
-  uint_t i;
   if (input == NULL) {
     PyErr_SetString (PyExc_ValueError, "input array is not a python object");
 …
       PyErr_SetString (PyExc_ValueError, "input array is a scalar");
       goto fail;
     } else if (PyArray_NDIM (input) > 2) {
+    } else if (PyArray_NDIM (input) > 1) {
       PyErr_SetString (PyExc_ValueError,
           "input array has more than two dimensions");
+          "input array has more than one dimensions");
       goto fail;
+    }
 …
       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 AUBIO_NPY_SMPL");
-        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
 …
     // create a new fvec object
     vec = (Py_fvec*) PyObject_New (Py_fvec, &Py_fvecType);
+    if (PyArray_NDIM (array) == 1) {
+      vec->channels = 1;
+      vec->length = PyArray_SIZE (array);
+    } else {
+      vec->channels = PyArray_DIM (array, 0);
+      vec->length = PyArray_DIM (array, 1);
+    }
+    vec->length = PyArray_SIZE (array);
     // no need to really allocate fvec, just its struct member
     // vec->o = new_fvec (vec->length, vec->channels);
+    // vec->o = new_fvec (vec->length);
     vec->o = (fvec_t *)malloc(sizeof(fvec_t));
+    vec->o->length = vec->length; vec->o->channels = vec->channels;
+    vec->o->data = (smpl_t**)malloc(vec->o->channels * sizeof(smpl_t*));
+    // hat data[i] point to array line
+    for (i = 0; i < vec->channels; i++) {
+      vec->o->data[i] = (smpl_t *) PyArray_GETPTR1 (array, i);
+    }
+    vec->o->length = vec->length;
+    vec->o->data = (smpl_t *) PyArray_GETPTR1 (array, 0);
+  } else if (PyObject_TypeCheck (input, &PyList_Type)) {
+    PyErr_SetString (PyExc_ValueError, "does not convert from list yet");
+    return NULL;
   } else {
     PyErr_SetString (PyExc_ValueError, "can only accept array or fvec as input");
+    PyErr_SetString (PyExc_ValueError, "can only accept vector or fvec as input");
     return NULL;
+  }
 …
 PyAubio_CFvecToArray (fvec_t * self)
+{
-  PyObject *array = NULL;
-  uint_t i;
   npy_intp dims[] = { self->length, 1 };
+  PyObject *concat = PyList_New (0), *tmp = NULL;
+  for (i = 0; i < self->channels; i++) {
+    tmp = PyArray_SimpleNewFromData (1, dims, AUBIO_NPY_SMPL, self->data[i]);
+    PyList_Append (concat, tmp);
+    Py_DECREF (tmp);
+  }
+  array = PyArray_FromObject (concat, AUBIO_NPY_SMPL, 2, 2);
+  Py_DECREF (concat);
+  return array;
+  return  PyArray_SimpleNewFromData (1, dims, AUBIO_NPY_SMPL, self->data);
+}
 …
+{
   PyObject *array = NULL;
+  if (self->channels == 1) {
+    npy_intp dims[] = { self->length, 1 };
+    array = PyArray_SimpleNewFromData (1, dims, AUBIO_NPY_SMPL, self->o->data[0]);
+  } else {
+    uint_t i;
+    npy_intp dims[] = { self->length, 1 };
+    PyObject *concat = PyList_New (0), *tmp = NULL;
+    for (i = 0; i < self->channels; i++) {
+      tmp = PyArray_SimpleNewFromData (1, dims, AUBIO_NPY_SMPL, self->o->data[i]);
+      PyList_Append (concat, tmp);
+      Py_DECREF (tmp);
+    }
+    array = PyArray_FromObject (concat, AUBIO_NPY_SMPL, 2, 2);
+    Py_DECREF (concat);
+  }
+  npy_intp dims[] = { self->length, 1 };
+  array = PyArray_SimpleNewFromData (1, dims, AUBIO_NPY_SMPL, self->o->data);
   return array;
+}
-static Py_ssize_t
-Py_fvec_getchannels (Py_fvec * self)
+{
-  return self->channels;
+}
 …
 Py_fvec_getitem (Py_fvec * 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, AUBIO_NPY_SMPL, self->o->data[index]);
+  return array;
+  if (index < 0 || index >= self->length) {
+    PyErr_SetString (PyExc_IndexError, "no such element");
+    return NULL;
+  }
+  return PyFloat_FromDouble (self->o->data[index]);
+}
 …
 Py_fvec_setitem (Py_fvec * 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, AUBIO_NPY_SMPL);
+  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 fvec");
+    goto fail;
+  }
+  self->o->data[index] = (smpl_t *) PyArray_GETPTR1 (array, 0);
+  if (index < 0 || index >= self->length) {
+    PyErr_SetString (PyExc_IndexError, "no such element");
+    goto fail;
+  }
+  if (PyFloat_Check (o)) {
+    PyErr_SetString (PyExc_ValueError, "should be a float");
+    goto fail;
+  }
+  self->o->data[index] = (smpl_t) PyFloat_AsDouble(o);
   return 0;
 …
 fail:
   return -1;
+}
+int
+Py_fvec_get_length (Py_fvec * self)
+{
+  return self->length;
+}
 …
   {"length", T_INT, offsetof (Py_fvec, length), READONLY,
       "length attribute"},
-  {"channels", T_INT, offsetof (Py_fvec, channels), READONLY,
-      "channels attribute"},
   {NULL}                        /* Sentinel */
 };
 …
 static PySequenceMethods Py_fvec_tp_as_sequence = {
   (lenfunc) Py_fvec_getchannels,        /* sq_length         */
+  (lenfunc) Py_fvec_get_length,        /* sq_length         */
 ,                                    /* sq_concat         */
 ,                                    /* sq_repeat         */

interfaces/python/py-phasevoc.c

-                      r0536612
+                      rf658288
 static char Py_pvoc_doc[] = "pvoc object";
 AUBIO_DECLARE(pvoc, uint_t win_s; uint_t hop_s; uint_t channels)
+AUBIO_DECLARE(pvoc, uint_t win_s; uint_t hop_s)
 //AUBIO_NEW(pvoc)
 …
 Py_pvoc_new (PyTypeObject * type, PyObject * args, PyObject * kwds)
+{
   int win_s = 0, hop_s = 0, channels = 0;
+  int win_s = 0, hop_s = 0;
   Py_pvoc *self;
   static char *kwlist[] = { "win_s", "hop_s", "channels", NULL };
+  static char *kwlist[] = { "win_s", "hop_s", NULL };
   if (!PyArg_ParseTupleAndKeywords (args, kwds, "|III", kwlist,
           &win_s, &hop_s, &channels)) {
+  if (!PyArg_ParseTupleAndKeywords (args, kwds, "|II", kwlist,
+          &win_s, &hop_s)) {
     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, self->channels)
+AUBIO_INIT(pvoc, self->win_s, self->hop_s)
 AUBIO_DEL(pvoc)
 …
   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);
+  output->o = new_cvec(((Py_pvoc *) self)->win_s);
   // compute the function
 …
   {"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)
 …
   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);
+  output->o = new_fvec(output->length);
   // compute the function

interfaces/python/setup.py

r0536612	rf658288
11	11	["aubiomodule.c",
12	12	"py-fvec.c",
	13	"py-fmat.c",
13	14	"py-cvec.c",
14	15	"py-filter.c",

interfaces/python/test_aubio.py

-                      r0536612
+                      rf658288
 from _aubio import *
 from numpy import array
-AUBIO_DO_CASTING = 0
 class aubiomodule_test_case(TestCase):
 …
     """ try importing 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__':

src/aubio.h

-                      r0536612
+                      rf658288
   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,
   optionally on several channels. ::cvec_t are used to store complex number,
   as two vectors of norm and phase elements, also on several channels.
+  ::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.
   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, channels);
+  aubio_fft_t *fft = new_aubio_fft (winsize);
   // phase vocoder
   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);
+  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);
   // beat tracking
   aubio_tempo_t *tempo = new_aubio_tempo (method, winsize, stepsize, channels, samplerate);
+  aubio_tempo_t *tempo = new_aubio_tempo (method, winsize, stepsize, samplerate);
   \endcode
 …
   Here is a simple example that creates an A-Weighting filter and applies it to a
   vector.
   \code
   // set channels, window size, and sampling rate
   uint_t channels = 2, winsize = 1024, sr = 44100;
+  // set window size, and sampling rate
+  uint_t winsize = 1024, sr = 44100;
   // create a vector
   fvec_t *this_buffer = new_fvec (winsize, channels);
+  fvec_t *this_buffer = new_fvec (winsize);
   // create the a-weighting filter
   aubio_filter_t *this_filter = new_aubio_filter_a_weighting (channels, sr);
+  aubio_filter_t *this_filter = new_aubio_filter_a_weighting (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"

src/cvec.c

-                      r0536612
+                      rf658288
 #include "cvec.h"
 cvec_t * new_cvec( uint_t length, uint_t channels) {
+cvec_t * new_cvec( uint_t length) {
   cvec_t * s = AUBIO_NEW(cvec_t);
+  uint_t i,j;
+  s->channels = channels;
+  uint_t j;
   s->length = length/2 + 1;
+  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.;
+    }
+  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.;
+  }
   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 channel, uint_t position) {
   s->norm[channel][position] = data;
+void cvec_write_norm(cvec_t *s, smpl_t data, uint_t position) {
+  s->norm[position] = data;
+}
 void cvec_write_phas(cvec_t *s, smpl_t data, uint_t channel, uint_t position) {
   s->phas[channel][position] = data;
+void cvec_write_phas(cvec_t *s, smpl_t data, uint_t position) {
+  s->phas[position] = data;
+}
 smpl_t cvec_read_norm(cvec_t *s, uint_t channel, uint_t position) {
   return s->norm[channel][position];
+smpl_t cvec_read_norm(cvec_t *s, uint_t position) {
+  return s->norm[position];
+}
 smpl_t cvec_read_phas(cvec_t *s, uint_t channel, uint_t position) {
   return s->phas[channel][position];
+smpl_t cvec_read_phas(cvec_t *s, uint_t position) {
+  return s->phas[position];
+}
+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) {
+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 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");
+  uint_t j;
+  AUBIO_MSG("norm: ");
+  for (j=0; j< s->length; j++) {
+    AUBIO_MSG(AUBIO_SMPL_FMT " ", s->norm[j]);
+  }
+  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 i,j;
+  for (i=0; i< s->channels; i++) {
+    for (j=0; j< s->length; j++) {
+      s->norm[i][j] = val;
+    }
+  uint_t j;
+  for (j=0; j< s->length; j++) {
+    s->norm[j] = val;
+  }
+}

src/cvec.h

-                      r0536612
+                      rf658288
 typedef struct {
   uint_t length;   /**< length of buffer = (requested length)/2 + 1 */
+  uint_t channels; /**< number of channels */
+  smpl_t **norm;   /**< norm array of size [length] * [channels] */
+  smpl_t **phas;   /**< phase array of size [length] * [channels] */
+  smpl_t *norm;   /**< norm array of size [length] */
+  smpl_t *phas;   /**< phase array of size [length] */
 } cvec_t;
 …
   This function creates a cvec_t structure holding two arrays of size
   [length/2+1] * channels, corresponding to the norm and phase values of the
+  [length/2+1], 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
-  \param channels the number of channels in the buffer
 */
 cvec_t * new_cvec(uint_t length, uint_t channels);
+cvec_t * new_cvec(uint_t length);
 /** 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[channel][position]. Its purpose
+  result can be obtained by assigning vec->norm[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[channel][position]
+  \param channel channel to write to
+  \param data norm value to write in s->norm[position]
   \param position sample position to write to
 */
 void cvec_write_norm(cvec_t *s, smpl_t data, uint_t channel, uint_t position);
+void cvec_write_norm(cvec_t *s, smpl_t data, 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[channel][position]. Its purpose
+  result can be obtained by assigning vec->phas[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[channel][position]
+  \param channel channel to write to
+  \param data phase value to write in s->phas[position]
   \param position sample position to write to
 */
 void cvec_write_phas(cvec_t *s, smpl_t data, uint_t channel, uint_t position);
+void cvec_write_phas(cvec_t *s, smpl_t data, 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[channel][position]. Its purpose is to
+  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
-  \param channel channel to read from
   \param position sample position to read from
 */
 smpl_t cvec_read_norm(cvec_t *s, uint_t channel, uint_t position);
+smpl_t cvec_read_norm(cvec_t *s, 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[channel][position]. Its purpose is to
+  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
-  \param channel channel to read from
   \param position sample position to read from
 */
+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);
+smpl_t cvec_read_phas(cvec_t *s, uint_t position);
 /** 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

src/fvec.c

-                      r0536612
+                      rf658288
 #include "fvec.h"
 fvec_t * new_fvec( uint_t length, uint_t channels) {
+fvec_t * new_fvec( uint_t length) {
   fvec_t * s = AUBIO_NEW(fvec_t);
+  uint_t i,j;
+  s->channels = channels;
+  uint_t j;
   s->length = length;
+  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.;
+    }
+  s->data = AUBIO_ARRAY(smpl_t, s->length);
+  for (j=0; j< s->length; j++) {
+    s->data[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 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];
+void fvec_write_sample(fvec_t *s, smpl_t data, uint_t position) {
+  s->data[position] = data;
+}
+smpl_t ** fvec_get_data(fvec_t *s) {
+smpl_t fvec_read_sample(fvec_t *s, uint_t position) {
+  return s->data[position];
+}
+smpl_t * fvec_get_data(fvec_t *s) {
   return s->data;
+}
 …
 void fvec_print(fvec_t *s) {
+  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");
+  uint_t j;
+  for (j=0; j< s->length; j++) {
+    AUBIO_MSG(AUBIO_SMPL_FMT " ", s->data[j]);
+  }
+  AUBIO_MSG("\n");
+}
 void fvec_set(fvec_t *s, smpl_t val) {
+  uint_t i,j;
+  for (i=0; i< s->channels; i++) {
+    for (j=0; j< s->length; j++) {
+      s->data[i][j] = val;
+    }
+  uint_t j;
+  for (j=0; j< s->length; j++) {
+    s->data[j] = val;
+  }
+}
 …
 void fvec_rev(fvec_t *s) {
+  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]);
+    }
+  uint_t j;
+  for (j=0; j< FLOOR(s->length/2); j++) {
+    ELEM_SWAP(s->data[j], s->data[s->length-1-j]);
+  }
+}
 void fvec_weight(fvec_t *s, fvec_t *weight) {
   uint_t i,j;
+  uint_t j;
   uint_t length = MIN(s->length, weight->length);
+  for (i=0; i< s->channels; i++) {
+    for (j=0; j< length; j++) {
+      s->data[i][j] *= weight->data[0][j];
+    }
+  for (j=0; j< length; j++) {
+    s->data[j] *= weight->data[j];
+  }
+}
 void fvec_copy(fvec_t *s, fvec_t *t) {
+  uint_t i,j;
+  uint_t channels = MIN(s->channels, t->channels);
+  uint_t j;
   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_ERR("warning, trying to copy %d elements to %d elements \n",
+    AUBIO_WRN("trying to copy %d elements to %d elements \n",
             s->length, t->length);
+  }
+  for (i=0; i< channels; i++) {
+    for (j=0; j< length; j++) {
+      t->data[i][j] = s->data[i][j];
+    }
+  for (j=0; j< length; j++) {
+    t->data[j] = s->data[j];
+  }
+}

src/fvec.h

-                      r0536612
+                      rf658288
 typedef struct {
   uint_t length;   /**< length of buffer */
+  uint_t channels; /**< number of channels */
+  smpl_t **data;   /**< data array of size [length] * [channels] */
+  smpl_t *data;   /**< data array of size [length] */
 } 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, uint_t channels);
+fvec_t * new_fvec(uint_t length);
 /** 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[channel][position]. Its purpose is to
+  result can be obtained using vec->data[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 channel, uint_t position);
+smpl_t fvec_read_sample(fvec_t *s, 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[channel][position]. Its purpose
+  result can be obtained by assigning vec->data[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[channel][position]
+  \param channel channel to write to
+  \param data value to write in s->data[position]
   \param position sample position to write to
 */
+void  fvec_write_sample(fvec_t *s, smpl_t data, uint_t channel, uint_t position);
+/** read channel vector from a buffer
+void  fvec_write_sample(fvec_t *s, smpl_t data, uint_t position);
-  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

src/lvec.c

-                      r0536612
+                      rf658288
 #include "lvec.h"
 lvec_t * new_lvec( uint_t length, uint_t channels) {
+lvec_t * new_lvec( uint_t length) {
   lvec_t * s = AUBIO_NEW(lvec_t);
+  uint_t i,j;
+  s->channels = channels;
+  uint_t j;
   s->length = length;
+  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.;
+    }
+  s->data = AUBIO_ARRAY(lsmp_t, s->length);
+  for (j=0; j< s->length; j++) {
+    s->data[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 channel, uint_t position) {
   s->data[channel][position] = data;
+void lvec_write_sample(lvec_t *s, lsmp_t data, uint_t position) {
+  s->data[position] = data;
+}
+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_read_sample(lvec_t *s, uint_t position) {
+  return s->data[position];
+}
 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 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");
+  uint_t j;
+  for (j=0; j< s->length; j++) {
+    AUBIO_MSG(AUBIO_LSMP_FMT " ", s->data[j]);
+  }
+  AUBIO_MSG("\n");
+}
 void lvec_set(lvec_t *s, smpl_t val) {
+  uint_t i,j;
+  for (i=0; i< s->channels; i++) {
+    for (j=0; j< s->length; j++) {
+      s->data[i][j] = val;
+    }
+  uint_t j;
+  for (j=0; j< s->length; j++) {
+    s->data[j] = val;
+  }
+}

src/lvec.h

-                      r0536612
+                      rf658288
 typedef struct {
   uint_t length;   /**< length of buffer */
+  uint_t channels; /**< number of channels */
+  lsmp_t **data;   /**< data array of size [length] * [channels] */
+  lsmp_t *data;   /**< data array of size [length] */
 } 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, uint_t channels);
+lvec_t * new_lvec(uint_t length);
 /** 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[channel][position]. Its purpose is to
+  result can be obtained using vec->data[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 channel, uint_t position);
+lsmp_t lvec_read_sample(lvec_t *s, 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[channel][position]. Its purpose
+  result can be obtained by assigning vec->data[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[channel][position]
+  \param channel channel to write to
+  \param data value to write in s->data[position]
   \param position sample position to write to
 */
+void  lvec_write_sample(lvec_t *s, lsmp_t data, uint_t channel, uint_t position);
+/** read channel vector from a buffer
+void  lvec_write_sample(lvec_t *s, lsmp_t data, uint_t position);
-  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

src/mathutils.c

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

src/mathutils.h

-                      r0536612
+                      rf658288
 */
 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 channel);
+    uint_t pos);
 /** apply adaptive threshold to a vector
 …
 */
+void fvec_adapt_thres (fvec_t * v, fvec_t * tmp, uint_t post, uint_t pre,
+    uint_t channel);
+void fvec_adapt_thres (fvec_t * v, fvec_t * tmp, uint_t post, uint_t pre);
 /** 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_channel (fvec_t * v, uint_t channel);
+smpl_t fvec_median (fvec_t * v);
 /** finds exact peak index by quadratic interpolation*/
 smpl_t fvec_quadint (fvec_t * x, uint_t pos, uint_t channel);
+smpl_t fvec_quadint (fvec_t * x, uint_t pos);
 /** Quadratic interpolation using Lagrange polynomial.

src/onset/onset.c

-                      r0536612
+                      rf658288
   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);
+  for (i = 0; i < input->channels; i++) {
+  isonset = onset->data[i][0];
+  wasonset = o->wasonset->data[i][0];
+  isonset = onset->data[0];
+  wasonset = o->wasonset->data[0];
   if (isonset > 0.) {
     if (aubio_silence_detection(input, o->silence)==1) {
 …
     wasonset++;
+  }
+  o->wasonset->data[i][0] = wasonset;
+  onset->data[i][0] = isonset;
+  }
+  o->wasonset->data[0] = wasonset;
+  onset->data[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 channels, uint_t samplerate)
+    uint_t buf_size, uint_t hop_size, uint_t samplerate)
+{
   aubio_onset_t * o = AUBIO_NEW(aubio_onset_t);
 …
   o->minioi    = 4;
   o->silence   = -70;
   o->wasonset  = new_fvec(1, channels);
+  o->wasonset  = new_fvec(1);
   o->samplerate = samplerate;
   o->hop_size = hop_size;
   o->pv = new_aubio_pvoc(buf_size, hop_size, channels);
   o->pp = new_aubio_peakpicker(channels);
+  o->pv = new_aubio_pvoc(buf_size, hop_size);
+  o->pp = new_aubio_peakpicker();
   aubio_peakpicker_set_threshold (o->pp, o->threshold);
   o->od = new_aubio_specdesc(onset_mode,buf_size,channels);
   o->fftgrain = new_cvec(buf_size,channels);
   o->of = new_fvec(1, channels);
+  o->od = new_aubio_specdesc(onset_mode,buf_size);
+  o->fftgrain = new_cvec(buf_size);
+  o->of = new_fvec(1);
   /*if (usedoubled)    {
     o2 = new_aubio_specdesc(onset_type2,buffer_size,channels);
     onset2 = new_fvec(1 , channels);
+    o2 = new_aubio_specdesc(onset_type2,buffer_size);
+    onset2 = new_fvec(1);
   }*/
   return o;

src/onset/onset.h

-                      r0536612
+                      rf658288
   \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 channels, uint_t samplerate);
+    uint_t buf_size, uint_t hop_size, uint_t samplerate);
 /** execute onset detection

src/onset/peakpicker.c

-                      r0536612
+                      rf658288
 /** function pointer to thresholding function */
 typedef smpl_t (*aubio_thresholdfn_t)(fvec_t *input, uint_t channel);
+typedef smpl_t (*aubio_thresholdfn_t)(fvec_t *input);
 /** 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 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];
+  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];
+  }
+  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);
+  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);
+    }
+  /* 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);
+  }
+}
 …
 aubio_peakpicker_t *
 new_aubio_peakpicker (uint_t channels)
+new_aubio_peakpicker ()
+{
   aubio_peakpicker_t *t = AUBIO_NEW (aubio_peakpicker_t);
 …
   t->win_post = 5;
   t->win_pre = 1;
+  //channels = 1;
+  t->channels = channels;
+  t->thresholdfn = (aubio_thresholdfn_t) (fvec_median_channel); /* (fvec_mean); */
+  t->thresholdfn = (aubio_thresholdfn_t) (fvec_median); /* (fvec_mean); */
   t->pickerfn = (aubio_pickerfn_t) (fvec_peakpick);
   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);
+  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);
   /* 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, channels);
+      -0.59488894, 0.23484048);
   return t;

src/onset/peakpicker.h

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

src/pitch/pitch.c

-                      r0536612
+                      rf658288
 aubio_pitch_t *
 new_aubio_pitch (char_t * pitch_mode,
     uint_t bufsize, uint_t hopsize, uint_t channels, uint_t samplerate)
+    uint_t bufsize, uint_t hopsize, uint_t samplerate)
+{
   aubio_pitch_t *p = AUBIO_NEW (aubio_pitch_t);
 …
   switch (p->type) {
     case aubio_pitcht_yin:
       p->buf = new_fvec (bufsize, channels);
+      p->buf = new_fvec (bufsize);
       p->yin = new_aubio_pitchyin (bufsize);
       p->callback = aubio_pitch_do_yin;
 …
       break;
     case aubio_pitcht_mcomb:
       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->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->callback = aubio_pitch_do_mcomb;
       break;
     case aubio_pitcht_fcomb:
       p->buf = new_fvec (bufsize, channels);
       p->fcomb = new_aubio_pitchfcomb (bufsize, hopsize, channels);
+      p->buf = new_fvec (bufsize);
+      p->fcomb = new_aubio_pitchfcomb (bufsize, hopsize);
       p->callback = aubio_pitch_do_fcomb;
       break;
     case aubio_pitcht_schmitt:
       p->buf = new_fvec (bufsize, channels);
+      p->buf = new_fvec (bufsize);
       p->schmitt = new_aubio_pitchschmitt (bufsize);
       p->callback = aubio_pitch_do_schmitt;
       break;
     case aubio_pitcht_yinfft:
       p->buf = new_fvec (bufsize, channels);
+      p->buf = new_fvec (bufsize);
       p->yinfft = new_aubio_pitchyinfft (bufsize);
       p->callback = aubio_pitch_do_yinfft;
 …
 aubio_pitch_slideblock (aubio_pitch_t * p, fvec_t * ibuf)
+{
   uint_t i, j = 0, overlap_size = 0;
+  uint_t j = 0, overlap_size = 0;
   overlap_size = p->buf->length - ibuf->length;
+  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];
+    }
+  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];
+  }
+}
 …
 aubio_pitch_do (aubio_pitch_t * p, fvec_t * ibuf, fvec_t * obuf)
+{
-  uint_t i;
   p->callback (p, ibuf, obuf);
+  for (i = 0; i < obuf->channels; i++) {
+    p->freqconv (obuf->data[i][0], p->srate, p->bufsize);
+  }
+  obuf->data[0] = p->freqconv (obuf->data[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);
+  for (i = 0; i < obuf->channels; i++) {
+    obuf->data[i][0] = aubio_bintofreq (obuf->data[i][0], p->srate, p->bufsize);
+  }
+  obuf->data[0] = aubio_bintofreq (obuf->data[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);
+  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;
+  }
+  pitch = obuf->data[0];
+  if (pitch > 0) {
+    pitch = p->srate / (pitch + 0.);
+  } else {
+    pitch = 0.;
+  }
+  obuf->data[0] = pitch;
+}
 …
+{
   smpl_t pitch = 0.;
-  uint_t i;
   aubio_pitch_slideblock (p, ibuf);
   aubio_pitchyinfft_do (p->yinfft, p->buf, obuf);
+  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;
+  }
+  pitch = obuf->data[0];
+  if (pitch > 0) {
+    pitch = p->srate / (pitch + 0.);
+  } else {
+    pitch = 0.;
+  }
+  obuf->data[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);
+  for (i = 0; i < out->channels; i++) {
+    out->data[i][0] = aubio_bintofreq (out->data[i][0], p->srate, p->bufsize);
+  }
+  out->data[0] = aubio_bintofreq (out->data[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);
+  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;
+  }
+}
+  period = out->data[0];
+  if (period > 0) {
+    pitch = p->srate / period;
+  } else {
+    pitch = 0.;
+  }
+  out->data[0] = pitch;
+}

src/pitch/pitch.h

-                      r0536612
+                      rf658288
   \param o pitch detection object as returned by new_aubio_pitch()
   \param in input signal of size [hop_size x channels]
   \param out output pitch candidates of size [1 x channels]
+  \param in input signal of size [hop_size]
+  \param out output pitch candidates of size [1]
 */
 …
   \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 channels, uint_t samplerate);
+    uint_t buf_size, uint_t hop_size, uint_t samplerate);
 /** set the output unit of the pitch detection object

src/pitch/pitchfcomb.c

-                      r0536612
+                      rf658288
 aubio_pitchfcomb_t *
 new_aubio_pitchfcomb (uint_t bufsize, uint_t hopsize, uint_t channels)
+new_aubio_pitchfcomb (uint_t bufsize, uint_t hopsize)
+{
   aubio_pitchfcomb_t *p = AUBIO_NEW (aubio_pitchfcomb_t);
   p->fftSize = bufsize;
   p->stepSize = hopsize;
   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->winput = new_fvec (bufsize);
+  p->fftOut = new_cvec (bufsize);
+  p->fftLastPhase = new_fvec (bufsize);
+  p->fft = new_aubio_fft (bufsize);
   p->win = new_aubio_window ("hanning", bufsize);
   return p;
 …
 aubio_pitchfcomb_do (aubio_pitchfcomb_t * p, fvec_t * input, fvec_t * output)
+{
   uint_t i, k, l, maxharm = 0;
+  uint_t k, l, maxharm = 0;
   smpl_t phaseDifference = TWO_PI * (smpl_t) p->stepSize / (smpl_t) p->fftSize;
   aubio_fpeak_t peaks[MAX_PEAKS];
+  for (i = 0; i < input->channels; i++) {
+  for (k = 0; k < MAX_PEAKS; k++) {
+    peaks[k].db = -200.;
+    peaks[k].bin = 0.;
+  }
+    for (k = 0; k < MAX_PEAKS; k++) {
+      peaks[k].db = -200.;
+      peaks[k].bin = 0.;
+  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 <= p->fftSize / 2; k++) {
+    smpl_t
+        magnitude =
+. * LOG10 (2. * p->fftOut->norm[k] / (smpl_t) p->fftSize),
+        phase = p->fftOut->phas[k], tmp, bin;
+    /* compute phase difference */
+    tmp = phase - p->fftLastPhase->data[k];
+    p->fftLastPhase->data[k] = phase;
+    /* subtract expected phase difference */
+    tmp -= (smpl_t) k *phaseDifference;
+    /* map delta phase into +/- Pi interval */
+    tmp = aubio_unwrap2pi (tmp);
+    /* get deviation from bin frequency from the +/- Pi interval */
+    tmp = p->fftSize / (smpl_t) p->stepSize * tmp / (TWO_PI);
+    /* 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;
+    }
+  }
+    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);
+    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;
+      /* compute phase difference */
+      tmp = phase - p->fftLastPhase->data[i][k];
+      p->fftLastPhase->data[i][k] = phase;
+      /* subtract expected phase difference */
+      tmp -= (smpl_t) k *phaseDifference;
+      /* map delta phase into +/- Pi interval */
+      tmp = aubio_unwrap2pi (tmp);
+      /* get deviation from bin frequency from the +/- Pi interval */
+      tmp = p->fftSize / (smpl_t) p->stepSize * tmp / (TWO_PI);
+      /* 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.;
+}

src/pitch/pitchfcomb.h

-                      r0536612
+                      rf658288
   \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,
+    uint_t channels);
+aubio_pitchfcomb_t *new_aubio_pitchfcomb (uint_t buf_size, uint_t hop_size);
 /** deletion of the pitch detection object

src/pitch/pitchmcomb.c

-                      r0536612
+                      rf658288
 aubio_pitchmcomb_do (aubio_pitchmcomb_t * p, cvec_t * fftgrain, fvec_t * output)
+{
   uint_t i, j;
+  uint_t 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 (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.;
+       } */
+  }
+  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.;
+     } */
+}
 …
 aubio_pitch_cands (aubio_pitchmcomb_t * p, cvec_t * fftgrain, smpl_t * cands)
+{
   uint_t i = 0, j;
+  uint_t 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[i][j] = fftgrain->norm[i][j];
+    newmag->data[j] = fftgrain->norm[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 i = 0, j;
+  uint_t j;
   uint_t length = mag->length;
   /* copy newmag to mag (scracth) */
   for (j = 0; j < length; j++) {
     mag->data[i][j] = newmag->data[i][j];
+    mag->data[j] = newmag->data[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, i);      /* adaptative threshold */
+  fvec_adapt_thres (mag, tmp, p->win_post, p->win_pre);      /* 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[i][peaks[j].bin];
+      peaks[j].mag = newmag->data[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[0][(uint_t) FLOOR (candidate[l]->ecomb[k] + .5)],
+            POW (newmag->data[(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 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.;
+      }
+    }
+  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.;
+    }
+  }
   return count;
+}
 …
 aubio_pitchmcomb_t *
 new_aubio_pitchmcomb (uint_t bufsize, uint_t hopsize, uint_t channels)
+new_aubio_pitchmcomb (uint_t bufsize, uint_t hopsize)
+{
   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, 1);
+  p->newmag = new_fvec (spec_size);
   /* array for median */
   p->scratch = new_fvec (spec_size, 1);
+  p->scratch = new_fvec (spec_size);
   /* array for phase */
   p->theta = new_fvec (spec_size, channels);
+  p->theta = new_fvec (spec_size);
   /* array for adaptative threshold */
   p->scratch2 = new_fvec (p->win_post + p->win_pre + 1, 1);
+  p->scratch2 = new_fvec (p->win_post + p->win_pre + 1);
   /* array of spectral peaks */
   p->peaks = AUBIO_ARRAY (aubio_spectralpeak_t, spec_size);

src/pitch/pitchmcomb.h

-                      r0536612
+                      rf658288
   \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,
+    uint_t channels);
+aubio_pitchmcomb_t *new_aubio_pitchmcomb (uint_t buf_size, uint_t hop_size);
 /** deletion of the pitch detection object

src/pitch/pitchschmitt.c

-                      r0536612
+                      rf658288
     fvec_t * output)
+{
+  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);
+  uint_t j;
+  for (j = 0; j < input->length; j++) {
+    p->buf[j] = input->data[j] * 32768.;
+  }
+  output->data[0] = aubio_schmittS16LE (p, input->length, p->buf);
+}

src/pitch/pitchyin.c

-                      r0536612
+                      rf658288
+{
   aubio_pitchyin_t *o = AUBIO_NEW (aubio_pitchyin_t);
   o->yin = new_fvec (bufsize / 2, 1);
+  o->yin = new_fvec (bufsize / 2);
   o->tol = 0.15;
   return o;
 …
 aubio_pitchyin_diff (fvec_t * input, fvec_t * yin)
+{
   uint_t c, j, tau;
+  uint_t j, tau;
   smpl_t 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);
+      }
+  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);
+    }
+  }
 …
 aubio_pitchyin_getcum (fvec_t * yin)
+{
   uint_t c, tau;
+  uint_t tau;
   smpl_t tmp;
+  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");
+  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]);
+  }
+  //AUBIO_DBG("\n");
+}
 …
 aubio_pitchyin_getpitch (fvec_t * yin)
+{
   uint_t c = 0, tau = 1;
+  uint_t tau = 1;
   do {
     if (yin->data[c][tau] < 0.1) {
       while (yin->data[c][tau + 1] < yin->data[c][tau]) {
+    if (yin->data[tau] < 0.1) {
+      while (yin->data[tau + 1] < yin->data[tau]) {
         tau++;
+      }
 …
   smpl_t tol = o->tol;
   fvec_t *yin = o->yin;
   uint_t c, j, tau = 0;
+  uint_t j, tau = 0;
   sint_t period;
   smpl_t tmp = 0., tmp2 = 0.;
+  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;
+      }
+  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);
+    }
+    out->data[c][0] = fvec_quadint (yin, fvec_min_elem (yin), c);
+  beach:
+    continue;
+    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;
+    }
+  }
+  //return 0;
+  out->data[0] = fvec_quadint (yin, fvec_min_elem (yin));
+beach:
+  return;
+}

src/pitch/pitchyinfft.c

-                      r0536612
+                      rf658288
+{
   aubio_pitchyinfft_t *p = AUBIO_NEW (aubio_pitchyinfft_t);
   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->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->tol = 0.85;
   p->win = new_aubio_window ("hanningz", bufsize);
+  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]));
+  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;
+    }
+    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 i, tau, l;
+  uint_t tau, l;
   uint_t halfperiod;
   smpl_t tmp, sum;
   cvec_t *res = (cvec_t *) p->res;
   fvec_t *yin = (fvec_t *) p->yinfft;
+  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];
+  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);
+    } 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);
+    }
+    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 {
+      output->data[i][0] = 0.;
+    }
+  } else {
+    output->data[0] = 0.;
+  }
+}

src/spectral/fft.c

-                      r0536612
+                      rf658288
 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, uint_t channels) {
+aubio_fft_t * new_aubio_fft(uint_t winsize) {
   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,channels);
+  s->compspec = new_fvec(winsize);
   /* create plans */
 #ifdef HAVE_COMPLEX_H
 …
 void aubio_fft_do_complex(aubio_fft_t * s, fvec_t * input, fvec_t * compspec) {
+  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
+  }
+  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
+}
 void aubio_fft_rdo_complex(aubio_fft_t * s, fvec_t * compspec, fvec_t * output) {
   uint_t i, j;
+  uint_t j;
   const smpl_t renorm = 1./(smpl_t)s->winsize;
+  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;
+    }
+#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;
+  }
+}
 …
 void aubio_fft_get_phas(fvec_t * compspec, cvec_t * spectrum) {
+  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.;
+    }
+  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.;
+  }
+}
 void aubio_fft_get_norm(fvec_t * compspec, cvec_t * spectrum) {
+  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]);
+  }
+  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]);
+}
 void aubio_fft_get_imag(cvec_t * spectrum, fvec_t * compspec) {
+  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]);
+    }
+  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]);
+  }
+}
 void aubio_fft_get_real(cvec_t * spectrum, fvec_t * compspec) {
+  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]);
+    }
+  }
+}
+  uint_t j;
+  for (j = 0; j < compspec->length / 2 + 1; j++) {
+    compspec->data[j] =
+      spectrum->norm[j]*COS(spectrum->phas[j]);
+  }
+}

src/spectral/fft.h

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

src/spectral/filterbank.c

-                      r0536612
+                      rf658288
 #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;
   fvec_t *filters;
+  fmat_t *filters;
 };
 …
   fb->n_filters = 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);
+  /* allocate filter tables, a matrix of length win_s and of height n_filters */
+  fb->filters = new_fmat (win_s / 2 + 1, n_filters);
   return fb;
 …
 del_aubio_filterbank (aubio_filterbank_t * fb)
+{
   del_fvec (fb->filters);
+  del_fmat (fb->filters);
   AUBIO_FREE (fb);
+}
 …
 aubio_filterbank_do (aubio_filterbank_t * f, cvec_t * in, fvec_t * out)
+{
   uint_t i, j, fn;
+  uint_t 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);
   /* apply filters on all channels */
   for (i = 0; i < max_channels; i++) {
+  /* for each filter */
+  for (fn = 0; fn < max_filters; fn++) {
+    /* 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];
+      }
+    /* for each sample */
+    for (j = 0; j < max_length; j++) {
+      out->data[fn] += in->norm[j] * f->filters->data[fn][j];
+    }
+  }
 …
+}
 fvec_t *
+fmat_t *
 aubio_filterbank_get_coeffs (aubio_filterbank_t * f)
+{
 …
 uint_t
 aubio_filterbank_set_coeffs (aubio_filterbank_t * f, fvec_t * filters)
+aubio_filterbank_set_coeffs (aubio_filterbank_t * f, fmat_t * filter_coeffs)
+{
   fvec_copy(filters, f->filters);
+  fmat_copy(filter_coeffs, f->filters);
   return 0;
+}

src/spectral/filterbank.h

-                      r0536612
+                      rf658288
 void aubio_filterbank_do (aubio_filterbank_t * fb, cvec_t * in, fvec_t * out);
 /** return a pointer to the fvec object containing all filter coefficients
+/** return a pointer to the matrix object containing all filter coefficients
   \param f filterbank object to get coefficients from
  */
 fvec_t *aubio_filterbank_get_coeffs (aubio_filterbank_t * f);
+fmat_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, fvec_t * filters);
+uint_t aubio_filterbank_set_coeffs (aubio_filterbank_t * f, fmat_t * filters);
 #ifdef __cplusplus

src/spectral/filterbank_mel.c

-                      r0536612
+                      rf658288
 #include "aubio_priv.h"
+#include "fmat.h"
 #include "fvec.h"
 #include "cvec.h"
 …
+{
   fvec_t *filters = aubio_filterbank_get_coeffs (fb);
   uint_t n_filters = filters->channels, win_s = filters->length;
+  fmat_t *filters = aubio_filterbank_get_coeffs (fb);
+  uint_t n_filters = filters->height, win_s = filters->length;
   uint_t fn;                    /* filter counter */
 …
+  }
   if (freqs->data[0][freqs->length - 1] > samplerate / 2) {
+  if (freqs->data[freqs->length - 1] > samplerate / 2) {
     AUBIO_WRN ("Nyquist frequency is %fHz, but highest frequency band ends at \
 %fHz\n", samplerate / 2, freqs->data[0][freqs->length - 1]);
+%fHz\n", samplerate / 2, freqs->data[freqs->length - 1]);
+  }
   /* convenience reference to lower/center/upper frequency for each triangle */
   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);
+  fvec_t *lower_freqs = new_fvec (n_filters);
+  fvec_t *upper_freqs = new_fvec (n_filters);
+  fvec_t *center_freqs = new_fvec (n_filters);
   /* height of each triangle */
   fvec_t *triangle_heights = new_fvec (n_filters, 1);
+  fvec_t *triangle_heights = new_fvec (n_filters);
   /* lookup table of each bin frequency in hz */
   fvec_t *fft_freqs = new_fvec (win_s, 1);
+  fvec_t *fft_freqs = new_fvec (win_s);
   /* fill up the lower/center/upper */
   for (fn = 0; fn < n_filters; fn++) {
     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];
+    lower_freqs->data[fn] = freqs->data[fn];
+    center_freqs->data[fn] = freqs->data[fn + 1];
+    upper_freqs->data[fn] = freqs->data[fn + 2];
+  }
   /* compute triangle heights so that each triangle has unit area */
   for (fn = 0; fn < n_filters; fn++) {
     triangle_heights->data[0][fn] =
 . / (upper_freqs->data[0][fn] - lower_freqs->data[0][fn]);
+    triangle_heights->data[fn] =
+. / (upper_freqs->data[fn] - lower_freqs->data[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[0][bin] =
+    fft_freqs->data[bin] =
         aubio_bintofreq (bin, samplerate, (win_s - 1) * 2);
+  }
   /* zeroing of all filters */
   fvec_zeros (filters);
   if (fft_freqs->data[0][1] >= lower_freqs->data[0][0]) {
+  fmat_zeros (filters);
+  if (fft_freqs->data[1] >= lower_freqs->data[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][0]) - 1;
+        (uint_t) FLOOR (samplerate / lower_freqs->data[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[0][1], lower_freqs->data[0][0],
         upper_freqs->data[0][0], (win_s - 1) * 2,
+        fft_freqs->data[1], lower_freqs->data[0],
+        upper_freqs->data[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[0][bin] <= lower_freqs->data[0][fn] &&
           fft_freqs->data[0][bin + 1] > lower_freqs->data[0][fn]) {
+      if (fft_freqs->data[bin] <= lower_freqs->data[fn] &&
+          fft_freqs->data[bin + 1] > lower_freqs->data[fn]) {
         bin++;
         break;
 …
     /* compute positive slope step size */
     smpl_t riseInc =
         triangle_heights->data[0][fn] /
         (center_freqs->data[0][fn] - lower_freqs->data[0][fn]);
+        triangle_heights->data[fn] /
+        (center_freqs->data[fn] - lower_freqs->data[fn]);
     /* compute coefficients in positive slope */
     for (; bin < win_s - 1; bin++) {
       filters->data[fn][bin] =
           (fft_freqs->data[0][bin] - lower_freqs->data[0][fn]) * riseInc;
       if (fft_freqs->data[0][bin + 1] >= center_freqs->data[0][fn]) {
+          (fft_freqs->data[bin] - lower_freqs->data[fn]) * riseInc;
+      if (fft_freqs->data[bin + 1] >= center_freqs->data[fn]) {
         bin++;
         break;
 …
     /* compute negative slope step size */
     smpl_t downInc =
         triangle_heights->data[0][fn] /
         (upper_freqs->data[0][fn] - center_freqs->data[0][fn]);
+        triangle_heights->data[fn] /
+        (upper_freqs->data[fn] - center_freqs->data[fn]);
     /* compute coefficents in negative slope */
     for (; bin < win_s - 1; bin++) {
       filters->data[fn][bin] +=
           (upper_freqs->data[0][fn] - fft_freqs->data[0][bin]) * downInc;
+          (upper_freqs->data[fn] - fft_freqs->data[bin]) * downInc;
       if (filters->data[fn][bin] < 0.) {
 …
+      }
       if (fft_freqs->data[0][bin + 1] >= upper_freqs->data[0][fn])
+      if (fft_freqs->data[bin + 1] >= upper_freqs->data[fn])
         break;
+    }
 …
   /* buffers to compute filter frequencies */
   fvec_t *freqs = new_fvec (n_filters + 2, 1);
+  fvec_t *freqs = new_fvec (n_filters + 2);
   /* first step: fill all the linear filter frequencies */
   for (fn = 0; fn < linearFilters; fn++) {
     freqs->data[0][fn] = lowestFrequency + fn * linearSpacing;
+  }
   smpl_t lastlinearCF = freqs->data[0][fn - 1];
+    freqs->data[fn] = lowestFrequency + fn * linearSpacing;
+  }
+  smpl_t lastlinearCF = freqs->data[fn - 1];
   /* second step: fill all the log filter frequencies */
   for (fn = 0; fn < logFilters + 2; fn++) {
     freqs->data[0][fn + linearFilters] =
+    freqs->data[fn + linearFilters] =
         lastlinearCF * (POW (logSpacing, fn + 1));
+  }

src/spectral/mfcc.c

-                      r0536612
+                      rf658288
 #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] */
   fvec_t *dct_coeffs;       /** DCT transform n_filters * n_coeffs */
+  fmat_t *dct_coeffs;       /** DCT transform n_filters * n_coeffs */
 };
 …
   /* allocating buffers */
   mfcc->in_dct = new_fvec (n_filters, 1);
+  mfcc->in_dct = new_fvec (n_filters);
   mfcc->dct_coeffs = new_fvec (n_coefs, n_filters);
+  mfcc->dct_coeffs = new_fmat (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 i, j, k;
+  uint_t j, k;
   /* compute filterbank */
 …
   /* compute discrete cosine transform */
+  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];
+      }
+  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];
+    }
+  }

src/spectral/phasevoc.c

-                      r0536612
+                      rf658288
   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) {
+  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);
+  }
+  /* slide  */
+  aubio_pvoc_swapbuffers(pv->data->data,pv->dataold->data,
+      datanew->data,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);
+  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_addsynth(pv->synth->data,pv->synthold->data,
+      synthnew->data,pv->win_s,pv->hop_s);
+}
 aubio_pvoc_t * new_aubio_pvoc (uint_t win_s, uint_t hop_s, uint_t channels) {
+aubio_pvoc_t * new_aubio_pvoc (uint_t win_s, uint_t hop_s) {
   aubio_pvoc_t * pv = AUBIO_NEW(aubio_pvoc_t);
 …
+  }
   pv->fft      = new_aubio_fft(win_s,channels);
+  pv->fft      = new_aubio_fft (win_s);
   /* remember old */
   pv->data     = new_fvec (win_s, channels);
   pv->synth    = new_fvec (win_s, channels);
+  pv->data     = new_fvec (win_s);
+  pv->synth    = new_fvec (win_s);
   /* new input output */
   pv->dataold  = new_fvec  (win_s-hop_s, channels);
   pv->synthold = new_fvec (win_s-hop_s, channels);
+  pv->dataold  = new_fvec  (win_s-hop_s);
+  pv->synthold = new_fvec (win_s-hop_s);
   pv->w        = new_aubio_window ("hanningz", win_s);
-  pv->channels = channels;
   pv->hop_s    = hop_s;
   pv->win_s    = win_s;

src/spectral/phasevoc.h

-                      r0536612
+                      rf658288
   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. Multiple channels are fully supported.
+  at creation time.
 */
 …
   \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, uint_t channels);
+aubio_pvoc_t * new_aubio_pvoc (uint_t win_s, uint_t hop_s);
 /** delete phase vocoder object
 …
 /** compute spectral frame
   This function accepts an input vector of size [channels]x[hop_s]. The
+  This function accepts an input vector of size [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
   [channels]x[buf_s] and computes its inverse Fourier transform. Overlap-add
+  [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

src/spectral/specdesc.c

-                      r0536612
+                      rf658288
 void aubio_specdesc_energy  (aubio_specdesc_t *o UNUSED,
     cvec_t * fftgrain, fvec_t * onset) {
+  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]);
+    }
+  uint_t j;
+  onset->data[0] = 0.;
+  for (j=0;j<fftgrain->length;j++) {
+    onset->data[0] += SQR(fftgrain->norm[j]);
+  }
+}
 …
 void aubio_specdesc_hfc(aubio_specdesc_t *o UNUSED,
     cvec_t * fftgrain, fvec_t * onset){
+  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];
+    }
+  uint_t j;
+  onset->data[0] = 0.;
+  for (j=0;j<fftgrain->length;j++) {
+    onset->data[0] += (j+1)*fftgrain->norm[j];
+  }
+}
 …
 /* Complex Domain Method onset detection function */
 void aubio_specdesc_complex (aubio_specdesc_t *o, cvec_t * fftgrain, fvec_t * onset) {
   uint_t i, j;
+  uint_t j;
   uint_t nbins = fftgrain->length;
+  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];
+    }
+  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];
+  }
+}
 …
 void aubio_specdesc_phase(aubio_specdesc_t *o,
     cvec_t * fftgrain, fvec_t * onset){
   uint_t i, j;
+  uint_t j;
   uint_t nbins = fftgrain->length;
+  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);
+  }
+  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);
+}
 …
 void aubio_specdesc_specdiff(aubio_specdesc_t *o,
     cvec_t * fftgrain, fvec_t * onset){
   uint_t i, j;
+  uint_t j;
   uint_t nbins = fftgrain->length;
+  for (i=0;i<fftgrain->channels; i++)  {
+    onset->data[i][0] = 0.0;
+    onset->data[0] = 0.0;
     for (j=0;j<nbins; 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]);
+      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]);
       else
         o->dev1->data[i][j] = 0.0;
       o->oldmag->data[i][j] = fftgrain->norm[i][j];
+        o->dev1->data[j] = 0.0;
+      o->oldmag->data[j] = fftgrain->norm[j];
+    }
 …
     aubio_hist_weight(o->histog);
     /* its mean is the result */
+    onset->data[i][0] = aubio_hist_mean(o->histog);
+  }
+    onset->data[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 i,j;
+  for (i=0;i<fftgrain->channels;i++) {
+    onset->data[i][0] = 0.;
+  uint_t j;
+    onset->data[0] = 0.;
     for (j=0;j<fftgrain->length;j++) {
       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];
+      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[i][0])) onset->data[i][0] = 0.;
+  }
+    if (isnan(onset->data[0])) onset->data[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 i,j;
+  for (i=0;i<fftgrain->channels;i++) {
+    onset->data[i][0] = 0.;
+  uint_t j;
+    onset->data[0] = 0.;
     for (j=0;j<fftgrain->length;j++) {
       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];
+      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[i][0])) onset->data[i][0] = 0.;
+  }
+    if (isnan(onset->data[0])) onset->data[0] = 0.;
+}
 /* Spectral flux */
 void aubio_specdesc_specflux(aubio_specdesc_t *o, cvec_t * fftgrain, fvec_t * onset){
+  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];
+    }
+  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];
+  }
+}
 …
  */
 aubio_specdesc_t *
+new_aubio_specdesc (char_t * onset_mode,
+    uint_t size, uint_t channels){
+new_aubio_specdesc (char_t * onset_mode, uint_t size){
   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,channels);
       o->dev1   = new_fvec(rsize,channels);
       o->theta1 = new_fvec(rsize,channels);
       o->theta2 = new_fvec(rsize,channels);
+      o->oldmag = new_fvec(rsize);
+      o->dev1   = new_fvec(rsize);
+      o->theta1 = new_fvec(rsize);
+      o->theta2 = new_fvec(rsize);
       break;
     case aubio_onset_phase:
       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->dev1   = new_fvec(rsize);
+      o->theta1 = new_fvec(rsize);
+      o->theta2 = new_fvec(rsize);
+      o->histog = new_aubio_hist(0.0, PI, 10);
       o->threshold = 0.1;
       break;
     case aubio_onset_specdiff:
       o->oldmag = new_fvec(rsize,channels);
       o->dev1   = new_fvec(rsize,channels);
       o->histog = new_aubio_hist(0.0, PI, 10, channels);
+      o->oldmag = new_fvec(rsize);
+      o->dev1   = new_fvec(rsize);
+      o->histog = new_aubio_hist(0.0, PI, 10);
       o->threshold = 0.1;
       break;
 …
     case aubio_onset_mkl:
     case aubio_onset_specflux:
       o->oldmag = new_fvec(rsize,channels);
+      o->oldmag = new_fvec(rsize);
       break;
     default:

src/spectral/specdesc.h

-                      r0536612
+                      rf658288
   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 and per channel (stored in a vector of size [channels]x[1]).
+  buffer (stored in a vector of size [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,
+    uint_t channels);
+aubio_specdesc_t *new_aubio_specdesc (char_t * method, uint_t buf_size);
 /** deletion of a spectral descriptor

src/spectral/statistics.c

-                      r0536612
+                      rf658288
 smpl_t
 cvec_sum_channel (cvec_t * s, uint_t i)
+cvec_sum (cvec_t * s)
+{
   uint_t j;
   smpl_t tmp = 0.0;
+  for (j = 0; j < s->length; j++)
+      tmp += s->norm[i][j];
+  for (j = 0; j < s->length; j++) {
+    tmp += s->norm[j];
+  }
   return tmp;
+}
 smpl_t
 cvec_mean_channel (cvec_t * s, uint_t i)
+cvec_mean (cvec_t * s)
+{
   return cvec_sum_channel(s, i) / (smpl_t) (s->length);
+  return cvec_sum (s) / (smpl_t) (s->length);
+}
 smpl_t
 cvec_centroid_channel (cvec_t * spec, uint_t i)
+cvec_centroid (cvec_t * spec)
+{
   smpl_t sum = 0., sc = 0.;
   uint_t j;
   sum = cvec_sum_channel (spec, i);
+  sum = cvec_sum (spec);
   if (sum == 0.) {
     return 0.;
   } else {
     for (j = 0; j < spec->length; j++) {
       sc += (smpl_t) j *spec->norm[i][j];
+      sc += (smpl_t) j *spec->norm[j];
+    }
     return sc / sum;
 …
 smpl_t
 cvec_moment_channel (cvec_t * spec, uint_t i, uint_t order)
+cvec_moment (cvec_t * spec, uint_t order)
+{
   smpl_t sum = 0., centroid = 0., sc = 0.;
   uint_t j;
   sum = cvec_sum_channel (spec, i);
+  sum = cvec_sum (spec);
   if (sum == 0.) {
     return 0.;
   } else {
     centroid = cvec_centroid_channel (spec, i);
+    centroid = cvec_centroid (spec);
     for (j = 0; j < spec->length; j++) {
       sc += (smpl_t) POW(j - centroid, order) * spec->norm[i][j];
+      sc += (smpl_t) POW(j - centroid, order) * spec->norm[j];
+    }
     return sc / sum;
 …
     fvec_t * desc)
+{
+  uint_t i;
+  for (i = 0; i < spec->channels; i++) {
+    desc->data[i][0] = cvec_centroid_channel (spec, i);
+  }
+  desc->data[0] = cvec_centroid (spec);
+}
 …
     fvec_t * desc)
+{
+  uint_t i;
+  for (i = 0; i < spec->channels; i++) {
+    desc->data[i][0] = cvec_moment_channel (spec, i, 2);
+  }
+  desc->data[0] = cvec_moment (spec, 2);
+}
 …
     fvec_t * desc)
+{
+  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);
+    }
+  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);
+  }
+}
 …
     fvec_t * desc)
+{
+  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);
+    }
+  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);
+  }
+}
 …
     fvec_t * desc)
+{
   uint_t i, j;
+  uint_t 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. );
+  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;
+  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];
+    }
+    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 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;
+  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;
+    }
+    desc->data[0] /= sum;
+  }
+}
 …
     fvec_t *desc)
+{
+  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]);
+  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++;
+    }
+    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;
+    }
+    desc->data[0] = j;
+  }
+}

src/spectral/tss.c

-                      r0536612
+                      rf658288
     cvec_t * trans, cvec_t * stead)
+{
   uint_t i,j;
+  uint_t 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 (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++){
+    dev[j] = aubio_unwrap2pi(input->phas[j]
+        -2.0*theta1[j]+theta2[j]);
+    theta2[j] = theta1[j];
+    theta1[j] = input->phas[j];
+  }
     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++){
+    /* 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++){
       /* 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;
+  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;
+      /*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;
+    }
+    /*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;
+  }
+}
 …
+}
 aubio_tss_t * new_aubio_tss(uint_t buf_size, uint_t hop_size, uint_t channels)
+aubio_tss_t * new_aubio_tss(uint_t buf_size, uint_t hop_size)
+{
   aubio_tss_t * o = AUBIO_NEW(aubio_tss_t);
 …
   o->beta = 4.;
   o->parm = o->threshold*o->thrsfact;
   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);
+  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);
   return o;
+}

src/spectral/tss.h

-                      r0536612
+                      rf658288
   \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, uint_t channels);
+aubio_tss_t *new_aubio_tss (uint_t buf_size, uint_t hop_size);
 /** delete tss object

src/tempo/beattracking.c

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

src/tempo/beattracking.h

-                      r0536612
+                      rf658288
   \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, uint_t channels);
+aubio_beattracking_t * new_aubio_beattracking(uint_t hop_size);
 /** track the beat

src/tempo/tempo.c

-                      r0536612
+                      rf658288
   /*if (usedoubled) {
     aubio_specdesc_do(o2,fftgrain, onset2);
     onset->data[0][0] *= onset2->data[0][0];
+    onset->data[0] *= onset2->data[0];
   }*/
   /* execute every overlap_size*step */
 …
     /* rotate dfframe */
     for (i = 0 ; i < winlen - step; i++ )
       o->dfframe->data[0][i] = o->dfframe->data[0][i+step];
+      o->dfframe->data[i] = o->dfframe->data[i+step];
     for (i = winlen - step ; i < winlen; i++ )
       o->dfframe->data[0][i] = 0.;
+      o->dfframe->data[i] = 0.;
     o->blockpos = -1;
+  }
   o->blockpos++;
   aubio_peakpicker_do (o->pp, o->of, o->onset);
   tempo->data[0][1] = o->onset->data[0][0];
+  tempo->data[1] = o->onset->data[0];
   thresholded = aubio_peakpicker_get_thresholded_input(o->pp);
   o->dfframe->data[0][winlen - step + o->blockpos] = thresholded->data[0][0];
+  o->dfframe->data[winlen - step + o->blockpos] = thresholded->data[0];
   /* end of second level loop */
   tempo->data[0][0] = 0; /* reset tactus */
+  tempo->data[0] = 0; /* reset tactus */
   i=0;
   for (i = 1; i < o->out->data[0][0]; i++ ) {
+  for (i = 1; i < o->out->data[0]; i++ ) {
     /* if current frame is a predicted 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 */
+    if (o->blockpos == FLOOR(o->out->data[i])) {
+      tempo->data[0] = o->out->data[i] - FLOOR(o->out->data[i]); /* set tactus */
       /* test for silence */
       if (aubio_silence_detection(input, o->silence)==1) {
         tempo->data[0][1] = 0; /* unset onset */
+        tempo->data[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 channels, uint_t samplerate)
+    uint_t buf_size, uint_t hop_size, uint_t samplerate)
+{
   aubio_tempo_t * o = AUBIO_NEW(aubio_tempo_t);
 …
   o->silence = -90.;
   o->blockpos = 0;
   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);
+  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();
   aubio_peakpicker_set_threshold (o->pp, o->threshold);
   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);
+  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);
   /*if (usedoubled)    {
     o2 = new_aubio_specdesc(type_onset2,buffer_size,channels);
     onset2 = new_fvec(1 , channels);
+    o2 = new_aubio_specdesc(type_onset2,buffer_size);
+    onset2 = new_fvec(1);
   }*/
   return o;

src/tempo/tempo.h

r0536612	rf658288
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 ~~channels, uint_t~~ samplerate);
	42	uint_t buf_size, uint_t hop_size, uint_t samplerate);
43	43
44	44	/** execute tempo detection */

src/temporal/a_weighting.c

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

src/temporal/a_weighting.h

-                      r0536612
+                      rf658288
 /** 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 channels,
+    uint_t samplerate);
+aubio_filter_t *new_aubio_filter_a_weighting (uint_t samplerate);
 /** set feedback and feedforward coefficients of a A-weighting filter

src/temporal/biquad.c

-                      r0536612
+                      rf658288
     return AUBIO_FAIL;
+  }
   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;
+  bs->data[0] = b0;
+  bs->data[1] = b1;
+  bs->data[2] = b2;
+  as->data[0] = 1.;
+  as->data[1] = a1;
+  as->data[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,
+    uint_t channels)
+new_aubio_filter_biquad (lsmp_t b0, lsmp_t b1, lsmp_t b2, lsmp_t a1, lsmp_t a2)
+{
   aubio_filter_t *f = new_aubio_filter (3, channels);
+  aubio_filter_t *f = new_aubio_filter (3);
   aubio_filter_set_biquad (f, b0, b1, b2, a1, a2);
   return f;

src/temporal/biquad.h

-                      r0536612
+                      rf658288
   \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, uint_t channels);
+    lsmp_t a1, lsmp_t a2);
 #ifdef __cplusplus

src/temporal/c_weighting.c

-                      r0536612
+                      rf658288
   lvec_t *bs = aubio_filter_get_feedforward (f);
   lvec_t *as = aubio_filter_get_feedback (f);
   lsmp_t *b = bs->data[0], *a = as->data[0];
+  lsmp_t *b = bs->data, *a = as->data;
   uint_t order = aubio_filter_get_order (f);
 …
+}
 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_t * new_aubio_filter_c_weighting (uint_t samplerate) {
+  aubio_filter_t * f = new_aubio_filter(5);
   aubio_filter_set_c_weighting (f, samplerate);
   return f;

src/temporal/c_weighting.h

-                      r0536612
+                      rf658288
 /** 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 channels,
+    uint_t samplerate);
+aubio_filter_t *new_aubio_filter_c_weighting (uint_t samplerate);
 /** set feedback and feedforward coefficients of a C-weighting filter

src/temporal/filter.c

-                      r0536612
+                      rf658288
 aubio_filter_do (aubio_filter_t * f, fvec_t * in)
+{
   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];
+  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;
+  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];
+      }
+  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];
+    }
+    /* store for next run */
+    f->x->data[i] = x;
+    f->y->data[i] = y;
+    /* 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];
+    }
+  }
+}
 …
 aubio_filter_do_filtfilt (aubio_filter_t * f, fvec_t * in, fvec_t * tmp)
+{
   uint_t j, i = 0;
+  uint_t j;
   uint_t length = in->length;
   /* apply filtering */
 …
   /* mirror */
   for (j = 0; j < length; j++)
     tmp->data[i][length - j - 1] = in->data[i][j];
+    tmp->data[length - j - 1] = in->data[j];
   /* apply filtering on mirrored */
   aubio_filter_do (f, tmp);
 …
   /* invert back */
   for (j = 0; j < length; j++)
     in->data[i][j] = tmp->data[i][length - j - 1];
+    in->data[j] = tmp->data[length - j - 1];
+}
 …
 aubio_filter_t *
 new_aubio_filter (uint_t order, uint_t channels)
+new_aubio_filter (uint_t order)
+{
   aubio_filter_t *f = AUBIO_NEW (aubio_filter_t);
   f->x = new_lvec (order, channels);
   f->y = new_lvec (order, channels);
   f->a = new_lvec (order, 1);
   f->b = new_lvec (order, 1);
+  f->x = new_lvec (order);
+  f->y = new_lvec (order);
+  f->a = new_lvec (order);
+  f->b = new_lvec (order);
   /* by default, samplerate is not set */
   f->samplerate = 0;
   f->order = order;
   /* set default to identity */
   f->a->data[0][1] = 1.;
+  f->a->data[1] = 1.;
   return f;
+}

src/temporal/filter.h

-                      r0536612
+                      rf658288
   Digital filter
   This object stores a digital filter of order \f$n\f$ for \f$c\f$ channels.
+  This object stores a digital filter of order \f$n\f$.
   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 an order
   and a specific number of channels.
+  This function creates a new ::aubio_filter_t object, given the order of the
+  filter.
   \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, uint_t channels);
+aubio_filter_t *new_aubio_filter (uint_t order);
 /** delete a filter object

src/temporal/resampler.c

-                      r0536612
+                      rf658288
 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;
+  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);
+  }
+  /* 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);
+}
 …
 void
 del_aubio_resampler (aubio_resampler_t * s)
+del_aubio_resampler (aubio_resampler_t * s UNUSED)
+{
+}
 void
 aubio_resampler_do (aubio_resampler_t * s, fvec_t * input, fvec_t * output)
+aubio_resampler_do (aubio_resampler_t * s UNUSED, fvec_t * input UNUSED, fvec_t * output UNUSED)
+{
+}

src/utils/hist.c

-                      r0536612
+                      rf658288
   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, uint_t channels){
+aubio_hist_t * new_aubio_hist (smpl_t ilow, smpl_t ihig, uint_t nelems){
   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, channels);
   s->cent = new_fvec(nelems, 1);
+  s->hist = new_fvec(nelems);
+  s->cent = new_fvec(nelems);
   /* 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][0] = ilow + 0.5 * step;
+  s->cent->data[0] = ilow + 0.5 * step;
   for (i=1; i < s->nelems; i++, accum+=step )
     s->cent->data[0][i] = s->cent->data[0][0] + accum;
+    s->cent->data[i] = s->cent->data[0] + accum;
   return s;
 …
  */
 void aubio_hist_do (aubio_hist_t *s, fvec_t *input) {
   uint_t i,j;
+  uint_t j;
   sint_t tmp = 0;
   aubio_scale_do(s->scaler, input);
   /* reset data */
+  for (i=0; i < s->channels; i++)
+    for (j=0; j < s->nelems; j++)
+      s->hist->data[i][j] = 0;
+  fvec_zeros(s->hist);
   /* run accum */
+  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;
+  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;
+    }
+  }
+}
 void aubio_hist_do_notnull (aubio_hist_t *s, fvec_t *input) {
   uint_t i,j;
+  uint_t j;
   sint_t tmp = 0;
   aubio_scale_do(s->scaler, input);
   /* reset data */
+  for (i=0; i < s->channels; i++)
+    for (j=0; j < s->nelems; j++)
+      s->hist->data[i][j] = 0;
+  fvec_zeros(s->hist);
   /* run accum */
+  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;
+      }
+  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;
+    }
+  }
+}
 void aubio_hist_dyn_notnull (aubio_hist_t *s, fvec_t *input) {
   uint_t i,j;
+  uint_t i;
   sint_t tmp = 0;
   smpl_t ilow = fvec_min(input);
 …
   /* recalculate centers */
   s->cent->data[0][0] = ilow + 0.5f * step;
+  s->cent->data[0] = ilow + 0.5f * step;
   for (i=1; i < s->nelems; i++)
     s->cent->data[0][i] = s->cent->data[0][0] + i * step;
+    s->cent->data[i] = s->cent->data[0] + i * step;
   /* scale */
 …
   /* reset data */
+  for (i=0; i < s->channels; i++)
+    for (j=0; j < s->nelems; j++)
+      s->hist->data[i][j] = 0;
+  fvec_zeros(s->hist);
   /* run accum */
+  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;
+      }
+  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;
+    }
+  }
+}
 void aubio_hist_weight (aubio_hist_t *s) {
+  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];
+    }
+  uint_t j;
+  for (j=0; j < s->nelems; j++) {
+    s->hist->data[j] *= s->cent->data[j];
+  }
+}
 smpl_t aubio_hist_mean (aubio_hist_t *s) {
   uint_t i,j;
+  uint_t j;
   smpl_t tmp = 0.0;
+  for (i=0; i < s->channels; i++)
+    for (j=0; j < s->nelems; j++)
+      tmp += s->hist->data[i][j];
+  for (j=0; j < s->nelems; j++)
+    tmp += s->hist->data[j];
   return tmp/(smpl_t)(s->nelems);
+}

src/utils/hist.h

-                      r0536612
+                      rf658288
  * \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, uint_t channels);
+aubio_hist_t * new_aubio_hist(smpl_t flow, smpl_t fhig, uint_t nelems);
 /** histogram deletion */
 void del_aubio_hist(aubio_hist_t *s);

src/utils/scale.c

-                      r0536612
+                      rf658288
 void aubio_scale_do (aubio_scale_t *s, fvec_t *input)
+{
+  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;
+    }
+  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;
+  }
+}

src/vecutils.c

-                      r0536612
+                      rf658288
 void TYPE ## _ ## OPNAME (TYPE ## _t *o) \
 { \
+  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]); \
+    } \
+  uint_t j; \
+  for (j = 0; j < o->length; j++) { \
+    o->OBJ[j] = OP (o->OBJ[j]); \
   } \
+}
 …
 void fvec_pow (fvec_t *s, smpl_t 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);
+    }
+  uint_t j;
+  for (j = 0; j < s->length; j++) {
+    s->data[j] = POW(s->data[j], power);
+  }
+}
 …
 void cvec_pow (cvec_t *s, smpl_t 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);
+    }
+  uint_t j;
+  for (j = 0; j < s->length; j++) {
+    s->norm[j] = POW(s->norm[j], power);
+  }
+}

swig/aubio.i

-                      r0536612
+                      rf658288
 /* fvec */
 fvec_t * new_fvec(uint_t length, uint_t channels);
+fvec_t * new_fvec(uint_t length);
 void del_fvec(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);
+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);
 /* cvec */
 cvec_t * new_cvec(uint_t length, uint_t channels);
+cvec_t * new_cvec(uint_t length);
 void del_cvec(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);
+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);
 /* fft */
 aubio_fft_t * new_aubio_fft(uint_t size, uint_t channels);
+aubio_fft_t * new_aubio_fft(uint_t size);
 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, uint_t channels);
+aubio_filter_t * new_aubio_filter(uint_t order);
 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 channels, uint_t samplerate);
+aubio_filter_t * new_aubio_filter_a_weighting (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 channels, uint_t samplerate);
+aubio_filter_t * new_aubio_filter_c_weighting (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, uint_t channels);
+aubio_filter_t * new_aubio_filter_biquad(lsmp_t b1, lsmp_t b2, lsmp_t b3, lsmp_t a2, lsmp_t a3);
 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, uint_t channels);
+aubio_pvoc_t * new_aubio_pvoc (uint_t win_s, uint_t hop_s);
 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 channels, uint_t samplerate);
+    uint_t bufsize, uint_t hopsize, 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 channels, uint_t samplerate);
+    uint_t buf_size, uint_t hop_size, 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,
+  uint_t channels);
+aubio_specdesc_t *new_aubio_specdesc (char_t * method, uint_t buf_size);
 void del_aubio_specdesc (aubio_specdesc_t * o);
 /* peak picker */
 aubio_peakpicker_t * new_aubio_peakpicker(uint_t channels);
+aubio_peakpicker_t * new_aubio_peakpicker();
 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);

tests/src/temporal/test-aweighting.c

-                      r0536612
+                      rf658288
   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 (channels, samplerate);
+    f = new_aubio_filter_a_weighting (samplerate);
     del_aubio_filter (f);
     f = new_aubio_filter (7, channels*2);
+    f = new_aubio_filter (7);
     aubio_filter_set_a_weighting (f, samplerate);
     del_aubio_filter (f);
 …
   // samplerate unknown
   f = new_aubio_filter_a_weighting (channels, 4200);
+  f = new_aubio_filter_a_weighting (4200);
   del_aubio_filter (f);
   // order to small
   f = new_aubio_filter (2, channels*2);
+  f = new_aubio_filter (2);
   aubio_filter_set_a_weighting (f, samplerate);
   del_aubio_filter (f);
   // order to big
   f = new_aubio_filter (12, channels*2);
+  f = new_aubio_filter (12);
   aubio_filter_set_a_weighting (f, samplerate);
   del_aubio_filter (f);

tests/src/temporal/test-cweighting.c

-                      r0536612
+                      rf658288
   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 (channels, samplerate);
+    f = new_aubio_filter_c_weighting (samplerate);
     del_aubio_filter (f);
     f = new_aubio_filter (5, channels*2);
+    f = new_aubio_filter (5);
     aubio_filter_set_c_weighting (f, samplerate);
     del_aubio_filter (f);
 …
   // samplerate unknown
   f = new_aubio_filter_c_weighting (channels, 4200);
+  f = new_aubio_filter_c_weighting (4200);
   del_aubio_filter (f);
   // order to small
   f = new_aubio_filter (2, channels*2);
+  f = new_aubio_filter (2);
   aubio_filter_set_c_weighting (f, samplerate);
   del_aubio_filter (f);
   // order to big
   f = new_aubio_filter (12, channels*2);
+  f = new_aubio_filter (12);
   aubio_filter_set_c_weighting (f, samplerate);
   del_aubio_filter (f);

tests/src/test-beattracking.c

-                      r0536612
+                      rf658288
         /* allocate some memory */
         uint_t win_s      = 1024;                       /* window size */
+        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 */
+        fvec_t * in       = new_fvec (win_s); /* input buffer */
+        fvec_t * out      = new_fvec (win_s/4);     /* input buffer */
         /* allocate fft and other memory space */
         aubio_beattracking_t * tempo  = new_aubio_beattracking(win_s, channels);
+        aubio_beattracking_t * tempo  = new_aubio_beattracking(win_s);
         uint_t i = 0;

tests/src/test-biquad.c

-                      r0536612
+                      rf658288
         /* allocate some memory */
         uint_t win_s      = 1024;                       /* window size */
+        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);
+        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);
         aubio_filter_do_filtfilt(o,in,in);

tests/src/test-cvec.c

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

tests/src/test-fft.c

-                      r0536612
+                      rf658288
         /* allocate some memory */
         uint_t win_s      = 8;                       /* window size        */
+        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;
+        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;
         /* allocate fft and other memory space */
         aubio_fft_t * fft = new_aubio_fft(win_s,channels);
+        aubio_fft_t * fft = new_aubio_fft(win_s);
         /* fill input with some data */
         fvec_print(in);

tests/src/test-filter.c

-                      r0536612
+                      rf658288
   /* allocate some memory */
   uint_t win_s = 32;            /* window size */
+  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 */
+  fvec_t *in = new_fvec (win_s);      /* input buffer */
+  fvec_t *out = new_fvec (win_s);     /* input buffer */
   aubio_filter_t *o = new_aubio_filter_c_weighting (channels, 44100);
   in->data[0][12] = 0.5;
+  aubio_filter_t *o = new_aubio_filter_c_weighting (44100);
+  in->data[12] = 0.5;
   fvec_print (in);
   aubio_filter_do (o, in);
 …
   del_aubio_filter (o);
   o = new_aubio_filter_c_weighting (channels, 44100);
   in->data[0][12] = 0.5;
+  o = new_aubio_filter_c_weighting (44100);
+  in->data[12] = 0.5;
   fvec_print (in);
   aubio_filter_do_outplace (o, in, out);
 …
   del_aubio_filter (o);
   o = new_aubio_filter_c_weighting (channels, 44100);
   in->data[0][12] = 0.5;
+  o = new_aubio_filter_c_weighting (44100);
+  in->data[12] = 0.5;
   fvec_print (in);
   aubio_filter_do_filtfilt (o, in, out);

tests/src/test-filterbank.c

-                      r0536612
+                      rf658288
   /* 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, channels);      /* input buffer */
   fvec_t *out = new_fvec (win_s, channels);     /* input buffer */
   fvec_t *coeffs = NULL;
+  cvec_t *in = new_cvec (win_s);      /* input buffer */
+  fvec_t *out = new_fvec (win_s);     /* input buffer */
+  fmat_t *coeffs = NULL;
   /* allocate fft and other memory space */
 …
+  }
+  /*
   if (fvec_max (coeffs) != 0.) {
     return -1;
 …
     return -1;
+  }
+  */
   fvec_print (coeffs);
+  fmat_print (coeffs);
   aubio_filterbank_do (o, in, out);

tests/src/test-filterbank_mel.c

-                      r0536612
+                      rf658288
   /* 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, channels);      /* input buffer */
   fvec_t *out = new_fvec (win_s, channels);     /* input buffer */
   fvec_t *coeffs = NULL;
+  cvec_t *in = new_cvec (win_s);      /* input buffer */
+  fvec_t *out = new_fvec (win_s);     /* input buffer */
+  fmat_t *coeffs = NULL;
   smpl_t samplerate = 16000.;
 …
+  }
   //fvec_print (coeffs);
+  //fmat_print (coeffs);
   //fprintf(stderr, "%f\n", fvec_sum(coeffs));

tests/src/test-fvec.c

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

tests/src/test-hist.c

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

tests/src/test-mfcc.c

-                      r0536612
+                      rf658288
   /* 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, channels);      /* input buffer */
   fvec_t *out = new_fvec (n_coefs, channels);     /* input buffer */
+  cvec_t *in = new_cvec (win_s);      /* input buffer */
+  fvec_t *out = new_fvec (n_coefs);     /* input buffer */
   smpl_t samplerate = 16000.;

tests/src/test-onset.c

-                      r0536612
+                      rf658288
         /* allocate some memory */
         uint_t win_s      = 1024;                       /* window size */
+        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.);
+        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 i = 0;

tests/src/test-onsetdetection.c

-                      r0536612
+                      rf658288
+{
   uint_t win_s = 1024;          /* window size */
+  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 */
+  cvec_t *in = new_cvec (win_s);      /* input buffer */
+  fvec_t *out = new_fvec (1); /* input buffer */
   aubio_specdesc_t *o;
   o = new_aubio_specdesc ("energy", win_s, channels);
+  o = new_aubio_specdesc ("energy", win_s);
   aubio_specdesc_do (o, in, out);
   del_aubio_specdesc (o);
   o = new_aubio_specdesc ("energy", win_s, channels);
+  o = new_aubio_specdesc ("energy", win_s);
   aubio_specdesc_do (o, in, out);
   del_aubio_specdesc (o);
   o = new_aubio_specdesc ("hfc", win_s, channels);
+  o = new_aubio_specdesc ("hfc", win_s);
   aubio_specdesc_do (o, in, out);
   del_aubio_specdesc (o);
   o = new_aubio_specdesc ("complex", win_s, channels);
+  o = new_aubio_specdesc ("complex", win_s);
   aubio_specdesc_do (o, in, out);
   del_aubio_specdesc (o);
   o = new_aubio_specdesc ("phase", win_s, channels);
+  o = new_aubio_specdesc ("phase", win_s);
   aubio_specdesc_do (o, in, out);
   del_aubio_specdesc (o);
   o = new_aubio_specdesc ("kl", win_s, channels);
+  o = new_aubio_specdesc ("kl", win_s);
   aubio_specdesc_do (o, in, out);
   del_aubio_specdesc (o);
   o = new_aubio_specdesc ("mkl", win_s, channels);
+  o = new_aubio_specdesc ("mkl", win_s);
   aubio_specdesc_do (o, in, out);
   del_aubio_specdesc (o);

tests/src/test-peakpick.c

-                      r0536612
+                      rf658288
         /* allocate some memory */
         uint_t win_s      = 1024;                       /* window size */
+        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 */
+        fvec_t * in       = new_fvec (win_s); /* input buffer */
+        fvec_t * out      = new_fvec (1); /* input buffer */
         aubio_peakpicker_t * o = new_aubio_peakpicker(1);
         aubio_peakpicker_set_threshold (o, 0.3);

tests/src/test-phasevoc-jack.c

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

tests/src/test-phasevoc.c

-                      r0536612
+                      rf658288
         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, 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      */
+        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      */
         /* allocate fft and other memory space */
         aubio_pvoc_t * pv = new_aubio_pvoc(win_s,hop_s,channels);
+        aubio_pvoc_t * pv = new_aubio_pvoc(win_s,hop_s);
         /* fill input with some data */
         printf("initialised\n");

tests/src/test-pitchdetection.c

-                      r0536612
+                      rf658288
   uint_t hop_s = win_s / 4;     /* hop size */
   uint_t samplerate = 44100;    /* samplerate */
+  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 */
+  fvec_t *in = new_fvec (hop_s);      /* input buffer */
+  fvec_t *out = new_fvec (1); /* input buffer */
   aubio_pitch_t *o =
       new_aubio_pitch ("default", win_s, hop_s, channels, samplerate);
+      new_aubio_pitch ("default", win_s, hop_s, samplerate);
   uint_t i = 0;

tests/src/test-pitchfcomb.c

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

tests/src/test-pitchmcomb.c

-                      r0536612
+                      rf658288
         uint_t win_s      = 1024;                       /* window size */
         uint_t hop_s      = win_s/4;                    /* hop size */
+        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 */
+        cvec_t * in       = new_cvec (win_s); /* input buffer */
+        fvec_t * out      = new_fvec (1); /* input buffer */
         aubio_pitchmcomb_t * o  = new_aubio_pitchmcomb(win_s, hop_s, channels);
+        aubio_pitchmcomb_t * o  = new_aubio_pitchmcomb(win_s, hop_s);
         uint_t i = 0;

tests/src/test-pitchschmitt.c

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

tests/src/test-pitchyin.c

-                      r0536612
+                      rf658288
         /* allocate some memory */
         uint_t win_s      = 1024;                       /* window size */
+        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 */
+        fvec_t * in       = new_fvec (win_s); /* input buffer */
+        fvec_t * out      = new_fvec (win_s/2); /* input buffer */
         aubio_pitchyin_t *p = new_aubio_pitchyin (win_s);
         uint_t i = 0;

tests/src/test-pitchyinfft.c

-                      r0536612
+                      rf658288
         /* allocate some memory */
         uint_t win_s      = 1024;                       /* window size */
+        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 */
+        fvec_t * in       = new_fvec (win_s); /* input buffer */
+        fvec_t * out      = new_fvec (1); /* output pitch periods */
         aubio_pitchyinfft_t * o  = new_aubio_pitchyinfft(win_s);
         aubio_pitchyinfft_set_tolerance (o, 0.2);

tests/src/test-resample.c

-                      r0536612
+                      rf658288
   /* 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, channels);      /* input buffer */
   fvec_t *out = new_fvec ((uint_t) (win_s * ratio), channels);  /* input buffer */
+  fvec_t *in = new_fvec (win_s);      /* input buffer */
+  fvec_t *out = new_fvec ((uint_t) (win_s * ratio));  /* input buffer */
   aubio_resampler_t *o = new_aubio_resampler (0.5, 0);
   uint_t i = 0;

tests/src/test-scale.c

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

tests/src/test-tempo.c

-                      r0536612
+                      rf658288
         /* allocate some memory */
         uint_t win_s      = 1024;                       /* window size */
+        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.);
+        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 i = 0;

tests/src/test-tss.c

-                      r0536612
+                      rf658288
         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, 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      */
+        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      */
         /* allocate fft and other memory space */
         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_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_tss_t *  tss = new_aubio_tss(win_s,hop_s,channels);
+        aubio_tss_t *  tss = new_aubio_tss(win_s,hop_s);
         /* fill input with some data */
         printf("initialised\n");

Context Navigation

Changes in / [0536612:f658288]

Legend:

Download in other formats: