Index: src/pitch/pitch.c
===================================================================
--- src/pitch/pitch.c	(revision 63f3c70e15951dd1bf7caa8d0d2e6cc18d69e3c0)
+++ src/pitch/pitch.c	(revision fddfa647d845149f90a4116483d287487f4b841c)
@@ -36,5 +36,6 @@
 
 /** pitch detection algorithm */
-typedef enum {
+typedef enum
+{
   aubio_pitcht_yin,     /**< YIN algorithm */
   aubio_pitcht_mcomb,   /**< Multi-comb filter */
@@ -46,5 +47,6 @@
 
 /** pitch detection output mode */
-typedef enum {
+typedef enum
+{
   aubio_pitchm_freq,   /**< Frequency (Hz) */
   aubio_pitchm_midi,   /**< MIDI note (0.,127) */
@@ -55,49 +57,56 @@
 
 typedef void (*aubio_pitch_func_t)
-  (aubio_pitch_t *p, fvec_t * ibuf, fvec_t *obuf);
+  (aubio_pitch_t * p, fvec_t * ibuf, fvec_t * obuf);
 typedef smpl_t (*aubio_pitch_conv_t)
   (smpl_t value, uint_t srate, uint_t bufsize);
 
-void aubio_pitch_slideblock(aubio_pitch_t *p, fvec_t *ibuf);
-
-void aubio_pitch_do_mcomb   (aubio_pitch_t *p, fvec_t *ibuf, fvec_t *obuf);
-void aubio_pitch_do_yin     (aubio_pitch_t *p, fvec_t *ibuf, fvec_t *obuf);
-void aubio_pitch_do_schmitt (aubio_pitch_t *p, fvec_t *ibuf, fvec_t *obuf);
-void aubio_pitch_do_fcomb   (aubio_pitch_t *p, fvec_t *ibuf, fvec_t *obuf);
-void aubio_pitch_do_yinfft  (aubio_pitch_t *p, fvec_t *ibuf, fvec_t *obuf);
+void aubio_pitch_slideblock (aubio_pitch_t * p, fvec_t * ibuf);
+
+void aubio_pitch_do_mcomb (aubio_pitch_t * p, fvec_t * ibuf, fvec_t * obuf);
+void aubio_pitch_do_yin (aubio_pitch_t * p, fvec_t * ibuf, fvec_t * obuf);
+void aubio_pitch_do_schmitt (aubio_pitch_t * p, fvec_t * ibuf, fvec_t * obuf);
+void aubio_pitch_do_fcomb (aubio_pitch_t * p, fvec_t * ibuf, fvec_t * obuf);
+void aubio_pitch_do_yinfft (aubio_pitch_t * p, fvec_t * ibuf, fvec_t * obuf);
 
 /** generic pitch detection structure */
-struct _aubio_pitch_t {
+struct _aubio_pitch_t
+{
   aubio_pitch_type type; /**< pitch detection mode */
   aubio_pitch_mode mode; /**< pitch detection output mode */
   uint_t srate;                   /**< samplerate */
   uint_t bufsize;                 /**< buffer size */
-  aubio_pitchmcomb_t * mcomb;     /**< mcomb object */
-  aubio_pitchfcomb_t * fcomb;     /**< fcomb object */
-  aubio_pitchschmitt_t * schmitt; /**< schmitt object */
-  aubio_pitchyinfft_t * yinfft;   /**< yinfft object */
-  aubio_pitchyin_t * yin;   /**< yinfft object */
-  aubio_filter_t * filter;        /**< filter */
-  aubio_pvoc_t * pv;              /**< phase vocoder for mcomb */ 
-  cvec_t * fftgrain;              /**< spectral frame for mcomb */
-  fvec_t * buf;                   /**< temporary buffer for yin */
+  aubio_pitchmcomb_t *mcomb;      /**< mcomb object */
+  aubio_pitchfcomb_t *fcomb;      /**< fcomb object */
+  aubio_pitchschmitt_t *schmitt;  /**< schmitt object */
+  aubio_pitchyinfft_t *yinfft;    /**< yinfft object */
+  aubio_pitchyin_t *yin;    /**< yinfft object */
+  aubio_filter_t *filter;         /**< filter */
+  aubio_pvoc_t *pv;               /**< phase vocoder for mcomb */
+  cvec_t *fftgrain;               /**< spectral frame for mcomb */
+  fvec_t *buf;                    /**< temporary buffer for yin */
   aubio_pitch_func_t callback; /**< pointer to current pitch detection method */
-  aubio_pitch_conv_t freqconv; /**< pointer to current pitch conversion method */ 
+  aubio_pitch_conv_t freqconv; /**< pointer to current pitch conversion method */
 };
 
 /* convenience wrapper function for frequency unit conversions 
  * should probably be rewritten with #defines */
-smpl_t freqconvbin(smpl_t f,uint_t srate,uint_t bufsize);
-smpl_t freqconvbin(smpl_t f,uint_t srate,uint_t bufsize){
-  return aubio_freqtobin(f,srate,bufsize);
-}
-
-smpl_t freqconvmidi(smpl_t f,uint_t srate,uint_t bufsize);
-smpl_t freqconvmidi(smpl_t f,uint_t srate UNUSED,uint_t bufsize UNUSED){
-  return aubio_freqtomidi(f);
-}
-
-smpl_t freqconvpass(smpl_t f,uint_t srate,uint_t bufsize);
-smpl_t freqconvpass(smpl_t f,uint_t srate UNUSED,uint_t bufsize UNUSED){
+smpl_t freqconvbin (smpl_t f, uint_t srate, uint_t bufsize);
+smpl_t
+freqconvbin (smpl_t f, uint_t srate, uint_t bufsize)
+{
+  return aubio_freqtobin (f, srate, bufsize);
+}
+
+smpl_t freqconvmidi (smpl_t f, uint_t srate, uint_t bufsize);
+smpl_t
+freqconvmidi (smpl_t f, uint_t srate UNUSED, uint_t bufsize UNUSED)
+{
+  return aubio_freqtomidi (f);
+}
+
+smpl_t freqconvpass (smpl_t f, uint_t srate, uint_t bufsize);
+smpl_t
+freqconvpass (smpl_t f, uint_t srate UNUSED, uint_t bufsize UNUSED)
+{
   return f;
 }
@@ -107,22 +116,23 @@
     uint_t bufsize, uint_t hopsize, uint_t channels, uint_t samplerate)
 {
-  aubio_pitch_t *p = AUBIO_NEW(aubio_pitch_t);
+  aubio_pitch_t *p = AUBIO_NEW (aubio_pitch_t);
   aubio_pitch_type pitch_type;
   if (strcmp (pitch_mode, "mcomb") == 0)
-      pitch_type = aubio_pitcht_mcomb;
+    pitch_type = aubio_pitcht_mcomb;
   else if (strcmp (pitch_mode, "yinfft") == 0)
-      pitch_type = aubio_pitcht_yin;
+    pitch_type = aubio_pitcht_yin;
   else if (strcmp (pitch_mode, "yin") == 0)
-      pitch_type = aubio_pitcht_yin;
+    pitch_type = aubio_pitcht_yin;
   else if (strcmp (pitch_mode, "schmitt") == 0)
-      pitch_type = aubio_pitcht_schmitt;
+    pitch_type = aubio_pitcht_schmitt;
   else if (strcmp (pitch_mode, "fcomb") == 0)
-      pitch_type = aubio_pitcht_fcomb;
+    pitch_type = aubio_pitcht_fcomb;
   else if (strcmp (pitch_mode, "default") == 0)
-      pitch_type = aubio_pitcht_default;
+    pitch_type = aubio_pitcht_default;
   else {
-      AUBIO_ERR ("unknown pitch detection method %s, using default.\n", pitch_mode);
-      pitch_type = aubio_pitcht_default;
-      return NULL;
+    AUBIO_ERR ("unknown pitch detection method %s, using default.\n",
+        pitch_mode);
+    pitch_type = aubio_pitcht_default;
+    return NULL;
   }
   p->srate = samplerate;
@@ -130,31 +140,31 @@
   aubio_pitch_set_unit (p, "default");
   p->bufsize = bufsize;
-  switch(p->type) {
+  switch (p->type) {
     case aubio_pitcht_yin:
-      p->buf      = new_fvec(bufsize,channels);
-      p->yin      = new_aubio_pitchyin(bufsize);
+      p->buf = new_fvec (bufsize, channels);
+      p->yin = new_aubio_pitchyin (bufsize);
       p->callback = aubio_pitch_do_yin;
       aubio_pitchyin_set_tolerance (p->yin, 0.15);
       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, channels);
+      p->fftgrain = new_cvec (bufsize, channels);
+      p->mcomb = new_aubio_pitchmcomb (bufsize, hopsize, channels);
+      p->filter = new_aubio_filter_c_weighting (samplerate, channels);
       p->callback = aubio_pitch_do_mcomb;
       break;
     case aubio_pitcht_fcomb:
-      p->buf      = new_fvec(bufsize,channels);
-      p->fcomb    = new_aubio_pitchfcomb(bufsize,hopsize,channels);
+      p->buf = new_fvec (bufsize, channels);
+      p->fcomb = new_aubio_pitchfcomb (bufsize, hopsize, channels);
       p->callback = aubio_pitch_do_fcomb;
       break;
     case aubio_pitcht_schmitt:
-      p->buf      = new_fvec(bufsize,channels);
-      p->schmitt  = new_aubio_pitchschmitt(bufsize);
+      p->buf = new_fvec (bufsize, channels);
+      p->schmitt = new_aubio_pitchschmitt (bufsize);
       p->callback = aubio_pitch_do_schmitt;
       break;
     case aubio_pitcht_yinfft:
-      p->buf      = new_fvec(bufsize,channels);
-      p->yinfft   = new_aubio_pitchyinfft(bufsize);
+      p->buf = new_fvec (bufsize, channels);
+      p->yinfft = new_aubio_pitchyinfft (bufsize);
       p->callback = aubio_pitch_do_yinfft;
       aubio_pitchyinfft_set_tolerance (p->yinfft, 0.85);
@@ -166,67 +176,73 @@
 }
 
-void del_aubio_pitch(aubio_pitch_t * p) {
-  switch(p->type) {
+void
+del_aubio_pitch (aubio_pitch_t * p)
+{
+  switch (p->type) {
     case aubio_pitcht_yin:
-      del_fvec(p->buf);
-      del_aubio_pitchyin(p->yin);
+      del_fvec (p->buf);
+      del_aubio_pitchyin (p->yin);
       break;
     case aubio_pitcht_mcomb:
-      del_aubio_pvoc(p->pv);
-      del_cvec(p->fftgrain);
-      del_aubio_filter(p->filter);
-      del_aubio_pitchmcomb(p->mcomb);
+      del_aubio_pvoc (p->pv);
+      del_cvec (p->fftgrain);
+      del_aubio_filter (p->filter);
+      del_aubio_pitchmcomb (p->mcomb);
       break;
     case aubio_pitcht_schmitt:
-      del_fvec(p->buf);
-      del_aubio_pitchschmitt(p->schmitt);
+      del_fvec (p->buf);
+      del_aubio_pitchschmitt (p->schmitt);
       break;
     case aubio_pitcht_fcomb:
-      del_fvec(p->buf);
-      del_aubio_pitchfcomb(p->fcomb);
+      del_fvec (p->buf);
+      del_aubio_pitchfcomb (p->fcomb);
       break;
     case aubio_pitcht_yinfft:
-      del_fvec(p->buf);
-      del_aubio_pitchyinfft(p->yinfft);
+      del_fvec (p->buf);
+      del_aubio_pitchyinfft (p->yinfft);
       break;
     default:
       break;
   }
-  AUBIO_FREE(p);
-}
-
-void aubio_pitch_slideblock(aubio_pitch_t *p, fvec_t *ibuf){
-  uint_t i,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];
-    }
-  }
-}
-
-uint_t aubio_pitch_set_unit (aubio_pitch_t *p, char_t * pitch_unit) {
+  AUBIO_FREE (p);
+}
+
+void
+aubio_pitch_slideblock (aubio_pitch_t * p, fvec_t * ibuf)
+{
+  uint_t i, 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];
+    }
+  }
+}
+
+uint_t
+aubio_pitch_set_unit (aubio_pitch_t * p, char_t * pitch_unit)
+{
   aubio_pitch_mode pitch_mode;
   if (strcmp (pitch_unit, "freq") == 0)
-      pitch_mode = aubio_pitchm_freq;
+    pitch_mode = aubio_pitchm_freq;
   else if (strcmp (pitch_unit, "midi") == 0)
-      pitch_mode = aubio_pitchm_midi;
+    pitch_mode = aubio_pitchm_midi;
   else if (strcmp (pitch_unit, "cent") == 0)
-      pitch_mode = aubio_pitchm_cent;
+    pitch_mode = aubio_pitchm_cent;
   else if (strcmp (pitch_unit, "bin") == 0)
-      pitch_mode = aubio_pitchm_bin;
+    pitch_mode = aubio_pitchm_bin;
   else if (strcmp (pitch_unit, "default") == 0)
-      pitch_mode = aubio_pitchm_default;
+    pitch_mode = aubio_pitchm_default;
   else {
-      AUBIO_ERR ("unknown pitch detection unit %s, using default\n", pitch_unit);
-      pitch_mode = aubio_pitchm_default;
+    AUBIO_ERR ("unknown pitch detection unit %s, using default\n", pitch_unit);
+    pitch_mode = aubio_pitchm_default;
   }
   p->mode = pitch_mode;
-  switch(p->mode) {
+  switch (p->mode) {
     case aubio_pitchm_freq:
       p->freqconv = freqconvpass;
@@ -248,6 +264,8 @@
 }
 
-uint_t aubio_pitch_set_tolerance(aubio_pitch_t *p, smpl_t tol) {
-  switch(p->type) {
+uint_t
+aubio_pitch_set_tolerance (aubio_pitch_t * p, smpl_t tol)
+{
+  switch (p->type) {
     case aubio_pitcht_yin:
       aubio_pitchyin_set_tolerance (p->yin, tol);
@@ -262,17 +280,21 @@
 }
 
-void aubio_pitch_do (aubio_pitch_t *p, fvec_t * ibuf, fvec_t *obuf) {
-  uint_t i;
-  p->callback(p, ibuf, obuf);
+void
+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);
-  }
-}
-
-void 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);
+    p->freqconv (obuf->data[i][0], p->srate, p->bufsize);
+  }
+}
+
+void
+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);
@@ -280,13 +302,15 @@
 }
 
