Changeset f218f29


Ignore:
Timestamp:
Nov 7, 2007, 5:03:59 PM (13 years ago)
Author:
Paul Brossier <piem@piem.org>
Branches:
feature/autosink, feature/constantq, feature/pitchshift, feature/pydocstrings, feature/timestretch, master, pitchshift, sampler, timestretch, yinfft+
Children:
10cf306
Parents:
ef7df76 (diff), 4368223 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

merge from banane

Files:
1 added
13 edited

Legend:

Unmodified
Added
Removed
  • src/fft.c

    ref7df76 rf218f29  
    1919
    2020#include "aubio_priv.h"
    21 #include "sample.h"
     21#include "fvec.h"
     22#include "cvec.h"
    2223#include "mathutils.h"
    2324#include "fft.h"
     
    4142
    4243struct _aubio_fft_t {
     44  uint_t winsize;
     45  uint_t channels;
    4346  uint_t fft_size;
    44   uint_t channels;
    45   real_t    *in, *out;
    46   fft_data_t   *specdata;
     47  real_t *in, *out;
    4748  fftw_plan   pfw, pbw;
     49  fft_data_t * specdata;     /* complex spectral data */
     50  fvec_t * compspec;
    4851};
    4952
    50 static void aubio_fft_getspectrum(fft_data_t * spectrum, smpl_t *norm, smpl_t * phas, uint_t size);
    51 
    52 aubio_fft_t * new_aubio_fft(uint_t size) {
     53aubio_fft_t * new_aubio_fft(uint_t winsize, uint_t channels) {
    5354  aubio_fft_t * s = AUBIO_NEW(aubio_fft_t);
     55  s->winsize  = winsize;
     56  s->channels = channels;
    5457  /* allocate memory */
    55   s->in       = AUBIO_ARRAY(real_t,size);
    56   s->out      = AUBIO_ARRAY(real_t,size);
     58  s->in       = AUBIO_ARRAY(real_t,winsize);
     59  s->out      = AUBIO_ARRAY(real_t,winsize);
     60  s->compspec = new_fvec(winsize,channels);
    5761  /* create plans */
    5862#ifdef HAVE_COMPLEX_H
    59   s->fft_size = size/2+1;
     63  s->fft_size = winsize/2+1;
    6064  s->specdata = (fft_data_t*)fftw_malloc(sizeof(fft_data_t)*s->fft_size);
    61   s->pfw = fftw_plan_dft_r2c_1d(size, s->in,  s->specdata, FFTW_ESTIMATE);
    62   s->pbw = fftw_plan_dft_c2r_1d(size, s->specdata, s->out, FFTW_ESTIMATE);
     65  s->pfw = fftw_plan_dft_r2c_1d(winsize, s->in,  s->specdata, FFTW_ESTIMATE);
     66  s->pbw = fftw_plan_dft_c2r_1d(winsize, s->specdata, s->out, FFTW_ESTIMATE);
    6367#else
    64   s->fft_size = size;
     68  s->fft_size = winsize;
    6569  s->specdata = (fft_data_t*)fftw_malloc(sizeof(fft_data_t)*s->fft_size);
    66   s->pfw = fftw_plan_r2r_1d(size, s->in,  s->specdata, FFTW_R2HC, FFTW_ESTIMATE);
    67   s->pbw = fftw_plan_r2r_1d(size, s->specdata, s->out, FFTW_HC2R, FFTW_ESTIMATE);
     70  s->pfw = fftw_plan_r2r_1d(winsize, s->in,  s->specdata, FFTW_R2HC, FFTW_ESTIMATE);
     71  s->pbw = fftw_plan_r2r_1d(winsize, s->specdata, s->out, FFTW_HC2R, FFTW_ESTIMATE);
    6872#endif
    6973  return s;
     
    7276void del_aubio_fft(aubio_fft_t * s) {
    7377  /* destroy data */
     78  del_fvec(s->compspec);
    7479  fftw_destroy_plan(s->pfw);
    7580  fftw_destroy_plan(s->pbw);
     
    8085}
    8186
    82 void aubio_fft_do(const aubio_fft_t * s,
    83     const smpl_t * data, fft_data_t * spectrum, const uint_t size) {
    84   uint_t i;
    85   for (i=0;i<size;i++) s->in[i] = data[i];
    86   fftw_execute(s->pfw);
    87   for (i=0; i < s->fft_size; i++) spectrum[i] = s->specdata[i];
     87void aubio_fft_do(aubio_fft_t * s, fvec_t * input, cvec_t * spectrum) {
     88  aubio_fft_do_complex(s, input, s->compspec);
     89  aubio_fft_get_spectrum(s->compspec, spectrum);
    8890}
    8991
    90 void aubio_fft_rdo(const aubio_fft_t * s,
    91     const fft_data_t * spectrum, smpl_t * data, const uint_t size) {
    92   uint_t i;
    93   const smpl_t renorm = 1./(smpl_t)size;
    94   for (i=0; i < s->fft_size; i++) s->specdata[i] = spectrum[i];
    95   fftw_execute(s->pbw);
    96   for (i=0;i<size;i++) data[i] = s->out[i]*renorm;
     92void aubio_fft_rdo(aubio_fft_t * s, cvec_t * spectrum, fvec_t * output) {
     93  aubio_fft_get_realimag(spectrum, s->compspec);
     94  aubio_fft_rdo_complex(s, s->compspec, output);
    9795}
    9896
    99 #ifdef HAVE_COMPLEX_H
    100 
    101 void aubio_fft_getnorm(smpl_t * norm, fft_data_t * spectrum, uint_t size) {
    102   uint_t i;
    103   for (i=0;i<size/2+1;i++) norm[i] = ABSC(spectrum[i]);
    104 }
    105 
    106 void aubio_fft_getphas(smpl_t * phas, fft_data_t * spectrum, uint_t size) {
    107   uint_t i;
    108   for (i=0;i<size/2+1;i++) phas[i] = ARGC(spectrum[i]);
    109 }
    110 
    111 void aubio_fft_getspectrum(fft_data_t * spectrum, smpl_t *norm, smpl_t * phas, uint_t size) {
    112   uint_t j;
    113   for (j=0; j<size/2+1; j++) {
    114     spectrum[j]  = CEXPC(I*phas[j]);
    115     spectrum[j] *= norm[j];
     97void aubio_fft_do_complex(aubio_fft_t * s, fvec_t * input, fvec_t * compspec) {
     98  uint_t i, j;
     99  for (i = 0; i < s->channels; i++) {
     100    for (j=0; j < s->winsize; j++) {
     101      s->in[j] = input->data[i][j];
     102    }
     103    fftw_execute(s->pfw);
     104#if HAVE_COMPLEX_H
     105    compspec->data[i][0] = REAL(s->specdata[0]);
     106    for (j = 1; j < s->fft_size -1 ; j++) {
     107      compspec->data[i][j] = REAL(s->specdata[j]);
     108      compspec->data[i][compspec->length - j] = IMAG(s->specdata[j]);
     109    }
     110    compspec->data[i][s->fft_size-1] = REAL(s->specdata[s->fft_size-1]);
     111#else
     112    for (j = 0; j < s->fft_size; j++) {
     113      compspec->data[i][j] = s->specdata[j];
     114    }
     115#endif
    116116  }
    117117}
    118118
     119void aubio_fft_rdo_complex(aubio_fft_t * s, fvec_t * compspec, fvec_t * output) {
     120  uint_t i, j;
     121  const smpl_t renorm = 1./(smpl_t)s->winsize;
     122  for (i = 0; i < compspec->channels; i++) {
     123#if HAVE_COMPLEX_H
     124    s->specdata[0] = compspec->data[i][0];
     125    for (j=1; j < s->fft_size - 1; j++) {
     126      s->specdata[j] = compspec->data[i][j] +
     127        I * compspec->data[i][compspec->length - j];
     128    }
     129    s->specdata[s->fft_size - 1] = compspec->data[i][s->fft_size - 1];
    119130#else
    120 
    121 void aubio_fft_getnorm(smpl_t * norm, fft_data_t * spectrum, uint_t size) {
    122   uint_t i;
    123   norm[0] = spectrum[0];
    124   for (i=1;i<size/2;i++) norm[i] = SQRT((SQR(spectrum[i]) + SQR(spectrum[size-i])));
    125   norm[size/2] = spectrum[size/2];
    126 }
    127 
    128 void aubio_fft_getphas(smpl_t * phas, fft_data_t * spectrum, uint_t size) {
    129   uint_t i;
    130   phas[0] = 0;
    131   for (i=1;i<size/2+1;i++) phas[i] = atan2f(spectrum[size-i] , spectrum[i]);
    132   phas[size/2] = 0;
    133 }
    134 
    135 void aubio_fft_getspectrum(fft_data_t * spectrum, smpl_t *norm, smpl_t * phas, uint_t size) {
    136   uint_t j;
    137   for (j=0; j<size/2+1; j++) {
    138     spectrum[j]       = norm[j]*COS(phas[j]);
    139   }
    140   for (j=1; j<size/2+1; j++) {
    141     spectrum[size-j]  = norm[j]*SIN(phas[j]);
     131    for (j=0; j < s->fft_size; j++) {
     132      s->specdata[j] = compspec->data[i][j];
     133    }
     134#endif
     135    fftw_execute(s->pbw);
     136    for (j = 0; j < output->length; j++) {
     137      output->data[i][j] = s->out[j]*renorm;
     138    }
    142139  }
    143140}
    144141
    145 #endif
    146 
    147 /* new interface aubio_mfft */
    148 struct _aubio_mfft_t {
    149         aubio_fft_t * fft;      /* fftw interface */
    150         fft_data_t ** spec;     /* complex spectral data */
    151         uint_t winsize;
    152         uint_t channels;
    153 };
    154 
    155 aubio_mfft_t * new_aubio_mfft(uint_t winsize, uint_t channels){
    156   uint_t i;
    157   aubio_mfft_t * fft = AUBIO_NEW(aubio_mfft_t);
    158   fft->winsize       = winsize;
    159   fft->channels      = channels;
    160   fft->fft           = new_aubio_fft(winsize);
    161   fft->spec          = AUBIO_ARRAY(fft_data_t*,channels);
    162   for (i=0; i < channels; i++)
    163     fft->spec[i] = AUBIO_ARRAY(fft_data_t,winsize);
    164   return fft;
     142void aubio_fft_get_spectrum(fvec_t * compspec, cvec_t * spectrum) {
     143  aubio_fft_get_phas(compspec, spectrum);
     144  aubio_fft_get_norm(compspec, spectrum);
    165145}
    166146
    167 /* execute stft */
    168 void aubio_mfft_do (aubio_mfft_t * fft,fvec_t * in,cvec_t * fftgrain){
    169   uint_t i=0;
    170   /* execute stft */
    171   for (i=0; i < fft->channels; i++) {
    172     aubio_fft_do (fft->fft,in->data[i],fft->spec[i],fft->winsize);
    173     /* put norm and phase into fftgrain */
    174     aubio_fft_getnorm(fftgrain->norm[i], fft->spec[i], fft->winsize);
    175     aubio_fft_getphas(fftgrain->phas[i], fft->spec[i], fft->winsize);
     147void aubio_fft_get_realimag(cvec_t * spectrum, fvec_t * compspec) {
     148  aubio_fft_get_imag(spectrum, compspec);
     149  aubio_fft_get_real(spectrum, compspec);
     150}
     151
     152void aubio_fft_get_phas(fvec_t * compspec, cvec_t * spectrum) {
     153  uint_t i, j;
     154  for (i = 0; i < spectrum->channels; i++) {
     155    spectrum->phas[i][0] = 0.;
     156    for (j=1; j < spectrum->length - 1; j++) {
     157      spectrum->phas[i][j] = atan2f(compspec->data[i][compspec->length-j],
     158          compspec->data[i][j]);
     159    }
     160    spectrum->phas[i][spectrum->length-1] = 0.;
    176161  }
    177162}
    178163
    179 /* execute inverse fourier transform */
    180 void aubio_mfft_rdo(aubio_mfft_t * fft,cvec_t * fftgrain, fvec_t * out){
    181   uint_t i=0;
    182   for (i=0; i < fft->channels; i++) {
    183     aubio_fft_getspectrum(fft->spec[i],fftgrain->norm[i],fftgrain->phas[i],fft->winsize);
    184     aubio_fft_rdo(fft->fft,fft->spec[i],out->data[i],fft->winsize);
     164void aubio_fft_get_norm(fvec_t * compspec, cvec_t * spectrum) {
     165  uint_t i, j = 0;
     166  for (i = 0; i < spectrum->channels; i++) {
     167    spectrum->norm[i][0] = compspec->data[i][0];
     168    for (j=1; j < spectrum->length - 1; j++) {
     169      spectrum->norm[i][j] = SQRT(SQR(compspec->data[i][j])
     170          + SQR(compspec->data[i][compspec->length - j]) );
     171    }
     172    spectrum->norm[i][spectrum->length-1] = compspec->data[i][compspec->length/2];
    185173  }
    186174}
    187175
    188 void del_aubio_mfft(aubio_mfft_t * fft) {
    189   uint_t i;
    190   for (i=0; i < fft->channels; i++)
    191     AUBIO_FREE(fft->spec[i]);
    192   AUBIO_FREE(fft->spec);
    193   del_aubio_fft(fft->fft);
    194   AUBIO_FREE(fft);       
     176void aubio_fft_get_imag(cvec_t * spectrum, fvec_t * compspec) {
     177  uint_t i, j;
     178  for (i = 0; i < compspec->channels; i++) {
     179    for (j = 1; j < compspec->length / 2 + 1; j++) {
     180      compspec->data[i][compspec->length - j] =
     181        spectrum->norm[i][j]*SIN(spectrum->phas[i][j]);
     182    }
     183  }
    195184}
     185
     186void aubio_fft_get_real(cvec_t * spectrum, fvec_t * compspec) {
     187  uint_t i, j;
     188  for (i = 0; i < compspec->channels; i++) {
     189    for (j = 0; j< compspec->length / 2 + 1; j++) {
     190      compspec->data[i][j] =
     191        spectrum->norm[i][j]*COS(spectrum->phas[i][j]);
     192    }
     193  }
     194}
  • src/fft.h

    ref7df76 rf218f29  
    6767
    6868  \param size length of the FFT
     69  \param channels number of channels
    6970
    7071*/
    71 aubio_fft_t * new_aubio_fft(uint_t size);
     72aubio_fft_t * new_aubio_fft(uint_t size, uint_t channels);
    7273/** delete FFT object
    7374
     
    7677*/
    7778void del_aubio_fft(aubio_fft_t * s);
     79
    7880/** compute forward FFT
    7981
    8082  \param s fft object as returned by new_aubio_fft
    81   \param data input signal
     83  \param input input signal
    8284  \param spectrum output spectrum
    83   \param size length of the input vector
    8485
    8586*/
    86 void aubio_fft_do (const aubio_fft_t *s, const smpl_t * data,
    87     fft_data_t * spectrum, const uint_t size);
     87void aubio_fft_do (aubio_fft_t *s, fvec_t * input, cvec_t * spectrum);
    8888/** compute backward (inverse) FFT
    8989
    9090  \param s fft object as returned by new_aubio_fft
    9191  \param spectrum input spectrum
    92   \param data output signal
    93   \param size length of the input vector
     92  \param output output signal
    9493
    9594*/
    96 void aubio_fft_rdo(const aubio_fft_t *s, const fft_data_t * spectrum,
    97     smpl_t * data, const uint_t size);
    98 /** compute norm vector from input spectrum
     95void aubio_fft_rdo (aubio_fft_t *s, cvec_t * spectrum, fvec_t * output);
    9996
    100   \param norm magnitude vector output
    101   \param spectrum spectral data input
    102   \param size size of the vectors
     97/** compute forward FFT
     98
     99  \param s fft object as returned by new_aubio_fft
     100  \param input real input signal
     101  \param compspec complex output fft real/imag
    103102
    104103*/
    105 void aubio_fft_getnorm(smpl_t * norm, fft_data_t * spectrum, uint_t size);
    106 /** compute phase vector from input spectrum
    107  
    108   \param phase phase vector output
    109   \param spectrum spectral data input
    110   \param size size of the vectors
     104void aubio_fft_do_complex (aubio_fft_t *s, fvec_t * input, fvec_t * compspec);
     105/** compute backward (inverse) FFT from real/imag
     106
     107  \param s fft object as returned by new_aubio_fft
     108  \param compspec real/imag input fft array
     109  \param output real output array
    111110
    112111*/
    113 void aubio_fft_getphas(smpl_t * phase, fft_data_t * spectrum, uint_t size);
     112void aubio_fft_rdo_complex (aubio_fft_t *s, fvec_t * compspec, fvec_t * output);
    114113
    115 /** FFT object (using cvec)
     114/** convert real/imag spectrum to norm/phas spectrum
    116115
    117   This object works similarly as aubio_fft_t, except the spectral data is
    118   stored in a cvec_t as two vectors, magnitude and phase.
     116  \param compspec real/imag input fft array
     117  \param spectrum cvec norm/phas output array
    119118
    120119*/
    121 typedef struct _aubio_mfft_t aubio_mfft_t;
     120void aubio_fft_get_spectrum(fvec_t * compspec, cvec_t * spectrum);
     121/** convert real/imag spectrum to norm/phas spectrum
    122122
    123 /** create new FFT computation object
    124 
    125   \param winsize length of the FFT
    126   \param channels number of channels
     123  \param compspec real/imag input fft array
     124  \param spectrum cvec norm/phas output array
    127125
    128126*/
    129 aubio_mfft_t * new_aubio_mfft(uint_t winsize, uint_t channels);
    130 /** compute forward FFT
     127void aubio_fft_get_realimag(cvec_t * spectrum, fvec_t * compspec);
    131128
    132   \param fft fft object as returned by new_aubio_mfft
    133   \param in input signal
    134   \param fftgrain output spectrum
     129/** compute phas spectrum from real/imag parts
     130
     131  \param compspec real/imag input fft array
     132  \param spectrum cvec norm/phas output array
    135133
    136134*/
    137 void aubio_mfft_do (aubio_mfft_t * fft,fvec_t * in,cvec_t * fftgrain);
    138 /** compute backward (inverse) FFT
     135void aubio_fft_get_phas(fvec_t * compspec, cvec_t * spectrum);
     136/** compute imaginary part from the norm/phas cvec
    139137
    140   \param fft fft object as returned by new_aubio_mfft
    141   \param fftgrain input spectrum (cvec)
    142   \param out output signal
     138  \param spectrum norm/phas input array
     139  \param compspec real/imag output fft array
    143140
    144141*/
    145 void aubio_mfft_rdo(aubio_mfft_t * fft,cvec_t * fftgrain, fvec_t * out);
    146 /** delete FFT object
     142void aubio_fft_get_imag(cvec_t * spectrum, fvec_t * compspec);
    147143
    148   \param fft fft object as returned by new_aubio_mfft
     144/** compute norm component from real/imag parts
     145
     146  \param compspec real/imag input fft array
     147  \param spectrum cvec norm/phas output array
    149148
    150149*/
    151 void del_aubio_mfft(aubio_mfft_t * fft);
     150void aubio_fft_get_norm(fvec_t * compspec, cvec_t * spectrum);
     151/** compute real part from norm/phas components
    152152
     153  \param spectrum norm/phas input array
     154  \param compspec real/imag output fft array
     155
     156*/
     157void aubio_fft_get_real(cvec_t * spectrum, fvec_t * compspec);
    153158
    154159#ifdef __cplusplus
     
    156161#endif
    157162
    158 #endif
     163#endif // FFT_H_
  • src/hist.c

    ref7df76 rf218f29  
    11/*
    2         Copyright (C) 2003 Paul Brossier
     2  Copyright (C) 2003 Paul Brossier
    33
    4         This program is free software; you can redistribute it and/or modify
    5         it under the terms of the GNU General Public License as published by
    6         the Free Software Foundation; either version 2 of the License, or
    7         (at your option) any later version.
     4  This program is free software; you can redistribute it and/or modify
     5  it under the terms of the GNU General Public License as published by
     6  the Free Software Foundation; either version 2 of the License, or
     7  (at your option) any later version.
    88
    9         This program is distributed in the hope that it will be useful,
    10         but WITHOUT ANY WARRANTY; without even the implied warranty of
    11         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    12         GNU General Public License for more details.
     9  This program is distributed in the hope that it will be useful,
     10  but WITHOUT ANY WARRANTY; without even the implied warranty of
     11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     12  GNU General Public License for more details.
    1313
    14         You should have received a copy of the GNU General Public License
    15         along with this program; if not, write to the Free Software
    16         Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    17          */
     14  You should have received a copy of the GNU General Public License
     15  along with this program; if not, write to the Free Software
     16  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
     17*/
    1818
    1919#include "aubio_priv.h"
     
    2828
    2929struct _aubio_hist_t {
    30         /*bug: move to a fvec */
    31         smpl_t ** hist;
    32         uint_t nelems;
    33         uint_t channels;
    34         smpl_t * cent;
    35         aubio_scale_t *scaler;
     30  fvec_t * hist;
     31  uint_t nelems;
     32  uint_t channels;
     33  fvec_t * cent;
     34  aubio_scale_t *scaler;
    3635};
    3736
     
    4039 */
    4140aubio_hist_t * new_aubio_hist (smpl_t ilow, smpl_t ihig, uint_t nelems, uint_t channels){
    42         aubio_hist_t * s = AUBIO_NEW(aubio_hist_t);
    43         smpl_t step = (ihig-ilow)/(smpl_t)(nelems);
    44         smpl_t accum = step;
    45         uint_t i;
    46         s->channels = channels;
    47         s->nelems = nelems;
    48         s->hist = AUBIO_ARRAY(smpl_t*, channels);
    49         for (i=0; i< s->channels; i++) {
    50                 s->hist[i] = AUBIO_ARRAY(smpl_t, nelems);
    51         }
    52         s->cent = AUBIO_ARRAY(smpl_t, nelems);
    53        
    54         /* use scale to map ilow/ihig -> 0/nelems */
    55         s->scaler = new_aubio_scale(ilow,ihig,0,nelems);
    56         /* calculate centers now once */
    57         s->cent[0] = ilow + 0.5 * step;
    58         for (i=1; i < s->nelems; i++, accum+=step )
    59                 s->cent[i] = s->cent[0] + accum;
    60        
    61         return s;       
     41  aubio_hist_t * s = AUBIO_NEW(aubio_hist_t);
     42  smpl_t step = (ihig-ilow)/(smpl_t)(nelems);
     43  smpl_t accum = step;
     44  uint_t i;
     45  s->channels = channels;
     46  s->nelems = nelems;
     47  s->hist = new_fvec(nelems, channels);
     48  s->cent = new_fvec(nelems, 1);
     49
     50  /* use scale to map ilow/ihig -> 0/nelems */
     51  s->scaler = new_aubio_scale(ilow,ihig,0,nelems);
     52  /* calculate centers now once */
     53  s->cent->data[0][0] = ilow + 0.5 * step;
     54  for (i=1; i < s->nelems; i++, accum+=step )
     55    s->cent->data[0][i] = s->cent->data[0][0] + accum;
     56
     57  return s;
    6258}
    6359
    6460void del_aubio_hist(aubio_hist_t *s) {
    65         uint_t i;
    66         for (i=0; i< s->channels; i++) {
    67                 AUBIO_FREE(s->hist[i]);
    68         }
    69         AUBIO_FREE(s->hist);
    70         AUBIO_FREE(s->cent);
    71         del_aubio_scale(s->scaler);
    72         AUBIO_FREE(s);
     61  del_fvec(s->hist);
     62  del_fvec(s->cent);
     63  del_aubio_scale(s->scaler);
     64  AUBIO_FREE(s);
    7365}
    7466
     
    7668 * do it
    7769 */
    78 void aubio_hist_do (aubio_hist_t *s, fvec_t *input)
    79 {
    80         uint_t i,j;
    81         sint_t tmp = 0;
    82         aubio_scale_do(s->scaler, input);
    83         /* reset data */
    84         for (i=0; i < s->channels; i++)
    85                 for (j=0; j < s->nelems; j++)
    86                         s->hist[i][j] = 0;
    87         /* run accum */
    88         for (i=0; i < input->channels; i++)
    89                 for (j=0;  j < input->length; j++)
    90                 {
    91                         tmp = (sint_t)FLOOR(input->data[i][j]);
    92                         if ((tmp >= 0) && (tmp < (sint_t)s->nelems))
    93                                 s->hist[i][tmp] += 1;
    94                 }
     70void aubio_hist_do (aubio_hist_t *s, fvec_t *input) {
     71  uint_t i,j;
     72  sint_t tmp = 0;
     73  aubio_scale_do(s->scaler, input);
     74  /* reset data */
     75  for (i=0; i < s->channels; i++)
     76    for (j=0; j < s->nelems; j++)
     77      s->hist->data[i][j] = 0;
     78  /* run accum */
     79  for (i=0; i < input->channels; i++)
     80    for (j=0;  j < input->length; j++)
     81    {
     82      tmp = (sint_t)FLOOR(input->data[i][j]);
     83      if ((tmp >= 0) && (tmp < (sint_t)s->nelems))
     84        s->hist->data[i][tmp] += 1;
     85    }
    9586}
    9687
    97 void aubio_hist_do_notnull (aubio_hist_t *s, fvec_t *input)
    98 {
    99         uint_t i,j;
    100         sint_t tmp = 0;
    101         aubio_scale_do(s->scaler, input);
    102         /* reset data */
    103         for (i=0; i < s->channels; i++)
    104                 for (j=0; j < s->nelems; j++)
    105                         s->hist[i][j] = 0;
    106         /* run accum */
    107         for (i=0; i < input->channels; i++)
    108                 for (j=0;  j < input->length; j++)
    109                 {
    110                         if (input->data[i][j] != 0) {
    111                                 tmp = (sint_t)FLOOR(input->data[i][j]);
    112                                 if ((tmp >= 0) && (tmp < (sint_t)s->nelems))
    113                                         s->hist[i][tmp] += 1;
    114                         }
    115                 }
     88void aubio_hist_do_notnull (aubio_hist_t *s, fvec_t *input) {
     89  uint_t i,j;
     90  sint_t tmp = 0;
     91  aubio_scale_do(s->scaler, input);
     92  /* reset data */
     93  for (i=0; i < s->channels; i++)
     94    for (j=0; j < s->nelems; j++)
     95      s->hist->data[i][j] = 0;
     96  /* run accum */
     97  for (i=0; i < input->channels; i++)
     98    for (j=0;  j < input->length; j++) {
     99      if (input->data[i][j] != 0) {
     100        tmp = (sint_t)FLOOR(input->data[i][j]);
     101        if ((tmp >= 0) && (tmp < (sint_t)s->nelems))
     102          s->hist->data[i][tmp] += 1;
     103      }
     104    }
    116105}
    117106
    118107
    119 void aubio_hist_dyn_notnull (aubio_hist_t *s, fvec_t *input)
    120 {
    121         uint_t i,j;
    122         sint_t tmp = 0;
    123         smpl_t ilow = vec_min(input);
    124         smpl_t ihig = vec_max(input);
    125         smpl_t step = (ihig-ilow)/(smpl_t)(s->nelems);
    126        
    127         /* readapt */
    128         aubio_scale_set(s->scaler, ilow, ihig, 0, s->nelems);
     108void aubio_hist_dyn_notnull (aubio_hist_t *s, fvec_t *input) {
     109  uint_t i,j;
     110  sint_t tmp = 0;
     111  smpl_t ilow = vec_min(input);
     112  smpl_t ihig = vec_max(input);
     113  smpl_t step = (ihig-ilow)/(smpl_t)(s->nelems);
    129114
    130         /* recalculate centers */
    131         s->cent[0] = ilow + 0.5f * step;
    132         for (i=1; i < s->nelems; i++)
    133                 s->cent[i] = s->cent[0] + i * step;
     115  /* readapt */
     116  aubio_scale_set(s->scaler, ilow, ihig, 0, s->nelems);
    134117
    135         /* scale */     
    136         aubio_scale_do(s->scaler, input);
     118  /* recalculate centers */
     119  s->cent->data[0][0] = ilow + 0.5f * step;
     120  for (i=1; i < s->nelems; i++)
     121    s->cent->data[0][i] = s->cent->data[0][0] + i * step;
    137122
    138         /* reset data */
    139         for (i=0; i < s->channels; i++)
    140                 for (j=0; j < s->nelems; j++)
    141                         s->hist[i][j] = 0;
    142         /* run accum */
    143         for (i=0; i < input->channels; i++)
    144                 for (j=0;  j < input->length; j++)
    145                 {
    146                         if (input->data[i][j] != 0) {
    147                                 tmp = (sint_t)FLOOR(input->data[i][j]);
    148                                 if ((tmp >= 0) && (tmp < (sint_t)s->nelems))
    149                                         s->hist[i][tmp] += 1;
    150                         }
    151                 }
     123  /* scale */
     124  aubio_scale_do(s->scaler, input);
     125
     126  /* reset data */
     127  for (i=0; i < s->channels; i++)
     128    for (j=0; j < s->nelems; j++)
     129      s->hist->data[i][j] = 0;
     130  /* run accum */
     131  for (i=0; i < input->channels; i++)
     132    for (j=0;  j < input->length; j++) {
     133      if (input->data[i][j] != 0) {
     134        tmp = (sint_t)FLOOR(input->data[i][j]);
     135        if ((tmp >= 0) && (tmp < (sint_t)s->nelems))
     136          s->hist->data[i][tmp] += 1;
     137      }
     138    }
    152139}
    153140
    154 void aubio_hist_weigth (aubio_hist_t *s)
    155 {
    156         uint_t i,j;
    157         for (i=0; i < s->channels; i++)
    158                 for (j=0; j < s->nelems; j++) {
    159                         s->hist[i][j] *= s->cent[j];
    160                 }
     141void aubio_hist_weight (aubio_hist_t *s) {
     142  uint_t i,j;
     143  for (i=0; i < s->channels; i++)
     144    for (j=0; j < s->nelems; j++) {
     145      s->hist->data[i][j] *= s->cent->data[0][j];
     146    }
    161147}
    162148
    163 smpl_t aubio_hist_mean (aubio_hist_t *s)
    164 {
    165         uint_t i,j;
    166         smpl_t tmp = 0.0f;
    167         for (i=0; i < s->channels; i++)
    168                 for (j=0; j < s->nelems; j++)
    169                         tmp += s->hist[i][j];
    170         return tmp/(smpl_t)(s->nelems);
     149smpl_t aubio_hist_mean (aubio_hist_t *s) {
     150  uint_t i,j;
     151  smpl_t tmp = 0.0f;
     152  for (i=0; i < s->channels; i++)
     153    for (j=0; j < s->nelems; j++)
     154      tmp += s->hist->data[i][j];
     155  return tmp/(smpl_t)(s->nelems);
    171156}
    172157
  • src/hist.h

    ref7df76 rf218f29  
    11/*
    2         Copyright (C) 2003 Paul Brossier
     2  Copyright (C) 2003 Paul Brossier
    33
    4         This program is free software; you can redistribute it and/or modify
    5         it under the terms of the GNU General Public License as published by
    6         the Free Software Foundation; either version 2 of the License, or
    7         (at your option) any later version.
     4  This program is free software; you can redistribute it and/or modify
     5  it under the terms of the GNU General Public License as published by
     6  the Free Software Foundation; either version 2 of the License, or
     7  (at your option) any later version.
    88
    9         This program is distributed in the hope that it will be useful,
    10         but WITHOUT ANY WARRANTY; without even the implied warranty of
    11         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    12         GNU General Public License for more details.
     9  This program is distributed in the hope that it will be useful,
     10  but WITHOUT ANY WARRANTY; without even the implied warranty of
     11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     12  GNU General Public License for more details.
    1313
    14          You should have received a copy of the GNU General Public License
    15          along with this program; if not, write to the Free Software
    16          Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    17          */
     14   You should have received a copy of the GNU General Public License
     15   along with this program; if not, write to the Free Software
     16   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
     17
     18*/
    1819
    1920/** @file
     
    3435typedef struct _aubio_hist_t aubio_hist_t;
    3536
    36 /** histogram creation 
     37/** histogram creation
    3738 * \param flow minimum input
    3839 * \param fhig maximum input
    3940 * \param nelems number of histogram columns
    40  * \param channels number of channels 
     41 * \param channels number of channels
    4142 */
    4243aubio_hist_t * new_aubio_hist(smpl_t flow, smpl_t fhig, uint_t nelems, uint_t channels);
     
    4849void aubio_hist_do_notnull(aubio_hist_t *s, fvec_t * input);
    4950/** compute the mean of the histogram */
    50 smpl_t aubio_hist_mean(aubio_hist_t *s); 
     51smpl_t aubio_hist_mean(aubio_hist_t *s);
    5152/** weight the histogram */
    52 void aubio_hist_weigth(aubio_hist_t *s);
     53void aubio_hist_weight(aubio_hist_t *s);
    5354/** compute dynamic histogram for non-null elements */
    5455void aubio_hist_dyn_notnull (aubio_hist_t *s, fvec_t *input);
  • src/onsetdetection.c

    ref7df76 rf218f29  
    129129                aubio_hist_dyn_notnull(o->histog,o->dev1);
    130130                /* weight it */
    131                 aubio_hist_weigth(o->histog);
     131                aubio_hist_weight(o->histog);
    132132                /* its mean is the result */
    133133                onset->data[i][0] = aubio_hist_mean(o->histog);
     
    158158                aubio_hist_dyn_notnull(o->histog,o->dev1);
    159159                /* weight it */
    160                 aubio_hist_weigth(o->histog);
     160                aubio_hist_weight(o->histog);
    161161                /* its mean is the result */
    162162                onset->data[i][0] = aubio_hist_mean(o->histog);
  • src/phasevoc.c

    ref7df76 rf218f29  
    1919
    2020#include "aubio_priv.h"
    21 #include "sample.h"
     21#include "fvec.h"
     22#include "cvec.h"
    2223#include "fft.h"
    2324#include "mathutils.h"
     
    2930  uint_t hop_s;       /** overlap step */
    3031  uint_t channels;    /** number of channels */
    31   aubio_mfft_t * fft; /** spectral data */
    32   fvec_t * synth;     /**cur output grain [win_s] */
    33   fvec_t * synthold;  /**last input frame [win_s-hop_s] */
    34   fvec_t * data;      /**current input grain [win_s] */
    35   fvec_t * dataold;   /**last input frame [win_s-hop_s] */
    36   smpl_t * w;          /** grain window [win_s] */
     32  aubio_fft_t * fft;  /** fft object */
     33  fvec_t * synth;     /** cur output grain [win_s] */
     34  fvec_t * synthold;  /** last input frame [win_s-hop_s] */
     35  fvec_t * data;      /** current input grain [win_s] */
     36  fvec_t * dataold;   /** last input frame [win_s-hop_s] */
     37  smpl_t * w;         /** grain window [win_s] */
    3738};
    3839
     
    5859  vec_shift(pv->data);
    5960  /* calculate fft */
    60   aubio_mfft_do (pv->fft,pv->data,fftgrain);
     61  aubio_fft_do (pv->fft,pv->data,fftgrain);
    6162}
    6263
     
    6465  uint_t i;
    6566  /* calculate rfft */
    66   aubio_mfft_rdo(pv->fft,fftgrain,pv->synth);
     67  aubio_fft_rdo(pv->fft,fftgrain,pv->synth);
    6768  /* unshift */
    6869  vec_shift(pv->synth);
     
    8889  }
    8990
    90   pv->fft      = new_aubio_mfft(win_s,channels);
     91  pv->fft      = new_aubio_fft(win_s,channels);
    9192
    9293  /* remember old */
     
    112113  del_fvec(pv->dataold);
    113114  del_fvec(pv->synthold);
    114   del_aubio_mfft(pv->fft);
     115  del_aubio_fft(pv->fft);
    115116  AUBIO_FREE(pv->w);
    116117  AUBIO_FREE(pv);
  • src/pitchfcomb.c

    ref7df76 rf218f29  
    3939        cvec_t * fftOut;
    4040        fvec_t * fftLastPhase;
    41         aubio_mfft_t * fft;
     41        aubio_fft_t * fft;
    4242        //aubio_pvoc_t * pvoc;
    4343};
     
    5252  p->fftOut       = new_cvec(bufsize,1);
    5353  p->fftLastPhase = new_fvec(bufsize,1);
    54   p->fft = new_aubio_mfft(bufsize, 1);
     54  p->fft = new_aubio_fft(bufsize, 1);
    5555  p->win = new_fvec(bufsize,1);
    5656  aubio_window(p->win->data[0], bufsize, aubio_win_hanning);
     
    7474          p->winput->data[0][k] = p->win->data[0][k] * input->data[0][k];
    7575  }
    76   aubio_mfft_do(p->fft,p->winput,p->fftOut);
     76  aubio_fft_do(p->fft,p->winput,p->fftOut);
    7777
    7878  for (k=0; k<=p->fftSize/2; k++) {
     
    130130  del_fvec(p->win);
    131131  del_fvec(p->winput);
    132   del_aubio_mfft(p->fft);
     132  del_aubio_fft(p->fft);
    133133  AUBIO_FREE(p);
    134134}
  • src/pitchyinfft.c

    ref7df76 rf218f29  
    3131  fvec_t * weight;    /**< spectral weighting window (psychoacoustic model) */
    3232  cvec_t * fftout;    /**< Fourier transform output */
    33   aubio_mfft_t * fft; /**< fft object to compute square difference function */
     33  aubio_fft_t * fft; /**< fft object to compute square difference function */
    3434  fvec_t * yinfft;    /**< Yin function */
    3535};
     
    4949  aubio_pitchyinfft_t * p = AUBIO_NEW(aubio_pitchyinfft_t);
    5050  p->winput       = new_fvec(bufsize,1);
    51   p->fft          = new_aubio_mfft(bufsize, 1);
     51  p->fft          = new_aubio_fft(bufsize, 1);
    5252  p->fftout       = new_cvec(bufsize,1);
    5353  p->sqrmag       = new_fvec(bufsize,1);
     
    9797          p->winput->data[0][l] = p->win->data[0][l] * input->data[0][l];
    9898  }
    99   aubio_mfft_do(p->fft,p->winput,p->fftout);
     99  aubio_fft_do(p->fft,p->winput,p->fftout);
    100100  for (l=0; l < p->fftout->length; l++){
    101101          p->sqrmag->data[0][l] = SQR(p->fftout->norm[0][l]);
     
    112112  }
    113113  sum *= 2.;
    114   aubio_mfft_do(p->fft,p->sqrmag,res);
     114  aubio_fft_do(p->fft,p->sqrmag,res);
    115115  yin->data[0][0] = 1.;
    116116  for (tau=1; tau < yin->length; tau++) {
     
    143143void del_aubio_pitchyinfft(aubio_pitchyinfft_t *p){
    144144        del_fvec(p->win);
    145         del_aubio_mfft(p->fft);
     145        del_aubio_fft(p->fft);
    146146        del_fvec(p->yinfft);
    147147        del_fvec(p->sqrmag);
  • src/scale.c

    ref7df76 rf218f29  
    11/*
    2         Copyright (C) 2003 Paul Brossier
     2  Copyright (C) 2003 Paul Brossier
    33
    4         This program is free software; you can redistribute it and/or modify
    5         it under the terms of the GNU General Public License as published by
    6         the Free Software Foundation; either version 2 of the License, or
    7         (at your option) any later version.
     4  This program is free software; you can redistribute it and/or modify
     5  it under the terms of the GNU General Public License as published by
     6  the Free Software Foundation; either version 2 of the License, or
     7  (at your option) any later version.
    88
    9         This program is distributed in the hope that it will be useful,
    10         but WITHOUT ANY WARRANTY; without even the implied warranty of
    11         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    12         GNU General Public License for more details.
     9  This program is distributed in the hope that it will be useful,
     10  but WITHOUT ANY WARRANTY; without even the implied warranty of
     11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     12  GNU General Public License for more details.
    1313
    14          You should have received a copy of the GNU General Public License
    15          along with this program; if not, write to the Free Software
    16          Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
     14   You should have received a copy of the GNU General Public License
     15   along with this program; if not, write to the Free Software
     16   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
     17
    1718*/
    1819
     
    2223
    2324struct _aubio_scale_t {
    24         smpl_t ilow;
    25         smpl_t ihig;
    26         smpl_t olow;
    27         smpl_t ohig;
     25  smpl_t ilow;
     26  smpl_t ihig;
     27  smpl_t olow;
     28  smpl_t ohig;
    2829
    29         smpl_t scaler;
    30         smpl_t irange;
    31        
    32         /* not implemented yet : type in/out data
    33         bool inint;
    34         bool outint;
    35         */
     30  smpl_t scaler;
     31  smpl_t irange;
     32
     33  /* not implemented yet : type in/out data
     34     bool inint;
     35     bool outint;
     36     */
    3637};
    3738
    38 aubio_scale_t * new_aubio_scale (smpl_t ilow, smpl_t ihig, smpl_t olow, smpl_t ohig     ){
    39         aubio_scale_t * s = AUBIO_NEW(aubio_scale_t);
    40         aubio_scale_set (s, ilow, ihig, olow, ohig);
    41         return s;       
     39aubio_scale_t * new_aubio_scale (smpl_t ilow, smpl_t ihig,
     40    smpl_t olow, smpl_t ohig) {
     41  aubio_scale_t * s = AUBIO_NEW(aubio_scale_t);
     42  aubio_scale_set (s, ilow, ihig, olow, ohig);
     43  return s;
    4244}
    4345
    4446void del_aubio_scale(aubio_scale_t *s) {
    45         AUBIO_FREE(s);
     47  AUBIO_FREE(s);
    4648}
    4749
    48 void aubio_scale_set (aubio_scale_t *s, smpl_t ilow, smpl_t ihig, smpl_t olow, smpl_t ohig)
    49 {
    50         smpl_t inputrange = ihig - ilow;
    51         smpl_t outputrange= ohig - olow;
    52         s->ilow = ilow;
    53         s->ihig = ihig;
    54         s->olow = olow;
    55         s->ohig = ohig;
    56         if (inputrange == 0 )
    57                 s->scaler = 0.0f;
    58         else {
    59                 s->scaler = outputrange/inputrange;
    60                 if (inputrange < 0 )
    61                         inputrange = inputrange * -1.0f;
    62         }
     50void aubio_scale_set (aubio_scale_t *s, smpl_t ilow, smpl_t ihig,
     51    smpl_t olow, smpl_t ohig) {
     52  smpl_t inputrange = ihig - ilow;
     53  smpl_t outputrange= ohig - olow;
     54  s->ilow = ilow;
     55  s->ihig = ihig;
     56  s->olow = olow;
     57  s->ohig = ohig;
     58  if (inputrange == 0) {
     59    s->scaler = 0.0f;
     60  } else {
     61    s->scaler = outputrange/inputrange;
     62    if (inputrange < 0) {
     63      inputrange = inputrange * -1.0f;
     64    }
     65  }
    6366}
    6467
    6568void aubio_scale_do (aubio_scale_t *s, fvec_t *input)
    6669{
    67         uint_t i, j;
    68         for (i=0; i < input->channels; i++){
    69                 for (j=0;  j < input->length; j++){
    70                         input->data[i][j] -= s->ilow;
    71                         input->data[i][j] *= s->scaler;
    72                         input->data[i][j] += s->olow;
    73                 }
    74         }
     70  uint_t i, j;
     71  for (i=0; i < input->channels; i++){
     72    for (j=0;  j < input->length; j++){
     73      input->data[i][j] -= s->ilow;
     74      input->data[i][j] *= s->scaler;
     75      input->data[i][j] += s->olow;
     76    }
     77  }
    7578}
    7679
  • src/scale.h

    ref7df76 rf218f29  
    11/*
    2         Copyright (C) 2003 Paul Brossier
     2  Copyright (C) 2003 Paul Brossier
    33
    4         This program is free software; you can redistribute it and/or modify
    5         it under the terms of the GNU General Public License as published by
    6         the Free Software Foundation; either version 2 of the License, or
    7         (at your option) any later version.
     4  This program is free software; you can redistribute it and/or modify
     5  it under the terms of the GNU General Public License as published by
     6  the Free Software Foundation; either version 2 of the License, or
     7  (at your option) any later version.
    88
    9         This program is distributed in the hope that it will be useful,
    10         but WITHOUT ANY WARRANTY; without even the implied warranty of
    11         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    12         GNU General Public License for more details.
     9  This program is distributed in the hope that it will be useful,
     10  but WITHOUT ANY WARRANTY; without even the implied warranty of
     11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     12  GNU General Public License for more details.
    1313
    14         You should have received a copy of the GNU General Public License
    15         along with this program; if not, write to the Free Software
    16         Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
     14  You should have received a copy of the GNU General Public License
     15  along with this program; if not, write to the Free Software
     16  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    1717*/
    1818
     
    4545
    4646*/
    47 aubio_scale_t * new_aubio_scale(smpl_t flow, smpl_t fhig, smpl_t ilow, smpl_t ihig      );
     47aubio_scale_t * new_aubio_scale(smpl_t flow, smpl_t fhig,
     48    smpl_t ilow, smpl_t ihig);
    4849/** delete a scale object
    4950
     
    6869
    6970*/
    70 void aubio_scale_set (aubio_scale_t *s, smpl_t ilow, smpl_t ihig, smpl_t olow, smpl_t ohig);
     71void aubio_scale_set (aubio_scale_t *s, smpl_t ilow, smpl_t ihig,
     72    smpl_t olow, smpl_t ohig);
    7173
    7274#ifdef __cplusplus
  • swig/aubio.i

    ref7df76 rf218f29  
    7272
    7373/* fft */
    74 extern void aubio_fft_getnorm(smpl_t * norm, fft_data_t * spectrum, uint_t size);
    75 extern void aubio_fft_getphas(smpl_t * phase, fft_data_t * spectrum, uint_t size);
    76 
    77 extern aubio_mfft_t * new_aubio_mfft(uint_t winsize, uint_t channels);
    78 extern void aubio_mfft_do (aubio_mfft_t * fft,fvec_t * in,cvec_t * fftgrain);
    79 extern void aubio_mfft_rdo(aubio_mfft_t * fft,cvec_t * fftgrain, fvec_t * out);
    80 extern void del_aubio_mfft(aubio_mfft_t * fft);
    81 
     74extern aubio_fft_t * new_aubio_fft(uint_t size, uint_t channels);
     75extern void del_aubio_fft(aubio_fft_t * s);
     76extern void aubio_fft_do (aubio_fft_t *s, fvec_t * input, cvec_t * spectrum);
     77extern void aubio_fft_rdo (aubio_fft_t *s, cvec_t * spectrum, fvec_t * output);
     78extern void aubio_fft_do_complex (aubio_fft_t *s, fvec_t * input, fvec_t * compspec);
     79extern void aubio_fft_rdo_complex (aubio_fft_t *s, fvec_t * compspec, fvec_t * output);
     80extern void aubio_fft_get_spectrum(fvec_t * compspec, cvec_t * spectrum);
     81extern void aubio_fft_get_realimag(cvec_t * spectrum, fvec_t * compspec);
     82extern void aubio_fft_get_phas(fvec_t * compspec, cvec_t * spectrum);
     83extern void aubio_fft_get_imag(cvec_t * spectrum, fvec_t * compspec);
     84extern void aubio_fft_get_norm(fvec_t * compspec, cvec_t * spectrum);
     85extern void aubio_fft_get_real(cvec_t * spectrum, fvec_t * compspec);
    8286
    8387/* filter */
     
    101105extern void aubio_hist_do(aubio_hist_t *s, fvec_t * input);
    102106extern void aubio_hist_do_notnull(aubio_hist_t *s, fvec_t * input);
    103 extern void aubio_hist_dyn_notnull (aubio_hist_t *s, fvec_t *input);
     107extern void aubio_hist_dyn_notnull(aubio_hist_t *s, fvec_t *input);
     108extern void aubio_hist_weight(aubio_hist_t *s);
     109extern smpl_t aubio_hist_mean(aubio_hist_t *s);
    104110
    105111/* mathutils */
  • tests/python/fft.py

    ref7df76 rf218f29  
    1 import unittest
    21import math
     2
     3from template import aubio_unit_template
    34
    45from aubio.aubiowrapper import *
    56
    6 buf_size = 8092
     7buf_size = 1024
    78channels = 4
    89
    9 precision = 6
    10 
    11 class aubio_mfft_test_case(unittest.TestCase):
     10class fft_unit(aubio_unit_template):
    1211
    1312  def setUp(self):
    14     self.o = new_aubio_mfft(buf_size, channels)
     13    self.o = new_aubio_fft(buf_size, channels)
    1514
    1615  def tearDown(self):
    17     del_aubio_mfft(self.o)
     16    del_aubio_fft(self.o)
    1817
    1918  def test_create(self):
     
    2120    pass
    2221
    23   def test_aubio_mfft_do_zeroes(self):
    24     """ test aubio_mfft_do on zeroes """
     22  def test_do_zeroes(self):
     23    """ test aubio_fft_do on zeroes """
    2524    input    = new_fvec(buf_size, channels)
    2625    fftgrain = new_cvec(buf_size, channels)
    2726    for index in range(buf_size):
    2827      for channel in range(channels):
    29         self.assertEqual(0., fvec_read_sample(input, channel, index))
    30     aubio_mfft_do(self.o, input, fftgrain)
     28        self.assertCloseEnough(0., fvec_read_sample(input, channel, index))
     29    aubio_fft_do(self.o, input, fftgrain)
    3130    for index in range(buf_size/2+1):
    3231      for channel in range(channels):
    33         self.assertEqual(0., cvec_read_norm(fftgrain, channel, index))
     32        self.assertCloseEnough(0., cvec_read_norm(fftgrain, channel, index))
    3433    for index in range(buf_size/2+1):
    3534      for channel in range(channels):
    36         self.assertEqual(0., cvec_read_phas(fftgrain, channel, index))
     35        self.assertCloseEnough(0., cvec_read_phas(fftgrain, channel, index))
    3736    del fftgrain
    3837    del input
    3938
    40   def test_aubio_mfft_rdo_zeroes(self):
    41     """ test aubio_mfft_rdo on zeroes """
     39  def test_rdo_zeroes(self):
     40    """ test aubio_fft_rdo on zeroes """
    4241    fftgrain = new_cvec(buf_size, channels)
    4342    output    = new_fvec(buf_size, channels)
    44     aubio_mfft_rdo(self.o, fftgrain, output)
     43    aubio_fft_rdo(self.o, fftgrain, output)
    4544    # check output
    4645    for index in range(buf_size):
     
    5049    del output
    5150
    52   def test_aubio_mfft_do_impulse(self):
    53     """ test aubio_mfft_do with an impulse on one channel """
     51  def test_do_impulse(self):
     52    """ test aubio_fft_do with an impulse on one channel """
    5453    input    = new_fvec(buf_size, channels)
    5554    fftgrain = new_cvec(buf_size, channels)
     
    5756    some_constant = 0.3412432456
    5857    fvec_write_sample(input, some_constant, 0, 0)
    59     aubio_mfft_do(self.o, input, fftgrain)
     58    aubio_fft_do(self.o, input, fftgrain)
    6059    # check norm
    6160    for index in range(buf_size/2+1):
    62       self.assertAlmostEqual(some_constant, cvec_read_norm(fftgrain, 0, index), precision)
     61      self.assertCloseEnough(some_constant, cvec_read_norm(fftgrain, 0, index))
    6362    for index in range(buf_size/2+1):
    6463      for channel in range(1, channels):
     
    7170    del input
    7271
    73   def test_aubio_mfft_do_constant(self):
    74     """ test aubio_mfft_do with a constant on one channel """
     72  def test_do_constant(self):
     73    """ test aubio_fft_do with a constant on one channel """
    7574    input    = new_fvec(buf_size, channels)
    7675    fftgrain = new_cvec(buf_size, channels)
     
    7978    for index in range(1,buf_size):
    8079      fvec_write_sample(input, some_constant, 0, index)
    81     aubio_mfft_do(self.o, input, fftgrain)
     80    aubio_fft_do(self.o, input, fftgrain)
    8281    # check norm and phase == 0 in all other channels
    8382    for index in range(buf_size/2+1):
    8483      for channel in range(1, channels):
    8584        self.assertEqual(0., cvec_read_norm(fftgrain, channel, index))
     85        self.assertEqual(0., cvec_read_phas(fftgrain, channel, index))
     86
    8687    # check norm and phase == 0 in first first and last bin of first channel
    87     self.assertAlmostEqual((buf_size-1)*some_constant, cvec_read_norm(fftgrain, 0, 0), precision)
    88     self.assertEqual(0., cvec_read_phas(fftgrain, 0, 0))
    89     self.assertEqual(0., cvec_read_norm(fftgrain, 0, buf_size/2+1))
    90     self.assertEqual(0., cvec_read_phas(fftgrain, 0, buf_size/2+1))
    91     # check unwrap2pi(phas) ~= pi everywhere but in first bin
     88    # check unwrap2pi(phas) ~= pi everywhere but in first and last bin
     89    self.assertCloseEnough(0., cvec_read_phas(fftgrain, 0, 0))
     90    for index in range(1,buf_size/2):
     91       self.assertCloseEnough(math.pi, aubio_unwrap2pi(cvec_read_phas(fftgrain, 0, index)))
     92    self.assertCloseEnough(0., cvec_read_phas(fftgrain, 0, buf_size/2))
     93    self.assertCloseEnough(0., cvec_read_phas(fftgrain, 0, buf_size/2+1))
     94
     95    self.assertCloseEnough((buf_size-1)*some_constant, cvec_read_norm(fftgrain, 0, 0))
    9296    for index in range(1,buf_size/2+1):
    93        self.assertAlmostEqual ( math.pi, aubio_unwrap2pi(cvec_read_phas(fftgrain, 0, index)), precision)
    94        self.assertAlmostEqual(some_constant, cvec_read_norm(fftgrain, 0, index), precision)
     97       self.assertCloseEnough(some_constant, abs(cvec_read_norm(fftgrain, 0, index)))
     98    self.assertCloseEnough(0., cvec_read_norm(fftgrain, 0, buf_size/2+1))
     99
    95100    del fftgrain
    96101    del input
    97102
    98   def test_aubio_mfft_do_impulse_multichannel(self):
    99     " test aubio_mfft_do on impulse two channels "
     103  def test_do_impulse_multichannel(self):
     104    " test aubio_fft_do on impulse two channels "
    100105    input    = new_fvec(buf_size, channels)
    101106    fftgrain = new_cvec(buf_size, channels)
     
    103108    fvec_write_sample(input, 1., 0, 0)
    104109    fvec_write_sample(input, 1., channels-1, 0)
    105     aubio_mfft_do(self.o, input, fftgrain)
     110    aubio_fft_do(self.o, input, fftgrain)
    106111    # check the norm
    107112    for index in range(buf_size/2+1):
     
    119124    del input
    120125
    121   def test_aubio_mfft_rdo_impulse(self):
    122     """ test aubio_mfft_rdo on impulse """
     126  def test_rdo_impulse(self):
     127    """ test aubio_fft_rdo on impulse """
    123128    fftgrain  = new_cvec(buf_size, channels)
    124129    for channel in range(channels):
    125130      cvec_write_norm(fftgrain, 1., channel, 0)
    126131    output    = new_fvec(buf_size, channels)
    127     aubio_mfft_rdo(self.o, fftgrain, output)
     132    aubio_fft_rdo(self.o, fftgrain, output)
    128133    for index in range(buf_size/2+1):
    129134      for channel in range(channels):
    130         self.assertAlmostEqual(fvec_read_sample(output, channel, index), 1./buf_size, precision)
     135        self.assertCloseEnough(fvec_read_sample(output, channel, index), 1./buf_size)
    131136    del fftgrain
    132137    del output
    133138
    134   def test_aubio_mfft_do_back_and_forth(self):
    135     """ test aubio_mfft_rdo on a constant """
     139  def test_do_back_and_forth(self):
     140    """ test aubio_fft_rdo on a constant """
    136141    input    = new_fvec(buf_size, channels)
    137142    output   = new_fvec(buf_size, channels)
     
    140145      for channel in range(channels):
    141146        fvec_write_sample(input, 0.67, channel, index)
    142     aubio_mfft_do(self.o, input, fftgrain)
    143     aubio_mfft_rdo(self.o, fftgrain, output)
     147    aubio_fft_do(self.o, input, fftgrain)
     148    aubio_fft_rdo(self.o, fftgrain, output)
    144149    for index in range(buf_size/2+1):
    145150      for channel in range(channels):
    146         self.assertAlmostEqual(fvec_read_sample(output, channel, index), 0.67, precision)
     151        self.assertCloseEnough(0.67, fvec_read_sample(output, channel, index))
    147152    del fftgrain
    148153    del output
  • tests/python/phasevoc.py

    ref7df76 rf218f29  
    99precision = 6
    1010
    11 class aubio_phasevoc_test(unittest.TestCase):
     11class phasevoc_unit(unittest.TestCase):
    1212
    1313  def setUp(self):
Note: See TracChangeset for help on using the changeset viewer.