merge changes from banane, more fixes

diff --cc src/phasevoc.c
index 8eeaef8bcbdb945f126011e258123f7be72fd5f2,60d58e871239c0945bdaf69902e6a155a3f00661..6fdf6cf0524380f80dddf9ddc54d8334a82de6b2
--- 1/src/phasevoc.c
--- 2/src/phasevoc.c
+++ b/src/phasevoc.c
@@@ -25,24 -25,15 +25,15 @@@
  
  /** phasevocoder internal object */
  struct _aubio_pvoc_t {
-       /** grain length */
-       uint_t win_s;
-       /** overlap step */
-       uint_t hop_s;
-       /** number of channels */
-       uint_t channels;
-       /** spectral data */
-       aubio_mfft_t * fft;
-       /**cur output grain             [win_s] */
-       fvec_t * synth;          
-       /**last input frame             [win_s-hop_s] */
-       fvec_t * synthold; 
-       /**current input grain          [win_s] */
-       fvec_t * data;           
-       /**last input frame             [win_s-hop_s] */
-       fvec_t * dataold;  
-       /** grain window                [win_s] */
-       float * w;
+   uint_t win_s;       /** grain length */
+   uint_t hop_s;       /** overlap step */
+   uint_t channels;    /** number of channels */
+   aubio_mfft_t * fft; /** spectral data */
+   fvec_t * synth;     /**cur output grain [win_s] */
+   fvec_t * synthold;  /**last input frame [win_s-hop_s] */
+   fvec_t * data;      /**current input grain [win_s] */
+   fvec_t * dataold;   /**last input frame [win_s-hop_s] */
 -  float * w;          /** grain window [win_s] */
++  smpl_t * w;          /** grain window [win_s] */
  };
  
  

diff --cc src/types.h
index f6f4829e52bc770e80677066745b4ac71acabf2e,f6f4829e52bc770e80677066745b4ac71acabf2e..8f84404436d2fe67f64fbeb1eae27e517f877378
--- 1/src/types.h
--- 2/src/types.h
+++ b/src/types.h
@@@ -39,8 -39,8 +39,8 @@@ extern "C" 
  #endif
  
  /** short sample format (32 or 64 bits) */
--typedef float        smpl_t;
--//typedef double       smpl_t;
++//typedef float        smpl_t;
++typedef double       smpl_t;
  /** long sample format (64 bits or more) */
  typedef double       lsmp_t;
  //typedef long        lsmp_t;

diff --cc tests/python/fft.py
index 0000000000000000000000000000000000000000,d377e6fb72824334e217064719f0a9bf635a1c10..b856238f5280d0a4f6394c70fa39ba5eac83dee1
mode 000000,100644..100644
--- /dev/null
--- 2/tests/python/fft.py
+++ b/tests/python/fft.py
@@@ -1,0 -1,121 +1,150 @@@
 -buf_size = 2048 
 -channels = 1
+ import unittest
+ import math
+ 
+ from aubio.aubiowrapper import *
+ 
 -    """ test aubio_mfft_do on impulse one channel """
++buf_size = 8092 
++channels = 4
++
++precision = 6
+ 
+ class aubio_mfft_test_case(unittest.TestCase):
+ 
+   def setUp(self):
+     self.o = new_aubio_mfft(buf_size, channels)
+ 
+   def tearDown(self):
+     del_aubio_mfft(self.o)
+ 
+   def test_create(self):
+     """ test creation and deletion of fft object """
+     pass
+ 
+   def test_aubio_mfft_do_zeroes(self):
+     """ test aubio_mfft_do on zeroes """
+     input    = new_fvec(buf_size, channels)
+     fftgrain = new_cvec(buf_size, channels)
+     for index in range(buf_size):
+       for channel in range(channels):
+         self.assertEqual(0., fvec_read_sample(input, channel, index))
+     aubio_mfft_do(self.o, input, fftgrain)
+     for index in range(buf_size/2+1):
+       for channel in range(channels):
+         self.assertEqual(0., cvec_read_norm(fftgrain, channel, index))
+     for index in range(buf_size/2+1):
+       for channel in range(channels):
+         self.assertEqual(0., cvec_read_phas(fftgrain, channel, index))
+     del fftgrain
+     del input
+ 
+   def test_aubio_mfft_rdo_zeroes(self):
+     """ test aubio_mfft_rdo on zeroes """
+     fftgrain = new_cvec(buf_size, channels)
+     output    = new_fvec(buf_size, channels)
+     aubio_mfft_rdo(self.o, fftgrain, output)
+     # check output
+     for index in range(buf_size):
+       for channel in range(channels):
+         self.assertEqual(0., fvec_read_sample(output, channel, index))
+     del fftgrain
+     del output
+ 
+   def test_aubio_mfft_do_impulse(self):
 -    fvec_write_sample(input, 1., 0, 0)
++    """ test aubio_mfft_do with an impulse on one channel """
+     input    = new_fvec(buf_size, channels)
+     fftgrain = new_cvec(buf_size, channels)
+     # write impulse in channel 0, sample 0.
 -      self.assertEqual(1., cvec_read_norm(fftgrain, 0, index), index)