-void aubio_pitch_do_yin(aubio_pitch_t *p, fvec_t *ibuf, fvec_t * obuf) {
+void
+aubio_pitch_do_yin (aubio_pitch_t * p, fvec_t * ibuf, fvec_t * obuf)
+{
   smpl_t pitch = 0.;
   uint_t i;
-  aubio_pitch_slideblock(p,ibuf);
-  aubio_pitchyin_do(p->yin,p->buf, obuf);
+  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.);
+    if (pitch > 0) {
+      pitch = p->srate / (pitch + 0.);
     } else {
       pitch = 0.;
@@ -297,13 +321,15 @@
 
 
-void aubio_pitch_do_yinfft(aubio_pitch_t *p, fvec_t *ibuf, fvec_t * obuf){
+void
+aubio_pitch_do_yinfft (aubio_pitch_t * p, fvec_t * ibuf, fvec_t * obuf)
+{
   smpl_t pitch = 0.;
   uint_t i;
-  aubio_pitch_slideblock(p,ibuf);
-  aubio_pitchyinfft_do(p->yinfft,p->buf,obuf);
+  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.);
+    if (pitch > 0) {
+      pitch = p->srate / (pitch + 0.);
     } else {
       pitch = 0.;
@@ -313,8 +339,10 @@
 }
 
-void 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);
+void
+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);
@@ -322,13 +350,15 @@
 }
 
