Changeset 81b3910 for src


Ignore:
Timestamp:
Oct 1, 2017, 12:50:15 PM (2 years ago)
Author:
Paul Brossier <piem@piem.org>
Branches:
feature/autosink, feature/constantq, feature/pitchshift, feature/pydocstrings, feature/timestretch, master
Children:
a6b5bf1
Parents:
16c12a1 (diff), faeec7c (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 branch 'intel_ipp_pull' of https://github.com/emuell/aubio into emuell-intel_ipp_pull

Location:
src
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • src/aubio_priv.h

    r16c12a1 r81b3910  
    9494#define aubio_vDSP_minvi      vDSP_minvi
    9595#define aubio_vDSP_dotpr      vDSP_dotpr
     96#define aubio_vDSP_vclr       vDSP_vclr
    9697#else /* HAVE_AUBIO_DOUBLE */
    9798#define aubio_vDSP_mmov       vDSP_mmovD
     
    105106#define aubio_vDSP_minvi      vDSP_minviD
    106107#define aubio_vDSP_dotpr      vDSP_dotprD
     108#define aubio_vDSP_vclr       vDSP_vclrD
    107109#endif /* HAVE_AUBIO_DOUBLE */
    108110#endif /* HAVE_ACCELERATE */
  • src/cvec.c

    r16c12a1 r81b3910  
    2121#include "aubio_priv.h"
    2222#include "cvec.h"
     23
     24#if defined HAVE_INTEL_IPP
     25#include <ippcore.h>
     26#include <ippvm.h>
     27#include <ipps.h>
     28#endif
    2329
    2430cvec_t * new_cvec(uint_t length) {
     
    8692    return;
    8793  }
    88 #ifdef HAVE_MEMCPY_HACKS
     94#if defined(HAVE_INTEL_IPP)
     95  #if HAVE_AUBIO_DOUBLE
     96    ippsCopy_64f(s->phas, t->phas, (int)s->length);
     97    ippsCopy_64f(s->norm, t->norm, (int)s->length);
     98  #else
     99    ippsCopy_32f(s->phas, t->phas, (int)s->length);
     100    ippsCopy_32f(s->norm, t->norm, (int)s->length);
     101  #endif
     102#elif defined(HAVE_MEMCPY_HACKS)
    89103  memcpy(t->norm, s->norm, t->length * sizeof(smpl_t));
    90104  memcpy(t->phas, s->phas, t->length * sizeof(smpl_t));
    91 #else /* HAVE_MEMCPY_HACKS */
     105#else
    92106  uint_t j;
    93107  for (j=0; j< t->length; j++) {
     
    95109    t->phas[j] = s->phas[j];
    96110  }
    97 #endif /* HAVE_MEMCPY_HACKS */
    98 }
    99 
    100 void cvec_norm_set_all (cvec_t *s, smpl_t val) {
     111#endif
     112}
     113
     114void cvec_norm_set_all(cvec_t *s, smpl_t val) {
     115#if defined(HAVE_INTEL_IPP)
     116  #if HAVE_AUBIO_DOUBLE
     117    ippsSet_64f(val, s->norm, (int)s->length);
     118  #else
     119    ippsSet_32f(val, s->norm, (int)s->length);
     120  #endif
     121#else
    101122  uint_t j;
    102123  for (j=0; j< s->length; j++) {
    103124    s->norm[j] = val;
    104125  }
     126#endif
    105127}
    106128
    107129void cvec_norm_zeros(cvec_t *s) {
    108 #ifdef HAVE_MEMCPY_HACKS
     130#if defined(HAVE_INTEL_IPP)
     131  #if HAVE_AUBIO_DOUBLE
     132    ippsZero_64f(s->norm, (int)s->length);
     133  #else
     134    ippsZero_32f(s->norm, (int)s->length);
     135  #endif
     136#elif defined(HAVE_MEMCPY_HACKS)
    109137  memset(s->norm, 0, s->length * sizeof(smpl_t));
    110 #else /* HAVE_MEMCPY_HACKS */
     138#else
    111139  cvec_norm_set_all (s, 0.);
    112 #endif /* HAVE_MEMCPY_HACKS */
     140#endif
    113141}
    114142
     
    118146
    119147void cvec_phas_set_all (cvec_t *s, smpl_t val) {
     148#if defined(HAVE_INTEL_IPP)
     149  #if HAVE_AUBIO_DOUBLE
     150    ippsSet_64f(val, s->phas, (int)s->length);
     151  #else
     152    ippsSet_32f(val, s->phas, (int)s->length);
     153  #endif
     154#else
    120155  uint_t j;
    121156  for (j=0; j< s->length; j++) {
    122157    s->phas[j] = val;
    123158  }
     159#endif
    124160}
    125161
    126162void cvec_phas_zeros(cvec_t *s) {
    127 #ifdef HAVE_MEMCPY_HACKS
     163#if defined(HAVE_INTEL_IPP)
     164  #if HAVE_AUBIO_DOUBLE
     165    ippsZero_64f(s->phas, (int)s->length);
     166  #else
     167    ippsZero_32f(s->phas, (int)s->length);
     168  #endif
     169#elif defined(HAVE_MEMCPY_HACKS)
    128170  memset(s->phas, 0, s->length * sizeof(smpl_t));
    129171#else
     
    142184
    143185void cvec_logmag(cvec_t *s, smpl_t lambda) {
    144   uint_t j;
    145   for (j=0; j< s->length; j++) {
    146     s->norm[j] = LOG(lambda * s->norm[j] + 1);
    147   }
    148 }
     186  #if defined(HAVE_INTEL_IPP)
     187    #if HAVE_AUBIO_DOUBLE
     188      ippsMulC_64f(s->norm, lambda, s->norm, (int)s->length);
     189      ippsAddC_64f(s->norm, 1.0, s->norm, (int)s->length);
     190      ippsLn_64f_A26(s->norm, s->norm, (int)s->length);
     191    #else
     192      ippsMulC_32f(s->norm, lambda, s->norm, (int)s->length);
     193      ippsAddC_32f(s->norm, 1.0, s->norm, (int)s->length);
     194      ippsLn_32f_A21(s->norm, s->norm, (int)s->length);
     195    #endif
     196  #else
     197    uint_t j;
     198    for (j=0; j< s->length; j++) {
     199      s->norm[j] = LOG(lambda * s->norm[j] + 1);
     200    }
     201  #endif
     202}
  • src/fvec.c

    r16c12a1 r81b3910  
    2121#include "aubio_priv.h"
    2222#include "fvec.h"
     23
     24#if defined HAVE_INTEL_IPP
     25#include <ippcore.h>
     26#include <ippvm.h>
     27#include <ipps.h>
     28#endif
    2329
    2430fvec_t * new_fvec(uint_t length) {
     
    6167
    6268void fvec_set_all (fvec_t *s, smpl_t val) {
    63 #if !defined(HAVE_ACCELERATE) && !defined(HAVE_ATLAS)
    64   uint_t j;
    65   for (j=0; j< s->length; j++) {
    66     s->data[j] = val;
    67   }
     69#if defined(HAVE_INTEL_IPP)
     70  #if HAVE_AUBIO_DOUBLE
     71    ippsSet_64f(val, s->data, (int)s->length);
     72  #else
     73    ippsSet_32f(val, s->data, (int)s->length);
     74  #endif
    6875#elif defined(HAVE_ATLAS)
    6976  aubio_catlas_set(s->length, val, s->data, 1);
    7077#elif defined(HAVE_ACCELERATE)
    7178  aubio_vDSP_vfill(&val, s->data, 1, s->length);
     79#else
     80  uint_t j;
     81  for ( j = 0; j< s->length; j++ )
     82  {
     83    s->data[j] = val;
     84  }
    7285#endif
    7386}
    7487
    7588void fvec_zeros(fvec_t *s) {
    76 #if !defined(HAVE_MEMCPY_HACKS) && !defined(HAVE_ACCELERATE)
    77   fvec_set_all (s, 0.);
    78 #else
    79 #if defined(HAVE_MEMCPY_HACKS)
     89#if defined(HAVE_INTEL_IPP)
     90  #if HAVE_AUBIO_DOUBLE
     91    ippsZero_64f(s->data, (int)s->length);
     92  #else
     93    ippsZero_32f(s->data, (int)s->length);
     94  #endif
     95#elif defined(HAVE_ACCELERATE)
     96  aubio_vDSP_vclr(s->data, 1, s->length);
     97#elif defined(HAVE_MEMCPY_HACKS)
    8098  memset(s->data, 0, s->length * sizeof(smpl_t));
    8199#else
    82   aubio_vDSP_vclr(s->data, 1, s->length);
    83 #endif
     100  fvec_set_all(s, 0.);
    84101#endif
    85102}
     
    97114
    98115void fvec_weight(fvec_t *s, const fvec_t *weight) {
    99 #ifndef HAVE_ACCELERATE
     116  uint_t length = MIN(s->length, weight->length);
     117#if defined(HAVE_INTEL_IPP)
     118  #if HAVE_AUBIO_DOUBLE
     119    ippsMul_64f(s->data, weight->data, s->data, (int)length);
     120  #else
     121    ippsMul_32f(s->data, weight->data, s->data, (int)length);
     122  #endif
     123#elif defined(HAVE_ACCELERATE)
     124  aubio_vDSP_vmul( s->data, 1, weight->data, 1, s->data, 1, length );
     125#else
    100126  uint_t j;
    101   uint_t length = MIN(s->length, weight->length);
    102   for (j=0; j< length; j++) {
     127  for (j = 0; j < length; j++) {
    103128    s->data[j] *= weight->data[j];
    104129  }
    105 #else
    106   aubio_vDSP_vmul(s->data, 1, weight->data, 1, s->data, 1, s->length);
    107130#endif /* HAVE_ACCELERATE */
    108131}
    109132
    110133void fvec_weighted_copy(const fvec_t *in, const fvec_t *weight, fvec_t *out) {
    111 #ifndef HAVE_ACCELERATE
     134  uint_t length = MIN(in->length, MIN(out->length, weight->length));
     135#if defined(HAVE_INTEL_IPP)
     136  #if HAVE_AUBIO_DOUBLE
     137    ippsMul_64f(in->data, weight->data, out->data, (int)length);
     138  #else
     139    ippsMul_32f(in->data, weight->data, out->data, (int)length);
     140  #endif
     141#elif defined(HAVE_ACCELERATE)
     142  aubio_vDSP_vmul(in->data, 1, weight->data, 1, out->data, 1, length);
     143#else
    112144  uint_t j;
    113   uint_t length = MIN(out->length, weight->length);
    114   for (j=0; j< length; j++) {
     145  for (j = 0; j < length; j++) {
    115146    out->data[j] = in->data[j] * weight->data[j];
    116147  }
    117 #else
    118   aubio_vDSP_vmul(in->data, 1, weight->data, 1, out->data, 1, out->length);
    119 #endif /* HAVE_ACCELERATE */
     148#endif
    120149}
    121150
     
    126155    return;
    127156  }
    128 #ifdef HAVE_NOOPT
    129   uint_t j;
    130   for (j=0; j< t->length; j++) {
    131     t->data[j] = s->data[j];
    132   }
    133 #elif defined(HAVE_MEMCPY_HACKS)
    134   memcpy(t->data, s->data, t->length * sizeof(smpl_t));
     157#if defined(HAVE_INTEL_IPP)
     158  #if HAVE_AUBIO_DOUBLE
     159    ippsCopy_64f(s->data, t->data, (int)s->length);
     160  #else
     161    ippsCopy_32f(s->data, t->data, (int)s->length);
     162  #endif
    135163#elif defined(HAVE_ATLAS)
    136164  aubio_cblas_copy(s->length, s->data, 1, t->data, 1);
    137165#elif defined(HAVE_ACCELERATE)
    138166  aubio_vDSP_mmov(s->data, t->data, 1, s->length, 1, 1);
     167#elif defined(HAVE_MEMCPY_HACKS)
     168  memcpy(t->data, s->data, t->length * sizeof(smpl_t));
     169#else
     170  uint_t j;
     171  for (j = 0; j < t->length; j++) {
     172    t->data[j] = s->data[j];
     173  }
    139174#endif
    140175}
  • src/mathutils.c

    r16c12a1 r81b3910  
    2525#include "mathutils.h"
    2626#include "musicutils.h"
     27
     28#if defined HAVE_INTEL_IPP
     29#include <ippcore.h>
     30#include <ippvm.h>
     31#include <ipps.h>
     32#endif
    2733
    2834/** Window types */
     
    160166{
    161167  smpl_t tmp = 0.0;
    162 #ifndef HAVE_ACCELERATE
     168#if defined(HAVE_INTEL_IPP)
     169  #if HAVE_AUBIO_DOUBLE
     170    ippsMean_64f(s->data, (int)s->length, &tmp);
     171  #else
     172    ippsMean_32f(s->data, (int)s->length, &tmp, ippAlgHintFast);
     173  #endif
     174    return tmp;
     175#elif defined(HAVE_ACCELERATE)
     176  aubio_vDSP_meanv(s->data, 1, &tmp, s->length);
     177  return tmp;
     178#else
    163179  uint_t j;
    164180  for (j = 0; j < s->length; j++) {
    165181    tmp += s->data[j];
    166182  }
    167   return tmp / (smpl_t) (s->length);
    168 #else
    169   aubio_vDSP_meanv(s->data, 1, &tmp, s->length);
    170   return tmp;
    171 #endif /* HAVE_ACCELERATE */
     183  return tmp / (smpl_t)(s->length);
     184#endif
    172185}
    173186
     
    176189{
    177190  smpl_t tmp = 0.0;
    178 #ifndef HAVE_ACCELERATE
     191#if defined(HAVE_INTEL_IPP)
     192  #if HAVE_AUBIO_DOUBLE
     193    ippsSum_64f(s->data, (int)s->length, &tmp);
     194  #else
     195    ippsSum_32f(s->data, (int)s->length, &tmp, ippAlgHintFast);
     196  #endif
     197#elif defined(HAVE_ACCELERATE)
     198  aubio_vDSP_sve(s->data, 1, &tmp, s->length);
     199#else
    179200  uint_t j;
    180201  for (j = 0; j < s->length; j++) {
    181202    tmp += s->data[j];
    182203  }
    183 #else
    184   aubio_vDSP_sve(s->data, 1, &tmp, s->length);
    185 #endif /* HAVE_ACCELERATE */
     204#endif
    186205  return tmp;
    187206}
     
    190209fvec_max (fvec_t * s)
    191210{
    192 #ifndef HAVE_ACCELERATE
    193   uint_t j;
    194   smpl_t tmp = 0.0;
    195   for (j = 0; j < s->length; j++) {
     211#if defined(HAVE_INTEL_IPP)
     212  smpl_t tmp = 0.;
     213  #if HAVE_AUBIO_DOUBLE
     214    ippsMax_64f( s->data, (int)s->length, &tmp);
     215  #else
     216    ippsMax_32f( s->data, (int)s->length, &tmp);
     217#endif
     218#elif defined(HAVE_ACCELERATE)
     219  smpl_t tmp = 0.;
     220  aubio_vDSP_maxv( s->data, 1, &tmp, s->length );
     221#else
     222  uint_t j;
     223  smpl_t tmp = s->data[0];
     224  for (j = 1; j < s->length; j++) {
    196225    tmp = (tmp > s->data[j]) ? tmp : s->data[j];
    197226  }
    198 #else
     227#endif
     228  return tmp;
     229}
     230
     231smpl_t
     232fvec_min (fvec_t * s)
     233{
     234#if defined(HAVE_INTEL_IPP)
    199235  smpl_t tmp = 0.;
    200   aubio_vDSP_maxv(s->data, 1, &tmp, s->length);
    201 #endif
    202   return tmp;
    203 }
    204 
    205 smpl_t
    206 fvec_min (fvec_t * s)
    207 {
    208 #ifndef HAVE_ACCELERATE
    209   uint_t j;
    210   smpl_t tmp = s->data[0];
    211   for (j = 0; j < s->length; j++) {
    212     tmp = (tmp < s->data[j]) ? tmp : s->data[j];
    213   }
    214 #else
     236  #if HAVE_AUBIO_DOUBLE
     237    ippsMin_64f(s->data, (int)s->length, &tmp);
     238  #else
     239    ippsMin_32f(s->data, (int)s->length, &tmp);
     240#endif
     241#elif defined(HAVE_ACCELERATE)
    215242  smpl_t tmp = 0.;
    216243  aubio_vDSP_minv(s->data, 1, &tmp, s->length);
     244#else
     245  uint_t j;
     246  smpl_t tmp = s->data[0];
     247  for (j = 1; j < s->length; j++) {
     248    tmp = (tmp < s->data[j]) ? tmp : s->data[j];
     249  }
    217250#endif
    218251  return tmp;
     
    575608}
    576609
     610uint_t
     611aubio_power_of_two_order (uint_t a)
     612{
     613  int order = 0;
     614  int temp = aubio_next_power_of_two(a);
     615  while (temp >>= 1) {
     616    ++order;
     617  }
     618  return order;
     619}
     620
    577621smpl_t
    578622aubio_db_spl (const fvec_t * o)
     
    639683
    640684void
     685aubio_init (void)
     686{
     687/* initialize intel IPP */
     688#ifdef HAVE_INTEL_IPP
     689  IppStatus status = ippInit();
     690  if (status != ippStsNoErr) {
     691    fprintf (stderr, "Error: failed to initialize Intel IPP - status %d\n", status);
     692  }
     693#endif
     694}
     695
     696void
    641697aubio_cleanup (void)
    642698{
  • src/mathutils.h

    r16c12a1 r81b3910  
    313313uint_t aubio_next_power_of_two(uint_t a);
    314314
     315/** return the log2 factor of the given power of 2 value a */
     316uint_t aubio_power_of_two_order(uint_t a);
     317
    315318/** compute normalised autocorrelation function
    316319
  • src/musicutils.h

    r16c12a1 r81b3910  
    9393smpl_t aubio_miditofreq (smpl_t midi);
    9494
     95/** initialize global status at beginning of program
     96
     97  This function should be used before doing anything else in aubio.
     98  So far it is only used to initialize the Intel IPP library, when it's used.
     99*/
     100void aubio_init (void);
     101
    95102/** clean up cached memory at the end of program
    96103
  • src/spectral/fft.c

    r16c12a1 r81b3910  
    7878pthread_mutex_t aubio_fftw_mutex = PTHREAD_MUTEX_INITIALIZER;
    7979
    80 #else
    81 #ifdef HAVE_ACCELERATE        // using ACCELERATE
     80#elif defined HAVE_ACCELERATE        // using ACCELERATE
    8281// https://developer.apple.com/library/mac/#documentation/Accelerate/Reference/vDSPRef/Reference/reference.html
    8382#include <Accelerate/Accelerate.h>
     
    113112#endif /* HAVE_AUBIO_DOUBLE */
    114113
    115 #else                         // using OOURA
     114#elif defined HAVE_INTEL_IPP // using INTEL IPP
     115
     116#include <ippcore.h>
     117#include <ippvm.h>
     118#include <ipps.h>
     119
     120#else // using OOURA
    116121// let's use ooura instead
    117122extern void aubio_ooura_rdft(int, int, smpl_t *, int *, smpl_t *);
    118123
    119 #endif /* HAVE_ACCELERATE */
    120 #endif /* HAVE_FFTW3 */
     124#endif
    121125
    122126struct _aubio_fft_t {
    123127  uint_t winsize;
    124128  uint_t fft_size;
     129
    125130#ifdef HAVE_FFTW3             // using FFTW3
    126131  real_t *in, *out;
    127132  fftw_plan pfw, pbw;
    128   fft_data_t * specdata;      /* complex spectral data */
    129 #else
    130 #ifdef HAVE_ACCELERATE        // using ACCELERATE
     133  fft_data_t * specdata; /* complex spectral data */
     134
     135#elif defined HAVE_ACCELERATE  // using ACCELERATE
    131136  int log2fftsize;
    132137  aubio_FFTSetup fftSetup;
    133138  aubio_DSPSplitComplex spec;
    134139  smpl_t *in, *out;
     140 
     141#elif defined HAVE_INTEL_IPP  // using Intel IPP
     142  // mark FFT impl as Intel IPP
     143  #define INTEL_IPP_FFT 1
     144  smpl_t *in, *out;
     145  Ipp8u* memSpec;
     146  Ipp8u* memInit;
     147  Ipp8u* memBuffer;
     148  #if HAVE_AUBIO_DOUBLE
     149    struct FFTSpec_R_64f* fftSpec;
     150    Ipp64fc* complexOut;
     151  #else
     152    struct FFTSpec_R_32f* fftSpec;
     153    Ipp32fc* complexOut;
     154  #endif
    135155#else                         // using OOURA
    136156  smpl_t *in, *out;
    137157  smpl_t *w;
    138158  int *ip;
    139 #endif /* HAVE_ACCELERATE */
    140 #endif /* HAVE_FFTW3 */
     159#endif /* using OOURA */
     160
    141161  fvec_t * compspec;
    142162};
     
    148168    goto beach;
    149169  }
     170
    150171#ifdef HAVE_FFTW3
    151172  uint_t i;
     
    176197    s->specdata[i] = 0.;
    177198  }
    178 #else
    179 #ifdef HAVE_ACCELERATE        // using ACCELERATE
     199
     200#elif defined HAVE_ACCELERATE  // using ACCELERATE
    180201  s->winsize = winsize;
    181202  s->fft_size = winsize;
    182203  s->compspec = new_fvec(winsize);
    183   s->log2fftsize = (uint_t)log2f(s->fft_size);
     204  s->log2fftsize = aubio_power_of_two_order(s->fft_size);
    184205  s->in = AUBIO_ARRAY(smpl_t, s->fft_size);
    185206  s->out = AUBIO_ARRAY(smpl_t, s->fft_size);
     
    187208  s->spec.imagp = AUBIO_ARRAY(smpl_t, s->fft_size/2);
    188209  s->fftSetup = aubio_vDSP_create_fftsetup(s->log2fftsize, FFT_RADIX2);
     210
     211#elif defined HAVE_INTEL_IPP  // using Intel IPP
     212  const IppHintAlgorithm qualityHint = ippAlgHintAccurate; // OR ippAlgHintFast;
     213  const int flags = IPP_FFT_NODIV_BY_ANY; // we're scaling manually afterwards
     214  int order = aubio_power_of_two_order(winsize);
     215  int sizeSpec, sizeInit, sizeBuffer;
     216  IppStatus status;
     217
     218  if (winsize <= 4 || aubio_is_power_of_two(winsize) != 1)
     219  {
     220    AUBIO_ERR("intel IPP fft: can only create with sizes > 4 and power of two, requested %d,"
     221      " try recompiling aubio with --enable-fftw3\n", winsize);
     222    goto beach;
     223  }
     224
     225#if HAVE_AUBIO_DOUBLE
     226  status = ippsFFTGetSize_R_64f(order, flags, qualityHint,
     227      &sizeSpec, &sizeInit, &sizeBuffer);
     228#else
     229  status = ippsFFTGetSize_R_32f(order, flags, qualityHint,
     230    &sizeSpec, &sizeInit, &sizeBuffer);
     231#endif
     232  if (status != ippStsNoErr) {
     233    AUBIO_ERR("fft: failed to initialize fft. IPP error: %d\n", status);
     234    goto beach;
     235  }
     236  s->fft_size = s->winsize = winsize;
     237  s->compspec = new_fvec(winsize);
     238  s->in = AUBIO_ARRAY(smpl_t, s->winsize);
     239  s->out = AUBIO_ARRAY(smpl_t, s->winsize);
     240  s->memSpec = ippsMalloc_8u(sizeSpec);
     241  s->memBuffer = ippsMalloc_8u(sizeBuffer);
     242  if (sizeInit > 0 ) {
     243    s->memInit = ippsMalloc_8u(sizeInit);
     244  }
     245#if HAVE_AUBIO_DOUBLE
     246  s->complexOut = ippsMalloc_64fc(s->fft_size / 2 + 1);
     247  status = ippsFFTInit_R_64f(
     248    &s->fftSpec, order, flags, qualityHint, s->memSpec, s->memInit);
     249#else
     250  s->complexOut = ippsMalloc_32fc(s->fft_size / 2 + 1);
     251  status = ippsFFTInit_R_32f(
     252    &s->fftSpec, order, flags, qualityHint, s->memSpec, s->memInit);
     253#endif
     254  if (status != ippStsNoErr) {
     255    AUBIO_ERR("fft: failed to initialize. IPP error: %d\n", status);
     256    goto beach;
     257  }
     258
    189259#else                         // using OOURA
    190260  if (aubio_is_power_of_two(winsize) != 1) {
     
    201271  s->w     = AUBIO_ARRAY(smpl_t, s->fft_size);
    202272  s->ip[0] = 0;
    203 #endif /* HAVE_ACCELERATE */
    204 #endif /* HAVE_FFTW3 */
     273#endif /* using OOURA */
     274
    205275  return s;
     276
    206277beach:
    207278  AUBIO_FREE(s);
     
    211282void del_aubio_fft(aubio_fft_t * s) {
    212283  /* destroy data */
    213   del_fvec(s->compspec);
    214284#ifdef HAVE_FFTW3             // using FFTW3
    215285  pthread_mutex_lock(&aubio_fftw_mutex);
     
    218288  fftw_free(s->specdata);
    219289  pthread_mutex_unlock(&aubio_fftw_mutex);
    220 #else /* HAVE_FFTW3 */
    221 #ifdef HAVE_ACCELERATE        // using ACCELERATE
     290
     291#elif defined HAVE_ACCELERATE // using ACCELERATE
    222292  AUBIO_FREE(s->spec.realp);
    223293  AUBIO_FREE(s->spec.imagp);
    224294  aubio_vDSP_destroy_fftsetup(s->fftSetup);
     295
     296#elif defined HAVE_INTEL_IPP  // using Intel IPP
     297  ippFree(s->memSpec);
     298  ippFree(s->memInit);
     299  ippFree(s->memBuffer);
     300  ippFree(s->complexOut);
     301
    225302#else                         // using OOURA
    226303  AUBIO_FREE(s->w);
    227304  AUBIO_FREE(s->ip);
    228 #endif /* HAVE_ACCELERATE */
    229 #endif /* HAVE_FFTW3 */
     305#endif
     306
     307  del_fvec(s->compspec);
     308  AUBIO_FREE(s->in);
    230309  AUBIO_FREE(s->out);
    231   AUBIO_FREE(s->in);
    232310  AUBIO_FREE(s);
    233311}
     
    235313void aubio_fft_do(aubio_fft_t * s, const fvec_t * input, cvec_t * spectrum) {
    236314  aubio_fft_do_complex(s, input, s->compspec);
    237   aubio_fft_get_spectrum(s->compspec, spectrum);
     315  aubio_fft_get_spectrum(s, s->compspec, spectrum);
    238316}
    239317
    240318void aubio_fft_rdo(aubio_fft_t * s, const cvec_t * spectrum, fvec_t * output) {
    241   aubio_fft_get_realimag(spectrum, s->compspec);
     319  aubio_fft_get_realimag(s, spectrum, s->compspec);
    242320  aubio_fft_rdo_complex(s, s->compspec, output);
    243321}
     
    252330  memcpy(s->in, input->data, s->winsize * sizeof(smpl_t));
    253331#endif /* HAVE_MEMCPY_HACKS */
     332
    254333#ifdef HAVE_FFTW3             // using FFTW3
    255334  fftw_execute(s->pfw);
     
    266345  }
    267346#endif /* HAVE_COMPLEX_H */
    268 #else /* HAVE_FFTW3 */
    269 #ifdef HAVE_ACCELERATE        // using ACCELERATE
     347
     348#elif defined HAVE_ACCELERATE // using ACCELERATE
    270349  // convert real data to even/odd format used in vDSP
    271350  aubio_vDSP_ctoz((aubio_DSPComplex*)s->in, 2, &s->spec, 1, s->fft_size/2);
     
    282361  smpl_t scale = 1./2.;
    283362  aubio_vDSP_vsmul(compspec->data, 1, &scale, compspec->data, 1, s->fft_size);
     363
     364#elif defined HAVE_INTEL_IPP  // using Intel IPP
     365
     366  // apply fft
     367#if HAVE_AUBIO_DOUBLE
     368  ippsFFTFwd_RToCCS_64f(s->in, (Ipp64f*)s->complexOut, s->fftSpec, s->memBuffer);
     369#else
     370  ippsFFTFwd_RToCCS_32f(s->in, (Ipp32f*)s->complexOut, s->fftSpec, s->memBuffer);
     371#endif
     372  // convert complex buffer to [ r0, r1, ..., rN, iN-1, .., i2, i1]
     373  compspec->data[0] = s->complexOut[0].re;
     374  compspec->data[s->fft_size / 2] = s->complexOut[s->fft_size / 2].re;
     375  for (i = 1; i < s->fft_size / 2; i++) {
     376    compspec->data[i] = s->complexOut[i].re;
     377    compspec->data[s->fft_size - i] = s->complexOut[i].im;
     378  }
     379  // apply scaling
     380#if HAVE_AUBIO_DOUBLE
     381  ippsMulC_64f(compspec->data, 1.0 / 2.0, compspec->data, s->fft_size);
     382#else
     383  ippsMulC_32f(compspec->data, 1.0 / 2.0, compspec->data, s->fft_size);
     384#endif
     385
    284386#else                         // using OOURA
    285387  aubio_ooura_rdft(s->winsize, 1, s->in, s->ip, s->w);
     
    290392    compspec->data[s->winsize - i] = - s->in[2 * i + 1];
    291393  }
    292 #endif /* HAVE_ACCELERATE */
    293 #endif /* HAVE_FFTW3 */
     394#endif /* using OOURA */
    294395}
    295396
     
    314415    output->data[i] = s->out[i]*renorm;
    315416  }
    316 #else /* HAVE_FFTW3 */
    317 #ifdef HAVE_ACCELERATE        // using ACCELERATE
     417
     418#elif defined HAVE_ACCELERATE // using ACCELERATE
    318419  // convert from real imag  [ r0, r1, ..., rN, iN-1, .., i2, i1]
    319420  // to vDSP packed format   [ r0, rN, r1, i1, ..., rN-1, iN-1 ]
     
    333434  smpl_t scale = 1.0 / s->winsize;
    334435  aubio_vDSP_vsmul(output->data, 1, &scale, output->data, 1, s->fft_size);
     436
     437#elif defined HAVE_INTEL_IPP  // using Intel IPP
     438
     439  // convert from real imag  [ r0, 0, ..., rN, iN-1, .., i2, i1, iN-1] to complex format
     440  s->complexOut[0].re = compspec->data[0];
     441  s->complexOut[0].im = 0;
     442  s->complexOut[s->fft_size / 2].re = compspec->data[s->fft_size / 2];
     443  s->complexOut[s->fft_size / 2].im = 0.0;
     444  for (i = 1; i < s->fft_size / 2; i++) {
     445    s->complexOut[i].re = compspec->data[i];
     446    s->complexOut[i].im = compspec->data[s->fft_size - i];
     447  }
     448#if HAVE_AUBIO_DOUBLE
     449  // apply fft
     450  ippsFFTInv_CCSToR_64f((const Ipp64f *)s->complexOut, output->data, s->fftSpec, s->memBuffer);
     451  // apply scaling
     452  ippsMulC_64f(output->data, 2.0 / s->winsize, output->data, s->fft_size);
     453#else
     454  // apply fft
     455  ippsFFTInv_CCSToR_32f((const Ipp32f *)s->complexOut, output->data, s->fftSpec, s->memBuffer);
     456  // apply scaling
     457  ippsMulC_32f(output->data, 2.0f / s->winsize, output->data, s->fft_size);
     458#endif /* HAVE_AUBIO_DOUBLE */
     459
    335460#else                         // using OOURA
    336461  smpl_t scale = 2.0 / s->winsize;
     
    345470    output->data[i] = s->out[i] * scale;
    346471  }
    347 #endif /* HAVE_ACCELERATE */
    348 #endif /* HAVE_FFTW3 */
    349 }
    350 
    351 void aubio_fft_get_spectrum(const fvec_t * compspec, cvec_t * spectrum) {
    352   aubio_fft_get_phas(compspec, spectrum);
    353   aubio_fft_get_norm(compspec, spectrum);
    354 }
    355 
    356 void aubio_fft_get_realimag(const cvec_t * spectrum, fvec_t * compspec) {
    357   aubio_fft_get_imag(spectrum, compspec);
    358   aubio_fft_get_real(spectrum, compspec);
    359 }
    360 
    361 void aubio_fft_get_phas(const fvec_t * compspec, cvec_t * spectrum) {
     472#endif
     473}
     474
     475void aubio_fft_get_spectrum(aubio_fft_t *s, const fvec_t * compspec, cvec_t * spectrum) {
     476  aubio_fft_get_phas(s, compspec, spectrum);
     477  aubio_fft_get_norm(s, compspec, spectrum);
     478}
     479
     480void aubio_fft_get_realimag(aubio_fft_t *s, const cvec_t * spectrum, fvec_t * compspec) {
     481  aubio_fft_get_imag(s, spectrum, compspec);
     482  aubio_fft_get_real(s, spectrum, compspec);
     483}
     484
     485void aubio_fft_get_phas(aubio_fft_t *s, const fvec_t * compspec, cvec_t * spectrum) {
     486
     487#ifdef INTEL_IPP_FFT // using Intel IPP FFT
     488  uint_t i;
     489 
     490  // convert from real imag  [ r0, 0, ..., rN, iN-1, .., i2, i1, iN-1] to complex format
     491  s->complexOut[0].re = compspec->data[0];
     492  s->complexOut[0].im = 0;
     493  s->complexOut[s->fft_size / 2].re = compspec->data[s->fft_size / 2];
     494  s->complexOut[s->fft_size / 2].im = 0.0;
     495  for (i = 1; i < spectrum->length - 1; i++) {
     496    s->complexOut[i].re = compspec->data[i];
     497    s->complexOut[i].im = compspec->data[compspec->length - i];
     498  }
     499 
     500#if HAVE_AUBIO_DOUBLE
     501  IppStatus status = ippsPhase_64fc(s->complexOut, spectrum->phas, spectrum->length);
     502#else
     503  IppStatus status = ippsPhase_32fc(s->complexOut, spectrum->phas, spectrum->length);
     504#endif
     505  if (status != ippStsNoErr) {
     506    AUBIO_ERR("fft: failed to extract phase from fft. IPP error: %d\n", status);
     507  }
     508
     509#else                 // NOT using Intel IPP
    362510  uint_t i;
    363511  if (compspec->data[0] < 0) {
     
    375523    spectrum->phas[spectrum->length - 1] = 0.;
    376524  }
    377 }
    378 
    379 void aubio_fft_get_norm(const fvec_t * compspec, cvec_t * spectrum) {
     525#endif
     526}
     527
     528void aubio_fft_get_norm(aubio_fft_t *s, const fvec_t * compspec, cvec_t * spectrum) {
    380529  uint_t i = 0;
    381530  spectrum->norm[0] = ABS(compspec->data[0]);
     
    388537}
    389538
    390 void aubio_fft_get_imag(const cvec_t * spectrum, fvec_t * compspec) {
     539void aubio_fft_get_imag(aubio_fft_t *s, const cvec_t * spectrum, fvec_t * compspec) {
    391540  uint_t i;
    392541  for (i = 1; i < ( compspec->length + 1 ) / 2 /*- 1 + 1*/; i++) {
     
    396545}
    397546
    398 void aubio_fft_get_real(const cvec_t * spectrum, fvec_t * compspec) {
     547void aubio_fft_get_real(aubio_fft_t *s, const cvec_t * spectrum, fvec_t * compspec) {
    399548  uint_t i;
    400549  for (i = 0; i < compspec->length / 2 + 1; i++) {
  • src/spectral/fft.h

    r16c12a1 r81b3910  
    9999
    100100*/
    101 void aubio_fft_get_spectrum(const fvec_t * compspec, cvec_t * spectrum);
     101void aubio_fft_get_spectrum(aubio_fft_t *s, const fvec_t * compspec, cvec_t * spectrum);
    102102/** convert real/imag spectrum to norm/phas spectrum
    103103
     
    106106
    107107*/
    108 void aubio_fft_get_realimag(const cvec_t * spectrum, fvec_t * compspec);
     108void aubio_fft_get_realimag(aubio_fft_t *s, const cvec_t * spectrum, fvec_t * compspec);
    109109
    110110/** compute phas spectrum from real/imag parts
     
    114114
    115115*/
    116 void aubio_fft_get_phas(const fvec_t * compspec, cvec_t * spectrum);
     116void aubio_fft_get_phas(aubio_fft_t *s, const fvec_t * compspec, cvec_t * spectrum);
    117117/** compute imaginary part from the norm/phas cvec
    118118
     
    121121
    122122*/
    123 void aubio_fft_get_imag(const cvec_t * spectrum, fvec_t * compspec);
     123void aubio_fft_get_imag(aubio_fft_t *s, const cvec_t * spectrum, fvec_t * compspec);
    124124
    125125/** compute norm component from real/imag parts
     
    129129
    130130*/
    131 void aubio_fft_get_norm(const fvec_t * compspec, cvec_t * spectrum);
     131void aubio_fft_get_norm(aubio_fft_t *s, const fvec_t * compspec, cvec_t * spectrum);
    132132/** compute real part from norm/phas components
    133133
     
    136136
    137137*/
    138 void aubio_fft_get_real(const cvec_t * spectrum, fvec_t * compspec);
     138void aubio_fft_get_real(aubio_fft_t *s, const cvec_t * spectrum, fvec_t * compspec);
    139139
    140140#ifdef __cplusplus
Note: See TracChangeset for help on using the changeset viewer.