++    some_constant = 0.3412432456
++    fvec_write_sample(input, some_constant, 0, 0)
+     aubio_mfft_do(self.o, input, fftgrain)
+     # check norm
+     for index in range(buf_size/2+1):
 -    cvec_write_norm(fftgrain, 1., 0, 0)
++      self.assertAlmostEqual(some_constant, cvec_read_norm(fftgrain, 0, index), precision)
+     for index in range(buf_size/2+1):
+       for channel in range(1, channels):
+         self.assertEqual(0., cvec_read_norm(fftgrain, channel, index))
+     # check phas
+     for index in range(buf_size/2+1):
+       for channel in range(channels):
+         self.assertEqual(0., cvec_read_phas(fftgrain, channel, index))
+     del fftgrain
+     del input
+ 
++  def test_aubio_mfft_do_constant(self):
++    """ test aubio_mfft_do with a constant on one channel """
++    input    = new_fvec(buf_size, channels)
++    fftgrain = new_cvec(buf_size, channels)
++    # write impulse in channel 0, sample 0.
++    some_constant = 0.003412432456
++    for index in range(1,buf_size):
++      fvec_write_sample(input, some_constant, 0, index)
++    aubio_mfft_do(self.o, input, fftgrain)
++    # check norm and phase == 0 in all other channels 
++    for index in range(buf_size/2+1):
++      for channel in range(1, channels):
++        self.assertEqual(0., cvec_read_norm(fftgrain, channel, index))
++    # check norm and phase == 0 in first first and last bin of first channel
++    self.assertAlmostEqual((buf_size-1)*some_constant, cvec_read_norm(fftgrain, 0, 0), precision)
++    self.assertEqual(0., cvec_read_phas(fftgrain, 0, 0))
++    self.assertEqual(0., cvec_read_norm(fftgrain, 0, buf_size/2+1))
++    self.assertEqual(0., cvec_read_phas(fftgrain, 0, buf_size/2+1))
++    # check unwrap2pi(phas) ~= pi everywhere but in first bin
++    for index in range(1,buf_size/2+1):
++       self.assertAlmostEqual ( math.pi, aubio_unwrap2pi(cvec_read_phas(fftgrain, 0, index)), precision)
++       self.assertAlmostEqual(some_constant, cvec_read_norm(fftgrain, 0, index), precision)
++    del fftgrain
++    del input
++
+   def test_aubio_mfft_do_impulse_multichannel(self):
+     " test aubio_mfft_do on impulse two channels "
+     input    = new_fvec(buf_size, channels)
+     fftgrain = new_cvec(buf_size, channels)
+     # put an impulse in first an last channel, at first and last index
+     fvec_write_sample(input, 1., 0, 0)
+     fvec_write_sample(input, 1., channels-1, 0)
+     aubio_mfft_do(self.o, input, fftgrain)
+     # check the norm
+     for index in range(buf_size/2+1):
+       self.assertEqual(1., cvec_read_norm(fftgrain, 0, index))
+     for index in range(buf_size/2+1):
+       for channel in range(1, channels-1):
+         self.assertEqual(0., cvec_read_norm(fftgrain, channel, index))
+     for index in range(buf_size/2+1):
+       self.assertEqual(1., cvec_read_norm(fftgrain, channels-1, index))
+     # check the phase
+     for index in range(buf_size/2+1):
+       for channel in range(channels):
+         self.assertEqual(0., cvec_read_phas(fftgrain, channel, index))
+     del fftgrain
+     del input
+ 
+   def test_aubio_mfft_rdo_impulse(self):
+     """ test aubio_mfft_rdo on impulse """
+     fftgrain  = new_cvec(buf_size, channels)
 -        self.assertEqual(fvec_read_sample(output, channel, index),1./buf_size)
++    for channel in range(channels):
++      cvec_write_norm(fftgrain, 1., channel, 0)
+     output    = new_fvec(buf_size, channels)
+     aubio_mfft_rdo(self.o, fftgrain, output)
+     for index in range(buf_size/2+1):
+       for channel in range(channels):
 -        self.assertAlmostEqual(fvec_read_sample(output, channel, index), 0.67, 7)
++        self.assertAlmostEqual(fvec_read_sample(output, channel, index), 1./buf_size, precision)
+     del fftgrain
+     del output
+ 
+   def test_aubio_mfft_do_back_and_forth(self):
+     """ test aubio_mfft_rdo on a constant """
+     input    = new_fvec(buf_size, channels)
+     output   = new_fvec(buf_size, channels)
+     fftgrain = new_cvec(buf_size, channels)
+     for index in range(buf_size/2+1):
+       for channel in range(channels):
+         fvec_write_sample(input, 0.67, channel, index)
+     aubio_mfft_do(self.o, input, fftgrain)
+     aubio_mfft_rdo(self.o, fftgrain, output)
+     for index in range(buf_size/2+1):
+       for channel in range(channels):
++        self.assertAlmostEqual(fvec_read_sample(output, channel, index), 0.67, precision)
+     del fftgrain
+     del output
+ 
+ if __name__ == '__main__': unittest.main()