-void aubio_pitch_do_schmitt(aubio_pitch_t *p, fvec_t *ibuf, fvec_t *out){
+void
+aubio_pitch_do_schmitt (aubio_pitch_t * p, fvec_t * ibuf, fvec_t * out)
+{
   smpl_t period, pitch = 0.;
   uint_t i;
-  aubio_pitch_slideblock(p,ibuf);
-  aubio_pitchschmitt_do(p->schmitt,p->buf, out);
+  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;
+    if (period > 0) {
+      pitch = p->srate / period;
     } else {
       pitch = 0.;
Index: src/pitch/pitch.h
===================================================================
--- src/pitch/pitch.h	(revision 63f3c70e15951dd1bf7caa8d0d2e6cc18d69e3c0)
+++ src/pitch/pitch.h	(revision fddfa647d845149f90a4116483d287487f4b841c)
@@ -45,6 +45,5 @@
 
 */
-void aubio_pitch_do (aubio_pitch_t * o, fvec_t * in,
-    fvec_t * out);
+void aubio_pitch_do (aubio_pitch_t * o, fvec_t * in, fvec_t * out);
 
 /** change yin or yinfft tolerance threshold
@@ -54,6 +53,5 @@
 
 */
-uint_t aubio_pitch_set_tolerance (aubio_pitch_t * o,
-    smpl_t tol);
+uint_t aubio_pitch_set_tolerance (aubio_pitch_t * o, smpl_t tol);
 
 /** deletion of the pitch detection object
@@ -73,5 +71,5 @@
 
 */
-aubio_pitch_t * new_aubio_pitch (char_t * mode,
+aubio_pitch_t *new_aubio_pitch (char_t * mode,
     uint_t bufsize, uint_t hopsize, uint_t channels, uint_t samplerate);
 
@@ -82,6 +80,5 @@
 
 */
-uint_t aubio_pitch_set_unit (aubio_pitch_t * o,
-    char_t * mode);
+uint_t aubio_pitch_set_unit (aubio_pitch_t * o, char_t * mode);
 
 #ifdef __cplusplus
Index: src/pitch/pitchfcomb.c
===================================================================
--- src/pitch/pitchfcomb.c	(revision 63f3c70e15951dd1bf7caa8d0d2e6cc18d69e3c0)
+++ src/pitch/pitchfcomb.c	(revision fddfa647d845149f90a4116483d287487f4b841c)
@@ -30,109 +30,113 @@
 #define MAX_PEAKS 8
 
-typedef struct {
+typedef struct
+{
   smpl_t bin;
   smpl_t db;
 } aubio_fpeak_t;
 
-struct _aubio_pitchfcomb_t {
+struct _aubio_pitchfcomb_t
+{
   uint_t fftSize;
   uint_t stepSize;
   uint_t rate;
-  fvec_t * winput;
-  fvec_t * win;
-  cvec_t * fftOut;
-  fvec_t * fftLastPhase;
-  aubio_fft_t * fft;
+  fvec_t *winput;
+  fvec_t *win;
+  cvec_t *fftOut;
+  fvec_t *fftLastPhase;
+  aubio_fft_t *fft;
 };
 
-aubio_pitchfcomb_t * new_aubio_pitchfcomb (uint_t bufsize, uint_t hopsize, uint_t channels)
+aubio_pitchfcomb_t *
+new_aubio_pitchfcomb (uint_t bufsize, uint_t hopsize, uint_t channels)
 {
-  aubio_pitchfcomb_t * p = AUBIO_NEW(aubio_pitchfcomb_t);
-  p->fftSize      = bufsize;
-  p->stepSize     = hopsize;
-  p->winput       = new_fvec(bufsize,1);
-  p->fftOut       = new_cvec(bufsize,1);
-  p->fftLastPhase = new_fvec(bufsize, channels);
-  p->fft = new_aubio_fft(bufsize, 1);
-  p->win = new_aubio_window("hanning", bufsize);
+  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->win = new_aubio_window ("hanning", bufsize);
   return p;
 }
 
 /* input must be stepsize long */
-void aubio_pitchfcomb_do (aubio_pitchfcomb_t * p, fvec_t * input, fvec_t * output)
+void
+aubio_pitchfcomb_do (aubio_pitchfcomb_t * p, fvec_t * input, fvec_t * output)
 {
   uint_t i, k, l, maxharm = 0;
-  smpl_t phaseDifference = TWO_PI*(smpl_t)p->stepSize/(smpl_t)p->fftSize;
+  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[0][k] = p->win->data[0][k] * input->data[i][k];
-  }
-  aubio_fft_do(p->fft,p->winput,p->fftOut);
+    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 = 20.*LOG10(2.*p->fftOut->norm[0][k]/(smpl_t)p->fftSize),
-      phase     = p->fftOut->phas[0][k],
-      tmp, bin;
+    for (k = 0; k <= p->fftSize / 2; k++) {
+      smpl_t
+          magnitude =
+          20. * 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;
+      /* 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;
+      /* subtract expected phase difference */
+      tmp -= (smpl_t) k *phaseDifference;
 
-    /* map delta phase into +/- Pi interval */
-    tmp = aubio_unwrap2pi(tmp);
+      /* 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);
+      /* 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;
+      /* 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;
+      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[i][0] = peaks[k].bin;
+    /* quick hack to clean output a bit */
+    if (peaks[k].bin > 5000.)
+      output->data[i][0] = 0.;
   }
 }
 
-void del_aubio_pitchfcomb (aubio_pitchfcomb_t * p)
+void
+del_aubio_pitchfcomb (aubio_pitchfcomb_t * p)
 {
-  del_cvec(p->fftOut);
-  del_fvec(p->fftLastPhase);
-  del_fvec(p->win);
-  del_fvec(p->winput);
-  del_aubio_fft(p->fft);
-  AUBIO_FREE(p);
+  del_cvec (p->fftOut);
+  del_fvec (p->fftLastPhase);
+  del_fvec (p->win);
+  del_fvec (p->winput);
+  del_aubio_fft (p->fft);
+  AUBIO_FREE (p);
 }
-
Index: src/pitch/pitchfcomb.h
===================================================================
--- src/pitch/pitchfcomb.h	(revision 63f3c70e15951dd1bf7caa8d0d2e6cc18d69e3c0)
+++ src/pitch/pitchfcomb.h	(revision fddfa647d845149f90a4116483d287487f4b841c)
@@ -50,5 +50,7 @@
  
 */
-void aubio_pitchfcomb_do (aubio_pitchfcomb_t *p, fvec_t * input, fvec_t * output);
+void aubio_pitchfcomb_do (aubio_pitchfcomb_t * p, fvec_t * input,
+    fvec_t * output);
+
 /** creation of the pitch detection object
  
@@ -58,5 +60,7 @@
  
 */
-aubio_pitchfcomb_t * new_aubio_pitchfcomb (uint_t bufsize, uint_t hopsize, uint_t channels);
+aubio_pitchfcomb_t *new_aubio_pitchfcomb (uint_t bufsize, uint_t hopsize,
+    uint_t channels);
+
 /** deletion of the pitch detection object
  
@@ -64,6 +68,5 @@
  
 */
-void del_aubio_pitchfcomb (aubio_pitchfcomb_t *p);
-
+void del_aubio_pitchfcomb (aubio_pitchfcomb_t * p);
 
 #ifdef __cplusplus
Index: src/pitch/pitchmcomb.c
===================================================================
--- src/pitch/pitchmcomb.c	(revision 63f3c70e15951dd1bf7caa8d0d2e6cc18d69e3c0)
+++ src/pitch/pitchmcomb.c	(revision fddfa647d845149f90a4116483d287487f4b841c)
@@ -29,24 +29,30 @@
 typedef struct _aubio_spectralpeak_t aubio_spectralpeak_t;
 typedef struct _aubio_spectralcandidate_t aubio_spectralcandidate_t;
-uint_t aubio_pitchmcomb_get_root_peak(aubio_spectralpeak_t * peaks, uint_t length);
-uint_t aubio_pitchmcomb_quadpick(aubio_spectralpeak_t * spectral_peaks, fvec_t * X);
-void aubio_pitchmcomb_spectral_pp(aubio_pitchmcomb_t * p, fvec_t * oldmag);
-void aubio_pitchmcomb_combdet(aubio_pitchmcomb_t * p, fvec_t * newmag);
+uint_t aubio_pitchmcomb_get_root_peak (aubio_spectralpeak_t * peaks,
+    uint_t length);
+uint_t aubio_pitchmcomb_quadpick (aubio_spectralpeak_t * spectral_peaks,
+    fvec_t * X);
+void aubio_pitchmcomb_spectral_pp (aubio_pitchmcomb_t * p, fvec_t * oldmag);
+void aubio_pitchmcomb_combdet (aubio_pitchmcomb_t * p, fvec_t * newmag);
 /* not used but useful : sort by amplitudes (or anything else)
  * sort_pitchpeak(peaks, length);
  */
 /** spectral_peak comparison function (must return signed int) */
-static sint_t aubio_pitchmcomb_sort_peak_comp(const void *x, const void *y);
+static sint_t aubio_pitchmcomb_sort_peak_comp (const void *x, const void *y);
 /** sort spectral_peak against their mag */
-void aubio_pitchmcomb_sort_peak(aubio_spectralpeak_t * peaks, uint_t nbins);
+void aubio_pitchmcomb_sort_peak (aubio_spectralpeak_t * peaks, uint_t nbins);
 /** select the best candidates */
-uint_t aubio_pitch_cands(aubio_pitchmcomb_t * p, cvec_t * fftgrain, smpl_t * cands);
+uint_t aubio_pitch_cands (aubio_pitchmcomb_t * p, cvec_t * fftgrain,
+    smpl_t * cands);
 
 /** sort spectral_candidate against their comb ene */
-void aubio_pitchmcomb_sort_cand_ene(aubio_spectralcandidate_t ** candidates, uint_t nbins);
+void aubio_pitchmcomb_sort_cand_ene (aubio_spectralcandidate_t ** candidates,
+    uint_t nbins);
 /** sort spectral_candidate against their frequency */
-void aubio_pitchmcomb_sort_cand_freq(aubio_spectralcandidate_t ** candidates, uint_t nbins);
-
-struct _aubio_pitchmcomb_t {
+void aubio_pitchmcomb_sort_cand_freq (aubio_spectralcandidate_t ** candidates,
+    uint_t nbins);
+
+struct _aubio_pitchmcomb_t
+{
   smpl_t threshold;                        /**< offset threshold [0.033 or 0.01]     */
   smpl_t alpha;                            /**< normalisation exponent [9]           */
@@ -61,12 +67,12 @@
   uint_t goodcandidate;                    /**< best candidate                       */
   uint_t spec_partition;                   /**< spectrum partition to consider       */
-  aubio_spectralpeak_t * peaks;            /**< up to length win/spec_partition      */
-  aubio_spectralcandidate_t ** candidates; /** up to five candidates                 */
+  aubio_spectralpeak_t *peaks;             /**< up to length win/spec_partition      */
+  aubio_spectralcandidate_t **candidates;  /** up to five candidates                 */
   /* some scratch pads */
   /** \bug  (unnecessary copied from fftgrain?) */
-  fvec_t * newmag;                         /**< vec to store mag                     */
-  fvec_t * scratch;                        /**< vec to store modified mag            */
-  fvec_t * scratch2;                       /**< vec to compute moving median         */
-  fvec_t * theta;                         /**< vec to store phase                     */
+  fvec_t *newmag;                          /**< vec to store mag                     */
+  fvec_t *scratch;                         /**< vec to store modified mag            */
+  fvec_t *scratch2;                        /**< vec to compute moving median         */
+  fvec_t *theta;                          /**< vec to store phase                     */
   smpl_t phasediff;
   smpl_t phasefreq;
@@ -78,5 +84,6 @@
 
 /** spectral peak object */
-struct _aubio_spectralpeak_t {
+struct _aubio_spectralpeak_t
+{
   uint_t bin;     /**< bin [0-(length-1)] */
   smpl_t ebin;    /**< estimated bin */
@@ -85,7 +92,8 @@
 
 /** spectral candidates array object */
-struct _aubio_spectralcandidate_t {
+struct _aubio_spectralcandidate_t
+{
   smpl_t ebin;    /**< interpolated bin */
-  smpl_t * ecomb; /**< comb */
+  smpl_t *ecomb;  /**< comb */
   smpl_t ene;     /**< candidate energy */
   smpl_t len;     /**< length */
@@ -93,61 +101,65 @@
 
 
-void aubio_pitchmcomb_do (aubio_pitchmcomb_t * p, cvec_t * fftgrain, fvec_t * output) {
-  uint_t i,j;
+void
+aubio_pitchmcomb_do (aubio_pitchmcomb_t * p, cvec_t * fftgrain, fvec_t * output)
+{
+  uint_t i, j;
   smpl_t instfreq;
-  fvec_t * newmag = (fvec_t *)p->newmag;
+  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.) {
+  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_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.;
-  }*/
-  }
-}
-
-uint_t aubio_pitch_cands(aubio_pitchmcomb_t * p, cvec_t * fftgrain,
-    smpl_t * cands) {
-  uint_t i=0,j;
+    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.;
+       } */
+  }
+}
+
+uint_t
+aubio_pitch_cands (aubio_pitchmcomb_t * p, cvec_t * fftgrain, smpl_t * cands)
+{
+  uint_t i = 0, j;
   uint_t k;
-  fvec_t * newmag = (fvec_t *)p->newmag;
-  aubio_spectralcandidate_t ** scands =
-    (aubio_spectralcandidate_t **)(p->candidates);
+  fvec_t *newmag = (fvec_t *) p->newmag;
+  aubio_spectralcandidate_t **scands =
+      (aubio_spectralcandidate_t **) (p->candidates);
   //smpl_t hfc; //fe=instfreq(theta1,theta,ops); //theta1=theta;
   /* copy incoming grain to newmag */
-  for (j=0; j< newmag->length; j++)
-    newmag->data[i][j]=fftgrain->norm[i][j];
+  for (j = 0; j < newmag->length; j++)
+    newmag->data[i][j] = fftgrain->norm[i][j];
   /* detect only if local energy > 10. */
-  if (fvec_local_energy(newmag)>10.) {
+  if (fvec_local_energy (newmag) > 10.) {
     /* hfc = fvec_local_hfc(newmag); do not use */
-    aubio_pitchmcomb_spectral_pp(p, newmag);
-    aubio_pitchmcomb_combdet(p,newmag);
-    aubio_pitchmcomb_sort_cand_freq(scands,p->ncand);
+    aubio_pitchmcomb_spectral_pp (p, newmag);
+    aubio_pitchmcomb_combdet (p, newmag);
+    aubio_pitchmcomb_sort_cand_freq (scands, p->ncand);
     /* store ncand comb energies in cands[1:ncand] */
-    for (k = 0; k<p->ncand; k++)
+    for (k = 0; k < p->ncand; k++)
       cands[k] = p->candidates[k]->ene;
     /* store ncand[end] freq in cands[end] */
-    cands[p->ncand] = p->candidates[p->ncand-1]->ebin;
+    cands[p->ncand] = p->candidates[p->ncand - 1]->ebin;
     return 1;
   } else {
-    for (k = 0; k<p->ncand; k++)
+    for (k = 0; k < p->ncand; k++)
       cands[k] = 0;
     return 0;
@@ -155,28 +167,30 @@
 }
 
-void aubio_pitchmcomb_spectral_pp(aubio_pitchmcomb_t * p, fvec_t * newmag) {
-  fvec_t * mag = (fvec_t *)p->scratch;
-  fvec_t * tmp = (fvec_t *)p->scratch2;
-  uint_t i=0,j;
+void
+aubio_pitchmcomb_spectral_pp (aubio_pitchmcomb_t * p, fvec_t * newmag)
+{
+  fvec_t *mag = (fvec_t *) p->scratch;
+  fvec_t *tmp = (fvec_t *) p->scratch2;
+  uint_t i = 0, j;
   uint_t length = mag->length;
   /* copy newmag to mag (scracth) */
-  for (j=0;j<length;j++) {
+  for (j = 0; j < length; j++) {
     mag->data[i][j] = newmag->data[i][j];
   }
-  fvec_min_removal(mag);              /* min removal          */
-  fvec_alpha_normalise(mag,p->alpha); /* alpha normalisation  */
-  /* skipped */                       /* low pass filtering   */
+  fvec_min_removal (mag);       /* min removal          */
+  fvec_alpha_normalise (mag, p->alpha); /* alpha normalisation  */
+  /* 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_add(mag,-p->threshold);        /* fixed threshold      */
+  fvec_adapt_thres (mag, tmp, p->win_post, p->win_pre, i);      /* adaptative threshold */
+  fvec_add (mag, -p->threshold);        /* fixed threshold      */
   {
-    aubio_spectralpeak_t * peaks = (aubio_spectralpeak_t *)p->peaks;
+    aubio_spectralpeak_t *peaks = (aubio_spectralpeak_t *) p->peaks;
     uint_t count;
     /*  return bin and ebin */
-    count = aubio_pitchmcomb_quadpick(peaks,mag);
-    for (j=0;j<count;j++)
+    count = aubio_pitchmcomb_quadpick (peaks, mag);
+    for (j = 0; j < count; j++)
       peaks[j].mag = newmag->data[i][peaks[j].bin];
     /* reset non peaks */
-    for (j=count;j<length;j++)
+    for (j = count; j < length; j++)
       peaks[j].mag = 0.;
     p->peaks = peaks;
@@ -185,12 +199,14 @@
 }
 
-void aubio_pitchmcomb_combdet(aubio_pitchmcomb_t * p, fvec_t * newmag) {
-  aubio_spectralpeak_t * peaks = (aubio_spectralpeak_t *)p->peaks;
-  aubio_spectralcandidate_t ** candidate =
-    (aubio_spectralcandidate_t **)p->candidates;
+void
+aubio_pitchmcomb_combdet (aubio_pitchmcomb_t * p, fvec_t * newmag)
+{
+  aubio_spectralpeak_t *peaks = (aubio_spectralpeak_t *) p->peaks;
+  aubio_spectralcandidate_t **candidate =
+      (aubio_spectralcandidate_t **) p->candidates;
 
   /* parms */
-  uint_t N = p->npartials; /* maximum number of partials to be considered 10 */
-  uint_t M = p->ncand;  /* maximum number of combs to be considered 5 */
+  uint_t N = p->npartials;      /* maximum number of partials to be considered 10 */
+  uint_t M = p->ncand;          /* maximum number of combs to be considered 5 */
   uint_t length = newmag->length;
   uint_t count = p->count;
@@ -209,30 +225,30 @@
 
   /* get the biggest peak in the spectrum */
-  root_peak = aubio_pitchmcomb_get_root_peak(peaks,count);
+  root_peak = aubio_pitchmcomb_get_root_peak (peaks, count);
   /* not enough partials in highest notes, could be forced */
   //if (peaks[root_peak].ebin >= aubio_miditofreq(85.)/p->tau) N=2;
   //if (peaks[root_peak].ebin >= aubio_miditofreq(90.)/p->tau) N=1;
   /* now calculate the energy of each of the 5 combs */
-  for (l=0;l<M;l++) {
-    smpl_t scaler = (1./(l+1.));
-    candidate[l]->ene = 0.; /* reset ene and len sums */
+  for (l = 0; l < M; l++) {
+    smpl_t scaler = (1. / (l + 1.));
+    candidate[l]->ene = 0.;     /* reset ene and len sums */
     candidate[l]->len = 0.;
-    candidate[l]->ebin=scaler*peaks[root_peak].ebin;
+    candidate[l]->ebin = scaler * peaks[root_peak].ebin;
     /* if less than N peaks available, curlen < N */
     if (candidate[l]->ebin != 0.)
-      curlen = (uint_t)FLOOR(length/(candidate[l]->ebin));
-    curlen = (N < curlen )? N : curlen;
+      curlen = (uint_t) FLOOR (length / (candidate[l]->ebin));
+    curlen = (N < curlen) ? N : curlen;
     /* fill candidate[l]->ecomb[k] with (k+1)*candidate[l]->ebin */
-    for (k=0;k<curlen;k++)
-      candidate[l]->ecomb[k]=(candidate[l]->ebin)*(k+1.);
-    for (k=curlen;k<length;k++)
-      candidate[l]->ecomb[k]=0.;
+    for (k = 0; k < curlen; k++)
+      candidate[l]->ecomb[k] = (candidate[l]->ebin) * (k + 1.);
+    for (k = curlen; k < length; k++)
+      candidate[l]->ecomb[k] = 0.;
     /* for each in candidate[l]->ecomb[k] */
-    for (k=0;k<curlen;k++) {
+    for (k = 0; k < curlen; k++) {
       xx = 100000.;
       /** get the candidate->ecomb the closer to peaks.ebin
        * (to cope with the inharmonicity)*/
-      for (d=0;d<count;d++) {
-        delta2 = ABS(candidate[l]->ecomb[k]-peaks[d].ebin);
+      for (d = 0; d < count; d++) {
+        delta2 = ABS (candidate[l]->ecomb[k] - peaks[d].ebin);
         if (delta2 <= xx) {
           position = d;
@@ -242,15 +258,16 @@
       /* for a Q factor of 17, maintaining "constant Q filtering",
        * and sum energy and length over non null combs */
-      if ( 17. * xx < candidate[l]->ecomb[k] ) {
-        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)],0.25);
-        candidate[l]->len += 1./curlen;
+      if (17. * xx < candidate[l]->ecomb[k]) {
+        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)],
+            0.25);
+        candidate[l]->len += 1. / curlen;
       } else
-        candidate[l]->ecomb[k]=0.;
+        candidate[l]->ecomb[k] = 0.;
     }
     /* punishment */
     /*if (candidate[l]->len<0.6)
-      candidate[l]->ene=0.; */
+       candidate[l]->ene=0.; */
     /* remember best candidate energy (in polyphonic, could check for
      * tmpene*1.1 < candidate->ene to reduce jumps towards low frequencies) */
@@ -270,13 +287,15 @@
  * \bug peak-picking too picky, sometimes counts too many peaks ?
  */
-uint_t aubio_pitchmcomb_quadpick(aubio_spectralpeak_t * spectral_peaks, fvec_t * X){
+uint_t
+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);
+  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.;
+        spectral_peaks[count - 1].bin = j;
+        spectral_peaks[count - 1].ebin = fvec_quadint (X, j, i) - 1.;
       }
     }
@@ -285,8 +304,10 @@
 
 /* get predominant partial */
-uint_t aubio_pitchmcomb_get_root_peak(aubio_spectralpeak_t * peaks, uint_t length) {
-  uint_t i,pos=0;
+uint_t
+aubio_pitchmcomb_get_root_peak (aubio_spectralpeak_t * peaks, uint_t length)
+{
+  uint_t i, pos = 0;
   smpl_t tmp = 0.;
-  for (i=0;i<length;i++)
+  for (i = 0; i < length; i++)
     if (tmp <= peaks[i].mag) {
       pos = i;
@@ -296,68 +317,82 @@
 }
 
-void aubio_pitchmcomb_sort_peak(aubio_spectralpeak_t * peaks, uint_t nbins) {
-  qsort(peaks, nbins, sizeof(aubio_spectralpeak_t),
+void
+aubio_pitchmcomb_sort_peak (aubio_spectralpeak_t * peaks, uint_t nbins)
+{
+  qsort (peaks, nbins, sizeof (aubio_spectralpeak_t),
       aubio_pitchmcomb_sort_peak_comp);
 }
-static sint_t aubio_pitchmcomb_sort_peak_comp(const void *x, const void *y) {
-  return (((aubio_spectralpeak_t *)y)->mag - ((aubio_spectralpeak_t *)x)->mag);
-}
-
-
-void aubio_pitchmcomb_sort_cand_ene(aubio_spectralcandidate_t ** candidates, uint_t nbins) {
+
+static sint_t
+aubio_pitchmcomb_sort_peak_comp (const void *x, const void *y)
+{
+  return (((aubio_spectralpeak_t *) y)->mag -
+      ((aubio_spectralpeak_t *) x)->mag);
+}
+
+
+void
+aubio_pitchmcomb_sort_cand_ene (aubio_spectralcandidate_t ** candidates,
+    uint_t nbins)
+{
   uint_t cur = 0;
   uint_t run = 0;
-  for (cur=0;cur<nbins;cur++) {
+  for (cur = 0; cur < nbins; cur++) {
     run = cur + 1;
-    for (run=cur;run<nbins;run++) {
-      if(candidates[run]->ene > candidates[cur]->ene)
-        CAND_SWAP(candidates[run], candidates[cur]);
-    }
-  }
-}
-
-
-void aubio_pitchmcomb_sort_cand_freq(aubio_spectralcandidate_t ** candidates, uint_t nbins) {
+    for (run = cur; run < nbins; run++) {
+      if (candidates[run]->ene > candidates[cur]->ene)
+        CAND_SWAP (candidates[run], candidates[cur]);
+    }
+  }
+}
+
+
+void
+aubio_pitchmcomb_sort_cand_freq (aubio_spectralcandidate_t ** candidates,
+    uint_t nbins)
+{
   uint_t cur = 0;
   uint_t run = 0;
-  for (cur=0;cur<nbins;cur++) {
+  for (cur = 0; cur < nbins; cur++) {
     run = cur + 1;
-    for (run=cur;run<nbins;run++) {
-      if(candidates[run]->ebin < candidates[cur]->ebin)
-        CAND_SWAP(candidates[run], candidates[cur]);
-    }
-  }
-}
-
-aubio_pitchmcomb_t * new_aubio_pitchmcomb(uint_t bufsize, uint_t hopsize, uint_t channels) {
-  aubio_pitchmcomb_t * p = AUBIO_NEW(aubio_pitchmcomb_t);
+    for (run = cur; run < nbins; run++) {
+      if (candidates[run]->ebin < candidates[cur]->ebin)
+        CAND_SWAP (candidates[run], candidates[cur]);
+    }
+  }
+}
+
+aubio_pitchmcomb_t *
+new_aubio_pitchmcomb (uint_t bufsize, uint_t hopsize, uint_t channels)
+{
+  aubio_pitchmcomb_t *p = AUBIO_NEW (aubio_pitchmcomb_t);
   /* bug: should check if size / 8 > post+pre+1 */
   uint_t i, j;
   uint_t spec_size;
-  p->spec_partition   = 4;
-  p->ncand            = 5;
-  p->npartials        = 5;
-  p->cutoff           = 1.;
-  p->threshold        = 0.01;
-  p->win_post         = 8;
-  p->win_pre          = 7;
+  p->spec_partition = 4;
+  p->ncand = 5;
+  p->npartials = 5;
+  p->cutoff = 1.;
+  p->threshold = 0.01;
+  p->win_post = 8;
+  p->win_pre = 7;
   // p->tau              = samplerate/bufsize;
-  p->alpha            = 9.;
-  p->goodcandidate    = 0;
-  p->phasefreq        = bufsize/hopsize/TWO_PI;
-  p->phasediff        = TWO_PI*hopsize/bufsize;
-  spec_size = bufsize/p->spec_partition;
+  p->alpha = 9.;
+  p->goodcandidate = 0;
+  p->phasefreq = bufsize / hopsize / TWO_PI;
+  p->phasediff = TWO_PI * hopsize / bufsize;
+  spec_size = bufsize / p->spec_partition;
   //p->pickerfn = quadpick;
   //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, 1);
   /* array for median */
-  p->scratch    = new_fvec(spec_size,1);
+  p->scratch = new_fvec (spec_size, 1);
   /* array for phase */
-  p->theta      = new_fvec(spec_size,channels);
+  p->theta = new_fvec (spec_size, channels);
   /* 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, 1);
   /* array of spectral peaks */
-  p->peaks      = AUBIO_ARRAY(aubio_spectralpeak_t,spec_size);
+  p->peaks = AUBIO_ARRAY (aubio_spectralpeak_t, spec_size);
   for (i = 0; i < spec_size; i++) {
     p->peaks[i].bin = 0.;
@@ -366,9 +401,9 @@
   }
   /* array of pointers to spectral candidates */
-  p->candidates = AUBIO_ARRAY(aubio_spectralcandidate_t *,p->ncand);
-  for (i=0;i<p->ncand;i++) {
-    p->candidates[i] = AUBIO_NEW(aubio_spectralcandidate_t);
-    p->candidates[i]->ecomb = AUBIO_ARRAY(smpl_t, spec_size);
-    for (j=0; j < spec_size; j++) {
+  p->candidates = AUBIO_ARRAY (aubio_spectralcandidate_t *, p->ncand);
+  for (i = 0; i < p->ncand; i++) {
+    p->candidates[i] = AUBIO_NEW (aubio_spectralcandidate_t);
+    p->candidates[i]->ecomb = AUBIO_ARRAY (smpl_t, spec_size);
+    for (j = 0; j < spec_size; j++) {
       p->candidates[i]->ecomb[j] = 0.;
     }
@@ -381,16 +416,18 @@
 
 
-void del_aubio_pitchmcomb (aubio_pitchmcomb_t *p) {
+void
+del_aubio_pitchmcomb (aubio_pitchmcomb_t * p)
+{
   uint_t i;
-  del_fvec(p->newmag);
-  del_fvec(p->scratch);
-  del_fvec(p->theta);
-  del_fvec(p->scratch2);
-  AUBIO_FREE(p->peaks);
-  for (i=0;i<p->ncand;i++) {
-    AUBIO_FREE(p->candidates[i]->ecomb);
-    AUBIO_FREE(p->candidates[i]);
-  }
-  AUBIO_FREE(p->candidates);
-  AUBIO_FREE(p);
-}
+  del_fvec (p->newmag);
+  del_fvec (p->scratch);
+  del_fvec (p->theta);
+  del_fvec (p->scratch2);
+  AUBIO_FREE (p->peaks);
+  for (i = 0; i < p->ncand; i++) {
+    AUBIO_FREE (p->candidates[i]->ecomb);
+    AUBIO_FREE (p->candidates[i]);
+  }
+  AUBIO_FREE (p->candidates);
+  AUBIO_FREE (p);
+}
Index: src/pitch/pitchmcomb.h
===================================================================
--- src/pitch/pitchmcomb.h	(revision 63f3c70e15951dd1bf7caa8d0d2e6cc18d69e3c0)
+++ src/pitch/pitchmcomb.h	(revision fddfa647d845149f90a4116483d287487f4b841c)
@@ -50,5 +50,7 @@
  
 */
-void aubio_pitchmcomb_do (aubio_pitchmcomb_t * p, cvec_t * fftgrain, fvec_t * output);
+void aubio_pitchmcomb_do (aubio_pitchmcomb_t * p, cvec_t * fftgrain,
+    fvec_t * output);
+
 /** creation of the pitch detection object
  
@@ -59,5 +61,7 @@
  
 */
-aubio_pitchmcomb_t * new_aubio_pitchmcomb(uint_t bufsize, uint_t hopsize, uint_t channels);
+aubio_pitchmcomb_t *new_aubio_pitchmcomb (uint_t bufsize, uint_t hopsize,
+    uint_t channels);
+
 /** deletion of the pitch detection object
  
@@ -65,5 +69,5 @@
  
 */
-void del_aubio_pitchmcomb(aubio_pitchmcomb_t *p);
+void del_aubio_pitchmcomb (aubio_pitchmcomb_t * p);
 
 #ifdef __cplusplus
Index: src/pitch/pitchyin.c
===================================================================
--- src/pitch/pitchyin.c	(revision 63f3c70e15951dd1bf7caa8d0d2e6cc18d69e3c0)
+++ src/pitch/pitchyin.c	(revision fddfa647d845149f90a4116483d287487f4b841c)
@@ -33,6 +33,7 @@
 #include "pitch/pitchyin.h"
 
-struct _aubio_pitchyin_t {
-  fvec_t * yin;
+struct _aubio_pitchyin_t
+{
+  fvec_t *yin;
   smpl_t tol;
 };
@@ -44,5 +45,5 @@
 
 */
-void aubio_pitchyin_diff(fvec_t * input, fvec_t * yinbuf);
+void aubio_pitchyin_diff (fvec_t * input, fvec_t * yinbuf);
 
 /** in place computation of the YIN cumulative normalised function 
@@ -51,5 +52,5 @@
 
 */
-void aubio_pitchyin_getcum(fvec_t * yinbuf);
+void aubio_pitchyin_getcum (fvec_t * yinbuf);
 
 /** detect pitch in a YIN function
@@ -58,34 +59,36 @@
 
 */
-uint_t aubio_pitchyin_getpitch(fvec_t *yinbuf);
+uint_t aubio_pitchyin_getpitch (fvec_t * yinbuf);
 
-aubio_pitchyin_t * new_aubio_pitchyin (uint_t bufsize) {
-  aubio_pitchyin_t * o = AUBIO_NEW(aubio_pitchyin_t);
-  o->yin = new_fvec (bufsize/2, 1);
+aubio_pitchyin_t *
+new_aubio_pitchyin (uint_t bufsize)
+{
+  aubio_pitchyin_t *o = AUBIO_NEW (aubio_pitchyin_t);
+  o->yin = new_fvec (bufsize / 2, 1);
   o->tol = 0.15;
   return o;
 }
 
-void del_aubio_pitchyin (aubio_pitchyin_t *o) {
-  del_fvec(o->yin);
-  AUBIO_FREE(o);
+void
+del_aubio_pitchyin (aubio_pitchyin_t * o)
+{
+  del_fvec (o->yin);
+  AUBIO_FREE (o);
 }
 
 /* outputs the difference function */
-void aubio_pitchyin_diff(fvec_t * input, fvec_t * yin){
-  uint_t c,j,tau;
+void
+aubio_pitchyin_diff (fvec_t * input, fvec_t * yin)
+{
+  uint_t c, j, tau;
   smpl_t tmp;
-  for (c=0;c<input->channels;c++)
-  {
-    for (tau=0;tau<yin->length;tau++)
-    {
+  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 = 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);
       }
     }
@@ -94,16 +97,16 @@
 
 /* cumulative mean normalized difference function */
-void aubio_pitchyin_getcum(fvec_t * yin) {
-  uint_t c,tau;
+void
+aubio_pitchyin_getcum (fvec_t * yin)
+{
+  uint_t c, tau;
   smpl_t tmp;
-  for (c=0;c<yin->channels;c++)
-  {
+  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++)
-    {
+    for (tau = 1; tau < yin->length; tau++) {
       tmp += yin->data[c][tau];
-      yin->data[c][tau] *= tau/tmp;
+      yin->data[c][tau] *= tau / tmp;
       //AUBIO_DBG("%f\t",yin->data[c][tau]);
     }
@@ -112,10 +115,11 @@
 }
 
-uint_t aubio_pitchyin_getpitch(fvec_t * yin) {
-  uint_t c=0,tau=1;
-  do 
-  {
-    if(yin->data[c][tau] < 0.1) { 
-      while (yin->data[c][tau+1] < yin->data[c][tau]) {
+uint_t
+aubio_pitchyin_getpitch (fvec_t * yin)
+{
+  uint_t c = 0, tau = 1;
+  do {
+    if (yin->data[c][tau] < 0.1) {
+      while (yin->data[c][tau + 1] < yin->data[c][tau]) {
         tau++;
       }
@@ -123,5 +127,5 @@
     }
     tau++;
-  } while (tau<yin->length);
+  } while (tau < yin->length);
   //AUBIO_DBG("No pitch found");
   return 0;
@@ -130,31 +134,31 @@
 
 /* all the above in one */
-void aubio_pitchyin_do(aubio_pitchyin_t *o, fvec_t * input, fvec_t * out){
+void
+aubio_pitchyin_do (aubio_pitchyin_t * o, fvec_t * input, fvec_t * out)
+{
   smpl_t tol = o->tol;
-  fvec_t * yin = o->yin;
-  uint_t c , j,tau = 0;
+  fvec_t *yin = o->yin;
+  uint_t c, 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++)
-    {
+    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);
+      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);
+      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;
       }
     }
-    out->data[c][0] = fvec_quadint(yin,fvec_min_elem(yin),c);
-beach:
+    out->data[c][0] = fvec_quadint (yin, fvec_min_elem (yin), c);
+  beach:
     continue;
   }
@@ -162,10 +166,14 @@
 }
 
-uint_t aubio_pitchyin_set_tolerance (aubio_pitchyin_t *o, smpl_t tol) {
+uint_t
+aubio_pitchyin_set_tolerance (aubio_pitchyin_t * o, smpl_t tol)
+{
   o->tol = tol;
   return 0;
 }
 
-smpl_t aubio_pitchyin_get_tolerance (aubio_pitchyin_t *o) {
+smpl_t
+aubio_pitchyin_get_tolerance (aubio_pitchyin_t * o)
+{
   return o->tol;
 }
Index: src/pitch/pitchyin.h
===================================================================
--- src/pitch/pitchyin.h	(revision 63f3c70e15951dd1bf7caa8d0d2e6cc18d69e3c0)
+++ src/pitch/pitchyin.h	(revision fddfa647d845149f90a4116483d287487f4b841c)
@@ -48,5 +48,5 @@
  
 */
-aubio_pitchyin_t * new_aubio_pitchyin (uint_t bufsize);
+aubio_pitchyin_t *new_aubio_pitchyin (uint_t bufsize);
 
 /** deletion of the pitch detection object
@@ -73,5 +73,5 @@
 
 */
-uint_t aubio_pitchyin_set_tolerance (aubio_pitchyin_t *o, smpl_t tol);
+uint_t aubio_pitchyin_set_tolerance (aubio_pitchyin_t * o, smpl_t tol);
 
 /** get tolerance parameter for YIN algorithm 
Index: src/pitch/pitchyinfft.c
===================================================================
--- src/pitch/pitchyinfft.c	(revision 63f3c70e15951dd1bf7caa8d0d2e6cc18d69e3c0)
+++ src/pitch/pitchyinfft.c	(revision fddfa647d845149f90a4116483d287487f4b841c)
@@ -27,63 +27,67 @@
 
 /** pitch yinfft structure */
-struct _aubio_pitchyinfft_t {
-  fvec_t * win;       /**< temporal weighting window */
-  fvec_t * winput;    /**< windowed spectrum */
-  cvec_t * res;       /**< complex vector to compute square difference function */
-  fvec_t * sqrmag;    /**< square difference function */
-  fvec_t * weight;    /**< spectral weighting window (psychoacoustic model) */
-  cvec_t * fftout;    /**< Fourier transform output */
-  aubio_fft_t * fft;  /**< fft object to compute square difference function */
-  fvec_t * yinfft;    /**< Yin function */
+struct _aubio_pitchyinfft_t
+{
+  fvec_t *win;        /**< temporal weighting window */
+  fvec_t *winput;     /**< windowed spectrum */
+  cvec_t *res;        /**< complex vector to compute square difference function */
+  fvec_t *sqrmag;     /**< square difference function */
+  fvec_t *weight;     /**< spectral weighting window (psychoacoustic model) */
+  cvec_t *fftout;     /**< Fourier transform output */
+  aubio_fft_t *fft;   /**< fft object to compute square difference function */
+  fvec_t *yinfft;     /**< Yin function */
   smpl_t tol;         /**< Yin tolerance */
 };
 
-static const smpl_t freqs[] = {0., 20., 25., 31.5, 40., 50., 63., 80., 100.,
+static const smpl_t freqs[] = { 0., 20., 25., 31.5, 40., 50., 63., 80., 100.,
   125., 160., 200., 250., 315., 400., 500., 630., 800., 1000., 1250.,
   1600., 2000., 2500., 3150., 4000., 5000., 6300., 8000., 9000., 10000.,
-  12500., 15000., 20000.,  25100};
+  12500., 15000., 20000., 25100
+};
 
-static const smpl_t weight[] = {-75.8, -70.1, -60.8, -52.1, -44.2, -37.5,
+static const smpl_t weight[] = { -75.8, -70.1, -60.8, -52.1, -44.2, -37.5,
   -31.3, -25.6, -20.9, -16.5, -12.6, -9.6, -7.0, -4.7, -3.0, -1.8, -0.8,
   -0.2, -0.0, 0.5, 1.6, 3.2, 5.4, 7.8, 8.1, 5.3, -2.4, -11.1, -12.8,
-  -12.2, -7.4, -17.8, -17.8, -17.8};
+  -12.2, -7.4, -17.8, -17.8, -17.8
+};
 
-aubio_pitchyinfft_t * new_aubio_pitchyinfft (uint_t bufsize)
+aubio_pitchyinfft_t *
+new_aubio_pitchyinfft (uint_t bufsize)
 {
-  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->tol    = 0.85;
-  p->win    = new_aubio_window("hanningz", bufsize);
-  p->weight      = new_fvec(bufsize/2+1,1);
+  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->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.;
+    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];
+        j += 1;
+      }
+      a0 = weight[j - 1];
+      f0 = freqs[j - 1];
+      a1 = weight[j];
       f1 = freqs[j];
-      if (f0 == f1) { // just in case
+      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 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.));
+        p->weight->data[0][i] = (a1 - a0) / (f1 - f0) * freq +
+            (a0 - (a1 - a0) / (f1 / f0 - 1.));
       }
       while (freq > freqs[j]) {
-        j +=1;
+        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] = DB2LIN (p->weight->data[0][i]);
       //p->weight->data[0][i] = SQRT(DB2LIN(p->weight->data[0][i]));
     }
@@ -92,79 +96,88 @@
 }
 
-void aubio_pitchyinfft_do (aubio_pitchyinfft_t * p, fvec_t * input, fvec_t * output) {
+void
+aubio_pitchyinfft_do (aubio_pitchyinfft_t * p, fvec_t * input, fvec_t * output)
+{
   uint_t i, tau, l;
   uint_t halfperiod;
   smpl_t tmp, sum;
-  cvec_t * res = (cvec_t *)p->res;
-  fvec_t * yin = (fvec_t *)p->yinfft;
-  for (i=0; i < input->channels; i++){
-  l = 0; tmp = 0.; sum = 0.;
-  for (l=0; l < input->length; l++){
-    p->winput->data[0][l] = p->win->data[0][l] * input->data[i][l];
-  }
-  aubio_fft_do(p->fft,p->winput,p->fftout);
-  for (l=0; l < p->fftout->length; l++){
-    p->sqrmag->data[0][l] = SQR(p->fftout->norm[0][l]);
-    p->sqrmag->data[0][l] *= p->weight->data[0][l];
-  }
-  for (l=1; l < p->fftout->length; l++){
-    p->sqrmag->data[0][(p->fftout->length-1)*2-l] =
-     SQR(p->fftout->norm[0][l]);
-    p->sqrmag->data[0][(p->fftout->length-1)*2-l] *=
-     p->weight->data[0][l];
-  }
-  for (l=0; l < p->sqrmag->length/2+1; l++) {
-    sum += p->sqrmag->data[0][l];
-  }
-  sum *= 2.;
-  aubio_fft_do(p->fft,p->sqrmag,res);
-  yin->data[0][0] = 1.;
-  for (tau=1; tau < yin->length; tau++) {
-    yin->data[0][tau] = sum -
-      res->norm[0][tau]*COS(res->phas[0][tau]);
-    tmp += yin->data[0][tau];
-    yin->data[0][tau] *= tau/tmp;
-  }
-  tau = fvec_min_elem(yin);
-  if (yin->data[0][tau] < p->tol) {
-    /* no interpolation */
-    //return tau;
-    /* 3 point quadratic interpolation */
-    //return fvec_quadint_min(yin,tau,1);
-    /* additional check for (unlikely) octave doubling in higher frequencies */
-    if (tau>35) {
-      output->data[i][0] = fvec_quadint(yin,tau,i);
+  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];
+    }
+    aubio_fft_do (p->fft, p->winput, p->fftout);
+    for (l = 0; l < p->fftout->length; l++) {
+      p->sqrmag->data[0][l] = SQR (p->fftout->norm[0][l]);
+      p->sqrmag->data[0][l] *= p->weight->data[0][l];
+    }
+    for (l = 1; l < p->fftout->length; l++) {
+      p->sqrmag->data[0][(p->fftout->length - 1) * 2 - l] =
+          SQR (p->fftout->norm[0][l]);
+      p->sqrmag->data[0][(p->fftout->length - 1) * 2 - l] *=
+          p->weight->data[0][l];
+    }
+    for (l = 0; l < p->sqrmag->length / 2 + 1; l++) {
+      sum += p->sqrmag->data[0][l];
+    }
+    sum *= 2.;
+    aubio_fft_do (p->fft, p->sqrmag, res);
+    yin->data[0][0] = 1.;
+    for (tau = 1; tau < yin->length; tau++) {
+      yin->data[0][tau] = sum - res->norm[0][tau] * COS (res->phas[0][tau]);
+      tmp += yin->data[0][tau];
+      yin->data[0][tau] *= tau / tmp;
+    }
+    tau = fvec_min_elem (yin);
+    if (yin->data[0][tau] < p->tol) {
+      /* no interpolation */
+      //return tau;
+      /* 3 point quadratic interpolation */
+      //return fvec_quadint_min(yin,tau,1);
+      /* additional check for (unlikely) octave doubling in higher frequencies */
+      if (tau > 35) {
+        output->data[i][0] = fvec_quadint (yin, tau, i);
+      } else {
+        /* should compare the minimum value of each interpolated peaks */
+        halfperiod = FLOOR (tau / 2 + .5);
+        if (yin->data[0][halfperiod] < p->tol)
+          output->data[i][0] = fvec_quadint (yin, halfperiod, i);
+        else
+          output->data[i][0] = fvec_quadint (yin, tau, i);
+      }
     } else {
-      /* should compare the minimum value of each interpolated peaks */
-      halfperiod = FLOOR(tau/2+.5);
-      if (yin->data[0][halfperiod] < p->tol)
-        output->data[i][0] = fvec_quadint(yin,halfperiod,i);
-      else
-        output->data[i][0] = fvec_quadint(yin,tau,i);
+      output->data[i][0] = 0.;
     }
-  } else {
-    output->data[i][0] = 0.;
-  }
   }
 }
 
-void del_aubio_pitchyinfft(aubio_pitchyinfft_t *p){
-  del_fvec(p->win);
-  del_aubio_fft(p->fft);
-  del_fvec(p->yinfft);
-  del_fvec(p->sqrmag);
-  del_cvec(p->res);
-  del_cvec(p->fftout);
-  del_fvec(p->winput);
-  del_fvec(p->weight);
-  AUBIO_FREE(p);
+void
+del_aubio_pitchyinfft (aubio_pitchyinfft_t * p)
+{
+  del_fvec (p->win);
+  del_aubio_fft (p->fft);
+  del_fvec (p->yinfft);
+  del_fvec (p->sqrmag);
+  del_cvec (p->res);
+  del_cvec (p->fftout);
+  del_fvec (p->winput);
+  del_fvec (p->weight);
+  AUBIO_FREE (p);
 }
 
-uint_t aubio_pitchyinfft_set_tolerance (aubio_pitchyinfft_t * p, smpl_t tol) {
+uint_t
+aubio_pitchyinfft_set_tolerance (aubio_pitchyinfft_t * p, smpl_t tol)
+{
   p->tol = tol;
   return 0;
 }
 
-smpl_t aubio_pitchyinfft_get_tolerance (aubio_pitchyinfft_t * p) {
+smpl_t
+aubio_pitchyinfft_get_tolerance (aubio_pitchyinfft_t * p)
+{
   return p->tol;
 }
Index: src/pitch/pitchyinfft.h
===================================================================
--- src/pitch/pitchyinfft.h	(revision 63f3c70e15951dd1bf7caa8d0d2e6cc18d69e3c0)
+++ src/pitch/pitchyinfft.h	(revision fddfa647d845149f90a4116483d287487f4b841c)
@@ -51,5 +51,5 @@
  
 */
-void aubio_pitchyinfft_do (aubio_pitchyinfft_t *p, fvec_t * in, fvec_t * out);
+void aubio_pitchyinfft_do (aubio_pitchyinfft_t * p, fvec_t * in, fvec_t * out);
 /** creation of the pitch detection object
  
@@ -57,5 +57,5 @@
  
 */
-aubio_pitchyinfft_t * new_aubio_pitchyinfft (uint_t bufsize);
+aubio_pitchyinfft_t *new_aubio_pitchyinfft (uint_t bufsize);
 /** deletion of the pitch detection object
  
@@ -63,5 +63,5 @@
  
 */
-void del_aubio_pitchyinfft (aubio_pitchyinfft_t *p);
+void del_aubio_pitchyinfft (aubio_pitchyinfft_t * p);
 
 /** get tolerance parameter for YIN algorithm 
