Changeset 633400d for src

src/aubio.h

-                      r5b46bc3
+                      r633400d
   Several examples of C programs are available in the \p examples/ and \p tests/src
+  directories of the source tree. See more examples:
+  @ref spectral/test-fft.c
+  @ref spectral/test-phasevoc.c
+  @ref onset/test-onset.c
+  @ref pitch/test-pitch.c
+  @ref tempo/test-tempo.c
+  @ref test-fvec.c
+  @ref test-cvec.c
+  directories of the source tree.
+  Some examples:
+  - @ref spectral/test-fft.c
+  - @ref spectral/test-phasevoc.c
+  - @ref onset/test-onset.c
+  - @ref pitch/test-pitch.c
+  - @ref tempo/test-tempo.c
+  - @ref test-fvec.c
+  - @ref test-cvec.c
   \subsection unstable_api Unstable API
 …
   Latest versions, further documentation, examples, wiki, and mailing lists can
   be found at http://aubio.org .
+  be found at https://aubio.org .
  */
 …
 #include "temporal/c_weighting.h"
 #include "spectral/fft.h"
+#include "spectral/dct.h"
 #include "spectral/phasevoc.h"
 #include "spectral/filterbank.h"
 …
 #include "spectral/mfcc.h"
 #include "spectral/specdesc.h"
+#include "spectral/awhitening.h"
 #include "spectral/tss.h"
 #include "pitch/pitch.h"
 …
 #include "pitch/pitchyin.h"
 #include "pitch/pitchyinfft.h"
+#include "pitch/pitchyinfast.h"
 #include "pitch/pitchschmitt.h"
 #include "pitch/pitchfcomb.h"

src/aubio_priv.h

-                      r5b46bc3
+                      r633400d
  */
+#ifdef HAVE_CONFIG_H
 #include "config.h"
+#endif
 #ifdef HAVE_STDLIB_H
 …
 #endif
 #ifdef HAVE_ACCELERATE
+#if defined(HAVE_ACCELERATE)
 #define HAVE_ATLAS 1
+#define HAVE_BLAS 1
 #include <Accelerate/Accelerate.h>
 #elif defined(HAVE_ATLAS_CBLAS_H)
+#elif defined(HAVE_BLAS)
+#if defined(HAVE_ATLAS_CBLAS_H)
 #define HAVE_ATLAS 1
 #include <atlas/cblas.h>
+#else
+#undef HAVE_ATLAS
+#elif defined(HAVE_OPENBLAS_CBLAS_H)
+#include <openblas/cblas.h>
+#elif defined(HAVE_CBLAS_H)
+#include <cblas.h>
+#endif
 #endif
 …
 #define aubio_vDSP_mmov       vDSP_mmov
 #define aubio_vDSP_vmul       vDSP_vmul
+#define aubio_vDSP_vsmul      vDSP_vsmul
+#define aubio_vDSP_vsadd      vDSP_vsadd
 #define aubio_vDSP_vfill      vDSP_vfill
 #define aubio_vDSP_meanv      vDSP_meanv
 …
 #define aubio_vDSP_minvi      vDSP_minvi
 #define aubio_vDSP_dotpr      vDSP_dotpr
+#define aubio_vDSP_vclr       vDSP_vclr
 #else /* HAVE_AUBIO_DOUBLE */
 #define aubio_vDSP_mmov       vDSP_mmovD
 #define aubio_vDSP_vmul       vDSP_vmulD
+#define aubio_vDSP_vsmul      vDSP_vsmulD
+#define aubio_vDSP_vsadd      vDSP_vsaddD
 #define aubio_vDSP_vfill      vDSP_vfillD
 #define aubio_vDSP_meanv      vDSP_meanvD
 …
 #define aubio_vDSP_minvi      vDSP_minviD
 #define aubio_vDSP_dotpr      vDSP_dotprD
+#define aubio_vDSP_vclr       vDSP_vclrD
 #endif /* HAVE_AUBIO_DOUBLE */
 #endif /* HAVE_ACCELERATE */
+#if defined(HAVE_BLAS)
+#ifndef HAVE_AUBIO_DOUBLE
 #ifdef HAVE_ATLAS
-#ifndef HAVE_AUBIO_DOUBLE
 #define aubio_catlas_set      catlas_sset
+#endif /* HAVE_ATLAS */
 #define aubio_cblas_copy      cblas_scopy
 #define aubio_cblas_swap      cblas_sswap
 #define aubio_cblas_dot       cblas_sdot
 #else /* HAVE_AUBIO_DOUBLE */
+#ifdef HAVE_ATLAS
 #define aubio_catlas_set      catlas_dset
+#endif /* HAVE_ATLAS */
 #define aubio_cblas_copy      cblas_dcopy
 #define aubio_cblas_swap      cblas_dswap
 #define aubio_cblas_dot       cblas_ddot
 #endif /* HAVE_AUBIO_DOUBLE */
+#endif /* HAVE_ATLAS */
+#if !defined(HAVE_MEMCPY_HACKS) && !defined(HAVE_ACCELERATE) && !defined(HAVE_ATLAS)
+#endif /* HAVE_BLAS */
+#if defined HAVE_INTEL_IPP
+#include <ippcore.h>
+#include <ippvm.h>
+#include <ipps.h>
+#ifndef HAVE_AUBIO_DOUBLE
+#define aubio_ippsSet         ippsSet_32f
+#define aubio_ippsZero        ippsZero_32f
+#define aubio_ippsCopy        ippsCopy_32f
+#define aubio_ippsMul         ippsMul_32f
+#define aubio_ippsMulC        ippsMulC_32f
+#define aubio_ippsAddC        ippsAddC_32f
+#define aubio_ippsLn          ippsLn_32f_A21
+#define aubio_ippsMean(a,b,c) ippsMean_32f(a, b, c, ippAlgHintFast)
+#define aubio_ippsSum(a,b,c)  ippsSum_32f(a, b, c, ippAlgHintFast)
+#define aubio_ippsMax         ippsMax_32f
+#define aubio_ippsMin         ippsMin_32f
+#else /* HAVE_AUBIO_DOUBLE */
+#define aubio_ippsSet         ippsSet_64f
+#define aubio_ippsZero        ippsZero_64f
+#define aubio_ippsCopy        ippsCopy_64f
+#define aubio_ippsMul         ippsMul_64f
+#define aubio_ippsMulC        ippsMulC_64f
+#define aubio_ippsAddC        ippsAddC_64f
+#define aubio_ippsLn          ippsLn_64f_A26
+#define aubio_ippsMean        ippsMean_64f
+#define aubio_ippsSum         ippsSum_64f
+#define aubio_ippsMax         ippsMax_64f
+#define aubio_ippsMin         ippsMin_64f
+#endif /* HAVE_AUBIO_DOUBLE */
+#endif
+#if !defined(HAVE_MEMCPY_HACKS) && !defined(HAVE_ACCELERATE) && !defined(HAVE_ATLAS) && !defined(HAVE_INTEL_IPP)
 #define HAVE_NOOPT 1
-#else
-#undef HAVE_NOOPT
 #endif
 …
 #ifdef HAVE_C99_VARARGS_MACROS
 #define AUBIO_ERR(...)               aubio_log(AUBIO_LOG_ERR, "AUBIO ERROR: " __VA_ARGS__)
+#define AUBIO_INF(...)               aubio_log(AUBIO_LOG_INF, "AUBIO INFO: " __VA_ARGS__)
 #define AUBIO_MSG(...)               aubio_log(AUBIO_LOG_MSG, __VA_ARGS__)
 #define AUBIO_DBG(...)               aubio_log(AUBIO_LOG_DBG, __VA_ARGS__)
 #define AUBIO_WRN(...)               aubio_log(AUBIO_LOG_WRN, "AUBIO WARNING: " __VA_ARGS__)
 #else
+#define AUBIO_ERR(format, args...)   aubio_log(stderr, "AUBIO ERROR: " format , ##args)
+#define AUBIO_MSG(format, args...)   aubio_log(stdout, format , ##args)
+#define AUBIO_DBG(format, args...)   aubio_log(stderr, format , ##args)
+#define AUBIO_WRN(format, args...)   aubio_log(stderr, "AUBIO WARNING: " format, ##args)
+#define AUBIO_ERR(format, args...)   aubio_log(AUBIO_LOG_ERR, "AUBIO ERROR: " format , ##args)
+#define AUBIO_INF(format, args...)   aubio_log(AUBIO_LOG_INF, "AUBIO INFO: " format , ##args)
+#define AUBIO_MSG(format, args...)   aubio_log(AUBIO_LOG_MSG, format , ##args)
+#define AUBIO_DBG(format, args...)   aubio_log(AUBIO_LOG_DBG, format , ##args)
+#define AUBIO_WRN(format, args...)   aubio_log(AUBIO_LOG_WRN, "AUBIO WARNING: " format, ##args)
 #endif
 …
 #define AUBIO_QUIT(_s)               exit(_s)
 #define AUBIO_SPRINTF                sprintf
+#define AUBIO_MAX_SAMPLERATE (192000*8)
+#define AUBIO_MAX_CHANNELS 1024
 /* pi and 2*pi */
 …
 #define FLOOR      floorf
 #define CEIL       ceilf
+#define ATAN       atanf
 #define ATAN2      atan2f
 #else
 …
 #define FLOOR      floor
 #define CEIL       ceil
+#define ATAN       atan
 #define ATAN2      atan2
 #endif

src/cvec.c

-                      r5b46bc3
+                      r633400d
     return;
+  }
+#ifdef HAVE_MEMCPY_HACKS
+#if defined(HAVE_INTEL_IPP)
+  aubio_ippsCopy(s->phas, t->phas, (int)s->length);
+  aubio_ippsCopy(s->norm, t->norm, (int)s->length);
+#elif defined(HAVE_MEMCPY_HACKS)
   memcpy(t->norm, s->norm, t->length * sizeof(smpl_t));
   memcpy(t->phas, s->phas, t->length * sizeof(smpl_t));
 #else /* HAVE_MEMCPY_HACKS */
+#else
   uint_t j;
   for (j=0; j< t->length; j++) {
 …
     t->phas[j] = s->phas[j];
+  }
 #endif /* HAVE_MEMCPY_HACKS */
+#endif
+}
+void cvec_norm_set_all (cvec_t *s, smpl_t val) {
+void cvec_norm_set_all(cvec_t *s, smpl_t val) {
+#if defined(HAVE_INTEL_IPP)
+  aubio_ippsSet(val, s->norm, (int)s->length);
+#else
   uint_t j;
   for (j=0; j< s->length; j++) {
     s->norm[j] = val;
+  }
+#endif
+}
 void cvec_norm_zeros(cvec_t *s) {
+#ifdef HAVE_MEMCPY_HACKS
+#if defined(HAVE_INTEL_IPP)
+  aubio_ippsZero(s->norm, (int)s->length);
+#elif defined(HAVE_MEMCPY_HACKS)
   memset(s->norm, 0, s->length * sizeof(smpl_t));
 #else /* HAVE_MEMCPY_HACKS */
+#else
   cvec_norm_set_all (s, 0.);
 #endif /* HAVE_MEMCPY_HACKS */
+#endif
+}
 …
 void cvec_phas_set_all (cvec_t *s, smpl_t val) {
+#if defined(HAVE_INTEL_IPP)
+  aubio_ippsSet(val, s->phas, (int)s->length);
+#else
   uint_t j;
   for (j=0; j< s->length; j++) {
     s->phas[j] = val;
+  }
+#endif
+}
 void cvec_phas_zeros(cvec_t *s) {
+#ifdef HAVE_MEMCPY_HACKS
+#if defined(HAVE_INTEL_IPP)
+  aubio_ippsZero(s->phas, (int)s->length);
+#elif defined(HAVE_MEMCPY_HACKS)
   memset(s->phas, 0, s->length * sizeof(smpl_t));
 #else
 …
   cvec_phas_zeros(s);
+}
+void cvec_logmag(cvec_t *s, smpl_t lambda) {
+#if defined(HAVE_INTEL_IPP)
+  aubio_ippsMulC(s->norm, lambda, s->norm, (int)s->length);
+  aubio_ippsAddC(s->norm, 1.0, s->norm, (int)s->length);
+  aubio_ippsLn(s->norm, s->norm, (int)s->length);
+#else
+  uint_t j;
+  for (j=0; j< s->length; j++) {
+    s->norm[j] = LOG(lambda * s->norm[j] + 1);
+  }
+#endif
+}

src/cvec.h

-                      r5b46bc3
+                      r633400d
 void cvec_zeros(cvec_t *s);
+/** take logarithmic magnitude
+  \param s input cvec to compress
+  \param lambda value to use for normalisation
+  \f$ S_k = log( \lambda * S_k + 1 ) \f$
+*/
+void cvec_logmag(cvec_t *s, smpl_t lambda);
 #ifdef __cplusplus
+}

src/fmat.c

-                      r5b46bc3
+                      r633400d
   uint_t i,j;
   for (i=0; i< s->height; i++) {
     for (j=0; j< FLOOR(s->length/2); j++) {
+    for (j=0; j< FLOOR((smpl_t)s->length/2); j++) {
       ELEM_SWAP(s->data[i][j], s->data[i][s->length-1-j]);
+    }
 …
   assert(s->length == scale->length);
 #endif
 #if !defined(HAVE_ACCELERATE) && !defined(HAVE_ATLAS)
+#if !defined(HAVE_ACCELERATE) && !defined(HAVE_BLAS)
   uint_t j;
   fvec_zeros(output);
 …
+    }
+  }
 #elif defined(HAVE_ATLAS)
+#elif defined(HAVE_BLAS)
   for (k = 0; k < s->height; k++) {
     output->data[k] = aubio_cblas_dot( s->length, scale->data, 1, s->data[k], 1);

src/fvec.c

-                      r5b46bc3
+                      r633400d
 void fvec_set_all (fvec_t *s, smpl_t val) {
+#if !defined(HAVE_ACCELERATE) && !defined(HAVE_ATLAS)
+  uint_t j;
+  for (j=0; j< s->length; j++) {
+    s->data[j] = val;
+  }
+#if defined(HAVE_INTEL_IPP)
+  aubio_ippsSet(val, s->data, (int)s->length);
 #elif defined(HAVE_ATLAS)
   aubio_catlas_set(s->length, val, s->data, 1);
 #elif defined(HAVE_ACCELERATE)
   aubio_vDSP_vfill(&val, s->data, 1, s->length);
+#else
+  uint_t j;
+  for ( j = 0; j< s->length; j++ )
+  {
+    s->data[j] = val;
+  }
 #endif
+}
 void fvec_zeros(fvec_t *s) {
+#if !defined(HAVE_MEMCPY_HACKS) && !defined(HAVE_ACCELERATE)
+  fvec_set_all (s, 0.);
+#else
+#if defined(HAVE_MEMCPY_HACKS)
+#if defined(HAVE_INTEL_IPP)
+  aubio_ippsZero(s->data, (int)s->length);
+#elif defined(HAVE_ACCELERATE)
+  aubio_vDSP_vclr(s->data, 1, s->length);
+#elif defined(HAVE_MEMCPY_HACKS)
   memset(s->data, 0, s->length * sizeof(smpl_t));
 #else
+  aubio_vDSP_vclr(s->data, 1, s->length);
+#endif
+  fvec_set_all(s, 0.);
 #endif
+}
 …
 void fvec_rev(fvec_t *s) {
   uint_t j;
   for (j=0; j< FLOOR(s->length/2); j++) {
+  for (j=0; j< FLOOR((smpl_t)s->length/2); j++) {
     ELEM_SWAP(s->data[j], s->data[s->length-1-j]);
+  }
 …
 void fvec_weight(fvec_t *s, const fvec_t *weight) {
+#ifndef HAVE_ACCELERATE
+  uint_t length = MIN(s->length, weight->length);
+#if defined(HAVE_INTEL_IPP)
+  aubio_ippsMul(s->data, weight->data, s->data, (int)length);
+#elif defined(HAVE_ACCELERATE)
+  aubio_vDSP_vmul( s->data, 1, weight->data, 1, s->data, 1, length );
+#else
   uint_t j;
+  uint_t length = MIN(s->length, weight->length);
+  for (j=0; j< length; j++) {
+  for (j = 0; j < length; j++) {
     s->data[j] *= weight->data[j];
+  }
-#else
-  aubio_vDSP_vmul(s->data, 1, weight->data, 1, s->data, 1, s->length);
 #endif /* HAVE_ACCELERATE */
+}
 void fvec_weighted_copy(const fvec_t *in, const fvec_t *weight, fvec_t *out) {
+#ifndef HAVE_ACCELERATE
+  uint_t length = MIN(in->length, MIN(out->length, weight->length));
+#if defined(HAVE_INTEL_IPP)
+  aubio_ippsMul(in->data, weight->data, out->data, (int)length);
+#elif defined(HAVE_ACCELERATE)
+  aubio_vDSP_vmul(in->data, 1, weight->data, 1, out->data, 1, length);
+#else
   uint_t j;
+  uint_t length = MIN(out->length, weight->length);
+  for (j=0; j< length; j++) {
+  for (j = 0; j < length; j++) {
     out->data[j] = in->data[j] * weight->data[j];
+  }
+#else
+  aubio_vDSP_vmul(in->data, 1, weight->data, 1, out->data, 1, out->length);
+#endif /* HAVE_ACCELERATE */
+#endif
+}
 …
     return;
+  }
+#ifdef HAVE_NOOPT
+  uint_t j;
+  for (j=0; j< t->length; j++) {
+    t->data[j] = s->data[j];
+  }
+#elif defined(HAVE_MEMCPY_HACKS)
+  memcpy(t->data, s->data, t->length * sizeof(smpl_t));
+#elif defined(HAVE_ATLAS)
+#if defined(HAVE_INTEL_IPP)
+  aubio_ippsCopy(s->data, t->data, (int)s->length);
+#elif defined(HAVE_BLAS)
   aubio_cblas_copy(s->length, s->data, 1, t->data, 1);
 #elif defined(HAVE_ACCELERATE)
   aubio_vDSP_mmov(s->data, t->data, 1, s->length, 1, 1);
+#elif defined(HAVE_MEMCPY_HACKS)
+  memcpy(t->data, s->data, t->length * sizeof(smpl_t));
+#else
+  uint_t j;
+  for (j = 0; j < t->length; j++) {
+    t->data[j] = s->data[j];
+  }
 #endif
+}

src/io/audio_unit.c

-                      r5b46bc3
+                      r633400d
 */
 #include "config.h"
+#include "aubio_priv.h"
 #ifdef HAVE_AUDIO_UNIT
-#include "aubio_priv.h"
 #include "fvec.h"

src/io/sink.c

-                      r5b46bc3
+                      r633400d
 */
-#include "config.h"
 #include "aubio_priv.h"
 #include "fvec.h"
 …
+  }
 #endif /* HAVE_WAVWRITE */
+  AUBIO_ERROR("sink: failed creating %s with samplerate %dHz\n",
+      uri, samplerate);
+#if !defined(HAVE_WAVWRITE) && \
+  !defined(HAVE_SNDFILE) && \
+  !defined(HAVE_SINK_APPLE_AUDIO)
+  AUBIO_ERROR("sink: failed creating '%s' at %dHz (no sink built-in)\n", uri, samplerate);
+#endif
   AUBIO_FREE(s);
   return NULL;

src/io/sink_apple_audio.c

-                      r5b46bc3
+                      r633400d
 */
 #include "config.h"
+#include "aubio_priv.h"
 #ifdef HAVE_SINK_APPLE_AUDIO
-#include "aubio_priv.h"
 #include "fvec.h"
 #include "fmat.h"
 #include "io/sink_apple_audio.h"
+#include "io/ioutils.h"
 // CFURLRef, CFURLCreateWithFileSystemPath, ...
 …
   s->async = false;
   if (uri == NULL) {
+  if ( (uri == NULL) || (strlen(uri) < 1) ) {
     AUBIO_ERROR("sink_apple_audio: Aborted opening null path\n");
     goto beach;
 …
   s->channels = 0;
-  // negative samplerate given, abort
-  if ((sint_t)samplerate < 0) goto beach;
   // zero samplerate given. do not open yet
+  if ((sint_t)samplerate == 0) return s;
+  if ((sint_t)samplerate == 0) {
+    return s;
+  }
+  // invalid samplerate given, abort
+  if (aubio_io_validate_samplerate("sink_apple_audio", s->path, samplerate)) {
+    goto beach;
+  }
   s->samplerate = samplerate;
 …
 uint_t aubio_sink_apple_audio_preset_samplerate(aubio_sink_apple_audio_t *s, uint_t samplerate)
+{
+  if ((sint_t)(samplerate) <= 0) return AUBIO_FAIL;
+  if (aubio_io_validate_samplerate("sink_apple_audio", s->path, samplerate)) {
+    return AUBIO_FAIL;
+  }
   s->samplerate = samplerate;
   // automatically open when both samplerate and channels have been set
 …
 uint_t aubio_sink_apple_audio_preset_channels(aubio_sink_apple_audio_t *s, uint_t channels)
+{
+  if ((sint_t)(channels) <= 0) return AUBIO_FAIL;
+  if (aubio_io_validate_channels("sink_apple_audio", s->path, channels)) {
+    return AUBIO_FAIL;
+  }
   s->channels = channels;
   // automatically open when both samplerate and channels have been set

src/io/sink_sndfile.c

-                      r5b46bc3
+                      r633400d
 #include "config.h"
+#include "aubio_priv.h"
 #ifdef HAVE_SNDFILE
 …
 #include <sndfile.h>
-#include "aubio_priv.h"
 #include "fvec.h"
 #include "fmat.h"
 #include "io/sink_sndfile.h"
+#define MAX_CHANNELS 6
+#include "io/ioutils.h"
 #define MAX_SIZE 4096
 …
   s->channels = 0;
-  // negative samplerate given, abort
-  if ((sint_t)samplerate < 0) goto beach;
   // zero samplerate given. do not open yet
+  if ((sint_t)samplerate == 0) return s;
+  if ((sint_t)samplerate == 0) {
+    return s;
+  }
+  // invalid samplerate given, abort
+  if (aubio_io_validate_samplerate("sink_sndfile", s->path, samplerate)) {
+    goto beach;
+  }
   s->samplerate = samplerate;
 …
 uint_t aubio_sink_sndfile_preset_samplerate(aubio_sink_sndfile_t *s, uint_t samplerate)
+{
+  if ((sint_t)(samplerate) <= 0) return AUBIO_FAIL;
+  if (aubio_io_validate_samplerate("sink_sndfile", s->path, samplerate)) {
+    return AUBIO_FAIL;
+  }
   s->samplerate = samplerate;
   // automatically open when both samplerate and channels have been set
 …
 uint_t aubio_sink_sndfile_preset_channels(aubio_sink_sndfile_t *s, uint_t channels)
+{
+  if ((sint_t)(channels) <= 0) return AUBIO_FAIL;
+  if (aubio_io_validate_channels("sink_sndfile", s->path, channels)) {
+    return AUBIO_FAIL;
+  }
   s->channels = channels;
   // automatically open when both samplerate and channels have been set
 …
   if (s->handle == NULL) {
     /* show libsndfile err msg */
+    AUBIO_ERR("sink_sndfile: Failed opening %s. %s\n", s->path, sf_strerror (NULL));
+    AUBIO_ERR("sink_sndfile: Failed opening \"%s\" with %d channels, %dHz: %s\n",
+        s->path, s->channels, s->samplerate, sf_strerror (NULL));
     return AUBIO_FAIL;
+  }
 …
   s->scratch_size = s->max_size*s->channels;
   /* allocate data for de/interleaving reallocated when needed. */
+  if (s->scratch_size >= MAX_SIZE * MAX_CHANNELS) {
+  if (s->scratch_size >= MAX_SIZE * AUBIO_MAX_CHANNELS) {
+    abort();
     AUBIO_ERR("sink_sndfile: %d x %d exceeds maximum aubio_sink_sndfile buffer size %d\n",
         s->max_size, s->channels, MAX_CHANNELS * MAX_CHANNELS);
+        s->max_size, s->channels, MAX_SIZE * AUBIO_MAX_CHANNELS);
     return AUBIO_FAIL;
+  }

src/io/sink_wavwrite.c

-                      r5b46bc3
+                      r633400d
 #include "config.h"
+#include "aubio_priv.h"
 #ifdef HAVE_WAVWRITE
-#include "aubio_priv.h"
 #include "fvec.h"
 #include "fmat.h"
 #include "io/sink_wavwrite.h"
+#include "io/ioutils.h"
 #include <errno.h>
-#define MAX_CHANNELS 6
 #define MAX_SIZE 4096
 …
   s->channels = 0;
-  // negative samplerate given, abort
-  if ((sint_t)samplerate < 0) goto beach;
   // zero samplerate given. do not open yet
+  if ((sint_t)samplerate == 0) return s;
+  // samplerate way too large, fail
+  if ((sint_t)samplerate > 192000 * 4) goto beach;
+  if ((sint_t)samplerate == 0) {
+    return s;
+  }
+  // invalid samplerate given, abort
+  if (aubio_io_validate_samplerate("sink_wavwrite", s->path, samplerate)) {
+    goto beach;
+  }
   s->samplerate = samplerate;
 …
 uint_t aubio_sink_wavwrite_preset_samplerate(aubio_sink_wavwrite_t *s, uint_t samplerate)
+{
+  if ((sint_t)(samplerate) <= 0) return AUBIO_FAIL;
+  if (aubio_io_validate_samplerate("sink_wavwrite", s->path, samplerate)) {
+    return AUBIO_FAIL;
+  }
   s->samplerate = samplerate;
   // automatically open when both samplerate and channels have been set
 …
 uint_t aubio_sink_wavwrite_preset_channels(aubio_sink_wavwrite_t *s, uint_t channels)
+{
+  if ((sint_t)(channels) <= 0) return AUBIO_FAIL;
+  if (aubio_io_validate_channels("sink_wavwrite", s->path, channels)) {
+    return AUBIO_FAIL;
+  }
   s->channels = channels;
   // automatically open when both samplerate and channels have been set
 …
   s->scratch_size = s->max_size * s->channels;
   /* allocate data for de/interleaving reallocated when needed. */
   if (s->scratch_size >= MAX_SIZE * MAX_CHANNELS) {
+  if (s->scratch_size >= MAX_SIZE * AUBIO_MAX_CHANNELS) {
     AUBIO_ERR("sink_wavwrite: %d x %d exceeds SIZE maximum buffer size %d\n",
         s->max_size, s->channels, MAX_SIZE * MAX_CHANNELS);
+        s->max_size, s->channels, MAX_SIZE * AUBIO_MAX_CHANNELS);
     goto beach;
+  }

src/io/source.c

-                      r5b46bc3
+                      r633400d
 */
-#include "config.h"
 #include "aubio_priv.h"
 #include "fvec.h"
 …
+  }
 #endif /* HAVE_WAVREAD */
+  AUBIO_ERROR("source: failed creating aubio source with %s"
+     " at samplerate %d with hop_size %d\n", uri, samplerate, hop_size);
+#if !defined(HAVE_WAVREAD) && \
+  !defined(HAVE_LIBAV) && \
+  !defined(HAVE_SOURCE_APPLE_AUDIO) && \
+  !defined(HAVE_SNDFILE)
+  AUBIO_ERROR("source: failed creating with %s at %dHz with hop size %d"
+     " (no source built-in)\n", uri, samplerate, hop_size);
+#endif
   AUBIO_FREE(s);
   return NULL;

src/io/source_apple_audio.c

-                      r5b46bc3
+                      r633400d
 */
 #include "config.h"
+#include "aubio_priv.h"
 #ifdef HAVE_SOURCE_APPLE_AUDIO
-#include "aubio_priv.h"
 #include "fvec.h"
 #include "fmat.h"
 …
+{
   OSStatus err = noErr;
   if (!s->audioFile) { return AUBIO_FAIL; }
+  if (!s->audioFile) { return AUBIO_OK; }
   err = ExtAudioFileDispose(s->audioFile);
   s->audioFile = NULL;

src/io/source_avcodec.c

-                      r5b46bc3
+                      r633400d
 */
+#include "config.h"
+#include "aubio_priv.h"
 #ifdef HAVE_LIBAV
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#if defined(HAVE_SWRESAMPLE)
+#include <libswresample/swresample.h>
+#elif defined(HAVE_AVRESAMPLE)
+#include <libavresample/avresample.h>
+#endif
+#include <libavutil/opt.h>
+#include <stdlib.h>
 // determine whether we use libavformat from ffmpeg or from libav
 #define FFMPEG_LIBAVFORMAT (LIBAVFORMAT_VERSION_MICRO > 99 )
 // max_analyze_duration2 was used from ffmpeg libavformat 55.43.100 through 57.2.100
+// max_analyze_duration2 was used from ffmpeg libavformat 55.43.100 -> 57.2.100
 #define FFMPEG_LIBAVFORMAT_MAX_DUR2 FFMPEG_LIBAVFORMAT && ( \
       (LIBAVFORMAT_VERSION_MAJOR == 55 && LIBAVFORMAT_VERSION_MINOR >= 43) \
 …
+      )
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libavresample/avresample.h>
+#include <libavutil/opt.h>
+#include <stdlib.h>
+// backward compatibility with libavcodec55
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(57,0,0)
+#define HAVE_AUBIO_LIBAVCODEC_DEPRECATED 1
+#endif
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(55,28,1)
+#warning "libavcodec < 56 is deprecated"
+#define av_frame_alloc  avcodec_alloc_frame
+#define av_frame_free avcodec_free_frame
+#define av_packet_unref av_free_packet
+#endif
 #include "aubio_priv.h"
 …
 #include "source_avcodec.h"
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(56, 56, 0)
 #define AUBIO_AVCODEC_MAX_BUFFER_SIZE FF_MIN_BUFFER_SIZE
+#else
+#define AUBIO_AVCODEC_MAX_BUFFER_SIZE AV_INPUT_BUFFER_MIN_SIZE
+#endif
 struct _aubio_source_avcodec_t {
 …
   AVCodecContext *avCodecCtx;
   AVFrame *avFrame;
+  AVPacket avPacket;
+#ifdef HAVE_AVRESAMPLE
   AVAudioResampleContext *avr;
+  float *output;
+#elif defined(HAVE_SWRESAMPLE)
+  SwrContext *avr;
+#endif
+  smpl_t *output;
   uint_t read_samples;
   uint_t read_index;
   sint_t selected_stream;
   uint_t eof;
-  uint_t multi;
 };
+// hack to create or re-create the context the first time _do or _do_multi is called
+void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s, uint_t multi);
+void aubio_source_avcodec_readframe(aubio_source_avcodec_t *s, uint_t * read_samples);
+// create or re-create the context when _do or _do_multi is called
+void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s);
+// actually read a frame
+void aubio_source_avcodec_readframe(aubio_source_avcodec_t *s,
+    uint_t * read_samples);
 uint_t aubio_source_avcodec_has_network_url(aubio_source_avcodec_t *s);
 …
+aubio_source_avcodec_t * new_aubio_source_avcodec(const char_t * path, uint_t samplerate, uint_t hop_size) {
+aubio_source_avcodec_t * new_aubio_source_avcodec(const char_t * path,
+    uint_t samplerate, uint_t hop_size) {
   aubio_source_avcodec_t * s = AUBIO_NEW(aubio_source_avcodec_t);
+  AVFormatContext *avFormatCtx = s->avFormatCtx;
+  AVCodecContext *avCodecCtx = s->avCodecCtx;
+  AVFrame *avFrame = s->avFrame;
+  sint_t selected_stream = -1;
+#if FF_API_LAVF_AVCTX
+  AVCodecParameters *codecpar;
+#endif
+  AVCodec *codec;
+  uint_t i;
   int err;
   if (path == NULL) {
 …
+  }
   if ((sint_t)samplerate < 0) {
+    AUBIO_ERR("source_avcodec: Can not open %s with samplerate %d\n", path, samplerate);
+    AUBIO_ERR("source_avcodec: Can not open %s with samplerate %d\n",
+        path, samplerate);
     goto beach;
+  }
   if ((sint_t)hop_size <= 0) {
+    AUBIO_ERR("source_avcodec: Can not open %s with hop_size %d\n", path, hop_size);
+    AUBIO_ERR("source_avcodec: Can not open %s with hop_size %d\n",
+        path, hop_size);
     goto beach;
+  }
 …
   strncpy(s->path, path, strnlen(path, PATH_MAX) + 1);
+#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(58,0,0)
   // register all formats and codecs
   av_register_all();
+#endif
   if (aubio_source_avcodec_has_network_url(s)) {
 …
   // try opening the file and get some info about it
-  AVFormatContext *avFormatCtx = s->avFormatCtx;
   avFormatCtx = NULL;
   if ( (err = avformat_open_input(&avFormatCtx, s->path, NULL, NULL) ) < 0 ) {
 …
     char errorstr[256];
     av_strerror (err, errorstr, sizeof(errorstr));
     AUBIO_ERR("source_avcodec: Could not find stream information " "for %s (%s)\n", s->path,
         errorstr);
+    AUBIO_ERR("source_avcodec: Could not find stream information "
+        "for %s (%s)\n", s->path, errorstr);
     goto beach;
+  }
 …
   // look for the first audio stream
-  uint_t i;
-  sint_t selected_stream = -1;
   for (i = 0; i < avFormatCtx->nb_streams; i++) {
+#if FF_API_LAVF_AVCTX
+    if (avFormatCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
+#else
     if (avFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
+#endif
       if (selected_stream == -1) {
         selected_stream = i;
 …
   s->selected_stream = selected_stream;
+  AVCodecContext *avCodecCtx = s->avCodecCtx;
+#if FF_API_LAVF_AVCTX
+  codecpar = avFormatCtx->streams[selected_stream]->codecpar;
+  if (codecpar == NULL) {
+    AUBIO_ERR("source_avcodec: Could not find decoder for %s", s->path);
+    goto beach;
+  }
+  codec = avcodec_find_decoder(codecpar->codec_id);
+  /* Allocate a codec context for the decoder */
+  avCodecCtx = avcodec_alloc_context3(codec);
+  if (!avCodecCtx) {
+    AUBIO_ERR("source_avcodec: Failed to allocate the %s codec context "
+        "for path %s\n", av_get_media_type_string(AVMEDIA_TYPE_AUDIO),
+        s->path);
+    goto beach;
+  }
+#else
   avCodecCtx = avFormatCtx->streams[selected_stream]->codec;
+  AVCodec *codec = avcodec_find_decoder(avCodecCtx->codec_id);
+  codec = avcodec_find_decoder(avCodecCtx->codec_id);
+#endif
   if (codec == NULL) {
     AUBIO_ERR("source_avcodec: Could not find decoder for %s", s->path);
     goto beach;
+  }
+#if FF_API_LAVF_AVCTX
+  /* Copy codec parameters from input stream to output codec context */
+  if ((err = avcodec_parameters_to_context(avCodecCtx, codecpar)) < 0) {
+    AUBIO_ERR("source_avcodec: Failed to copy %s codec parameters to "
+        "decoder context for %s\n",
+        av_get_media_type_string(AVMEDIA_TYPE_AUDIO), s->path);
+    goto beach;
+  }
+#endif
   if ( ( err = avcodec_open2(avCodecCtx, codec, NULL) ) < 0) {
     char errorstr[256];
     av_strerror (err, errorstr, sizeof(errorstr));
+    AUBIO_ERR("source_avcodec: Could not load codec for %s (%s)\n", s->path, errorstr);
+    AUBIO_ERR("source_avcodec: Could not load codec for %s (%s)\n", s->path,
+        errorstr);
     goto beach;
+  }
 …
+  }
-  AVFrame *avFrame = s->avFrame;
   avFrame = av_frame_alloc();
   if (!avFrame) {
 …
   /* allocate output for avr */
+  s->output = (float *)av_malloc(AUBIO_AVCODEC_MAX_BUFFER_SIZE * sizeof(float));
+  s->output = (smpl_t *)av_malloc(AUBIO_AVCODEC_MAX_BUFFER_SIZE
+      * sizeof(smpl_t));
   s->read_samples = 0;
 …
   s->avFrame = avFrame;
+  // default to mono output
+  aubio_source_avcodec_reset_resampler(s, 0);
+  aubio_source_avcodec_reset_resampler(s);
+  if (s->avr == NULL) goto beach;
   s->eof = 0;
-  s->multi = 0;
   //av_log_set_level(AV_LOG_QUIET);
 …
+}
+void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s, uint_t multi) {
+  if ( (multi != s->multi) || (s->avr == NULL) ) {
+void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s)
+{
+  // create or reset resampler to/from mono/multi-channel
+  if ( s->avr == NULL ) {
+    int err;
     int64_t input_layout = av_get_default_channel_layout(s->input_channels);
+    uint_t output_channels = multi ? s->input_channels : 1;
+    int64_t output_layout = av_get_default_channel_layout(output_channels);
+    if (s->avr != NULL) {
+      avresample_close( s->avr );
+      av_free ( s->avr );
+      s->avr = NULL;
+    }
+    AVAudioResampleContext *avr = s->avr;
+    avr = avresample_alloc_context();
+    av_opt_set_int(avr, "in_channel_layout",  input_layout,           0);
+    av_opt_set_int(avr, "out_channel_layout", output_layout,          0);
+    av_opt_set_int(avr, "in_sample_rate",     s->input_samplerate,    0);
+    av_opt_set_int(avr, "out_sample_rate",    s->samplerate,          0);
+    int64_t output_layout = av_get_default_channel_layout(s->input_channels);
+#ifdef HAVE_AVRESAMPLE
+    AVAudioResampleContext *avr = avresample_alloc_context();
+#elif defined(HAVE_SWRESAMPLE)
+    SwrContext *avr = swr_alloc();
+#endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */
+    av_opt_set_int(avr, "in_channel_layout",  input_layout,              0);
+    av_opt_set_int(avr, "out_channel_layout", output_layout,             0);
+    av_opt_set_int(avr, "in_sample_rate",     s->input_samplerate,       0);
+    av_opt_set_int(avr, "out_sample_rate",    s->samplerate,             0);
     av_opt_set_int(avr, "in_sample_fmt",      s->avCodecCtx->sample_fmt, 0);
+    av_opt_set_int(avr, "out_sample_fmt",     AV_SAMPLE_FMT_FLT,      0);
+    int err;
+    if ( ( err = avresample_open(avr) ) < 0) {
+#if HAVE_AUBIO_DOUBLE
+    av_opt_set_int(avr, "out_sample_fmt",     AV_SAMPLE_FMT_DBL,         0);
+#else
+    av_opt_set_int(avr, "out_sample_fmt",     AV_SAMPLE_FMT_FLT,         0);
+#endif
+    // TODO: use planar?
+    //av_opt_set_int(avr, "out_sample_fmt",     AV_SAMPLE_FMT_FLTP,      0);
+#ifdef HAVE_AVRESAMPLE
+    if ( ( err = avresample_open(avr) ) < 0)
+#elif defined(HAVE_SWRESAMPLE)
+    if ( ( err = swr_init(avr) ) < 0)
+#endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */
+    {
       char errorstr[256];
       av_strerror (err, errorstr, sizeof(errorstr));
+      AUBIO_ERR("source_avcodec: Could not open AVAudioResampleContext for %s (%s)\n",
+          s->path, errorstr);
+      //goto beach;
+      AUBIO_ERR("source_avcodec: Could not open resampling context"
+         " for %s (%s)\n", s->path, errorstr);
       return;
+    }
     s->avr = avr;
+    s->multi = multi;
+  }
+}
+void aubio_source_avcodec_readframe(aubio_source_avcodec_t *s, uint_t * read_samples) {
+  }
+}
+void aubio_source_avcodec_readframe(aubio_source_avcodec_t *s,
+    uint_t * read_samples)
+{
   AVFormatContext *avFormatCtx = s->avFormatCtx;
   AVCodecContext *avCodecCtx = s->avCodecCtx;
   AVFrame *avFrame = s->avFrame;
+  AVPacket avPacket;
+  AVPacket avPacket = s->avPacket;
+#ifdef HAVE_AVRESAMPLE
+  AVAudioResampleContext *avr = s->avr;
+#elif defined(HAVE_SWRESAMPLE)
+  SwrContext *avr = s->avr;
+#endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */
+  int got_frame = 0;
+#ifdef HAVE_AVRESAMPLE
+  int in_linesize = 0;
+  int in_samples = avFrame->nb_samples;
+  int out_linesize = 0;
+  int max_out_samples = AUBIO_AVCODEC_MAX_BUFFER_SIZE;
+  int out_samples = 0;
+#elif defined(HAVE_SWRESAMPLE)
+  int in_samples = avFrame->nb_samples;
+  int max_out_samples = AUBIO_AVCODEC_MAX_BUFFER_SIZE / avCodecCtx->channels;
+  int out_samples = 0;
+#endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */
+  smpl_t *output = s->output;
+#ifndef FF_API_LAVF_AVCTX
+  int len = 0;
+#else
+  int ret = 0;
+#endif
   av_init_packet (&avPacket);
-  AVAudioResampleContext *avr = s->avr;
-  float *output = s->output;
   *read_samples = 0;
 …
       char errorstr[256];
       av_strerror (err, errorstr, sizeof(errorstr));
+      AUBIO_ERR("Could not read frame in %s (%s)\n", s->path, errorstr);
+      AUBIO_ERR("source_avcodec: could not read frame in %s (%s)\n",
+          s->path, errorstr);
+      s->eof = 1;
       goto beach;
+    }
   } while (avPacket.stream_index != s->selected_stream);
+  int got_frame = 0;
+  int len = avcodec_decode_audio4(avCodecCtx, avFrame, &got_frame, &avPacket);
+#if FF_API_LAVF_AVCTX
+  ret = avcodec_send_packet(avCodecCtx, &avPacket);
+  if (ret < 0 && ret != AVERROR_EOF) {
+    AUBIO_ERR("source_avcodec: error when sending packet for %s\n", s->path);
+    goto beach;
+  }
+  ret = avcodec_receive_frame(avCodecCtx, avFrame);
+  if (ret >= 0) {
+    got_frame = 1;
+  }
+  if (ret < 0) {
+    if (ret == AVERROR(EAGAIN)) {
+      //AUBIO_WRN("source_avcodec: output is not available right now - "
+      //    "user must try to send new input\n");
+      goto beach;
+    } else if (ret == AVERROR_EOF) {
+      AUBIO_WRN("source_avcodec: the decoder has been fully flushed, "
+          "and there will be no more output frames\n");
+    } else {
+      AUBIO_ERR("source_avcodec: decoding errors on %s\n", s->path);
+      goto beach;
+    }
+  }
+#else
+  len = avcodec_decode_audio4(avCodecCtx, avFrame, &got_frame, &avPacket);
   if (len < 0) {
+    AUBIO_ERR("Error while decoding %s\n", s->path);
+    goto beach;
+  }
+    AUBIO_ERR("source_avcodec: error while decoding %s\n", s->path);
+    goto beach;
+  }
+#endif
   if (got_frame == 0) {
+    //AUBIO_ERR("Could not get frame for (%s)\n", s->path);
+    goto beach;
+  }
+  int in_linesize = 0;
+    AUBIO_WRN("source_avcodec: did not get a frame when reading %s\n",
+        s->path);
+    goto beach;
+  }
+#if LIBAVUTIL_VERSION_MAJOR > 52
+  if (avFrame->channels != (sint_t)s->input_channels) {
+    AUBIO_WRN ("source_avcodec: trying to read from %d channel(s),"
+        "but configured for %d; is '%s' corrupt?\n",
+        avFrame->channels, s->input_channels, s->path);
+    goto beach;
+  }
+#else
+#warning "avutil < 53 is deprecated, crashes might occur on corrupt files"
+#endif
+#ifdef HAVE_AVRESAMPLE
+  in_linesize = 0;
   av_samples_get_buffer_size(&in_linesize, avCodecCtx->channels,
       avFrame->nb_samples, avCodecCtx->sample_fmt, 1);
   int in_samples = avFrame->nb_samples;
   int out_linesize = 0;
   int max_out_samples = AUBIO_AVCODEC_MAX_BUFFER_SIZE;
   int out_samples = avresample_convert ( avr,
+  in_samples = avFrame->nb_samples;
+  out_linesize = 0;
+  max_out_samples = AUBIO_AVCODEC_MAX_BUFFER_SIZE;
+  out_samples = avresample_convert ( avr,
         (uint8_t **)&output, out_linesize, max_out_samples,
         (uint8_t **)avFrame->data, in_linesize, in_samples);
+#elif defined(HAVE_SWRESAMPLE)
+  in_samples = avFrame->nb_samples;
+  max_out_samples = AUBIO_AVCODEC_MAX_BUFFER_SIZE / avCodecCtx->channels;
+  out_samples = swr_convert( avr,
+      (uint8_t **)&output, max_out_samples,
+      (const uint8_t **)avFrame->data, in_samples);
+#endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */
   if (out_samples <= 0) {
+    //AUBIO_ERR("No sample found while converting frame (%s)\n", s->path);
+    AUBIO_WRN("source_avcodec: no sample found while converting frame (%s)\n",
+        s->path);
     goto beach;
+  }
 …
   s->avCodecCtx = avCodecCtx;
   s->avFrame = avFrame;
+#if defined(HAVE_AVRESAMPLE) || defined(HAVE_SWRESAMPLE)
   s->avr = avr;
+#endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */
   s->output = output;
 …
+}
 void aubio_source_avcodec_do(aubio_source_avcodec_t * s, fvec_t * read_data, uint_t * read){
   if (s->multi == 1) aubio_source_avcodec_reset_resampler(s, 0);
   uint_t i;
+void aubio_source_avcodec_do(aubio_source_avcodec_t * s, fvec_t * read_data,
+    uint_t * read) {
+  uint_t i, j;
   uint_t end = 0;
   uint_t total_wrote = 0;
 …
     end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote);
     for (i = 0; i < end; i++) {
+      read_data->data[i + total_wrote] = s->output[i + s->read_index];
+      read_data->data[i + total_wrote] = 0.;
+      for (j = 0; j < s->input_channels; j++) {
+        read_data->data[i + total_wrote] +=
+          s->output[(i + s->read_index) * s->input_channels + j];
+      }
+      read_data->data[i + total_wrote] *= 1./s->input_channels;
+    }
     total_wrote += end;
 …
+  }
   if (total_wrote < s->hop_size) {
     for (i = end; i < s->hop_size; i++) {
+    for (i = total_wrote; i < s->hop_size; i++) {
       read_data->data[i] = 0.;
+    }
 …
+}
 void aubio_source_avcodec_do_multi(aubio_source_avcodec_t * s, fmat_t * read_data, uint_t * read){
   if (s->multi == 0) aubio_source_avcodec_reset_resampler(s, 1);
+void aubio_source_avcodec_do_multi(aubio_source_avcodec_t * s,
+    fmat_t * read_data, uint_t * read) {
   uint_t i,j;
   uint_t end = 0;
 …
   if (total_wrote < s->hop_size) {
     for (j = 0; j < read_data->height; j++) {
       for (i = end; i < s->hop_size; i++) {
+      for (i = total_wrote; i < s->hop_size; i++) {
         read_data->data[j][i] = 0.;
+      }
 …
 uint_t aubio_source_avcodec_seek (aubio_source_avcodec_t * s, uint_t pos) {
+  int64_t resampled_pos = (uint_t)ROUND(pos * (s->input_samplerate * 1. / s->samplerate));
+  int64_t resampled_pos =
+    (uint_t)ROUND(pos * (s->input_samplerate * 1. / s->samplerate));
   int64_t min_ts = MAX(resampled_pos - 2000, 0);
   int64_t max_ts = MIN(resampled_pos + 2000, INT64_MAX);
   int seek_flags = AVSEEK_FLAG_FRAME | AVSEEK_FLAG_ANY;
+  int ret = avformat_seek_file(s->avFormatCtx, s->selected_stream,
+  int ret = AUBIO_FAIL;
+  if (s->avFormatCtx != NULL && s->avr != NULL) {
+    ret = AUBIO_OK;
+  } else {
+    AUBIO_ERR("source_avcodec: failed seeking in %s (file not opened?)",
+        s->path);
+    return ret;
+  }
+  if ((sint_t)pos < 0) {
+    AUBIO_ERR("source_avcodec: could not seek %s at %d (seeking position"
+       " should be >= 0)\n", s->path, pos);
+    return AUBIO_FAIL;
+  }
+  ret = avformat_seek_file(s->avFormatCtx, s->selected_stream,
       min_ts, resampled_pos, max_ts, seek_flags);
   if (ret < 0) {
+    AUBIO_ERR("Failed seeking to %d in file %s", pos, s->path);
+    AUBIO_ERR("source_avcodec: failed seeking to %d in file %s",
+        pos, s->path);
+  }
   // reset read status
 …
   s->read_index = 0;
   s->read_samples = 0;
+#ifdef HAVE_AVRESAMPLE
   // reset the AVAudioResampleContext
   avresample_close(s->avr);
   avresample_open(s->avr);
+#elif defined(HAVE_SWRESAMPLE)
+  swr_close(s->avr);
+  swr_init(s->avr);
+#endif
   return ret;
+}
 …
 uint_t aubio_source_avcodec_close(aubio_source_avcodec_t * s) {
   if (s->avr != NULL) {
+#ifdef HAVE_AVRESAMPLE
     avresample_close( s->avr );
+#elif defined(HAVE_SWRESAMPLE)
+    swr_close ( s->avr );
+#endif
     av_free ( s->avr );
+  }
   s->avr = NULL;
   if (s->avCodecCtx != NULL) {
+#ifndef HAVE_AUBIO_LIBAVCODEC_DEPRECATED
+    avcodec_free_context( &s->avCodecCtx );
+#else
     avcodec_close ( s->avCodecCtx );
+#endif
+  }
   s->avCodecCtx = NULL;
   if (s->avFormatCtx != NULL) {
+    avformat_close_input ( &(s->avFormatCtx) );
+  }
+  s->avFormatCtx = NULL;
+    avformat_close_input(&s->avFormatCtx);
+    s->avFormatCtx = NULL;
+  }
+  av_packet_unref(&s->avPacket);
   return AUBIO_OK;
+}
 …
     av_frame_free( &(s->avFrame) );
+  }
-  if (s->path) AUBIO_FREE(s->path);
   s->avFrame = NULL;
+  if (s->path) {
+    AUBIO_FREE(s->path);
+  }
+  s->path = NULL;
   AUBIO_FREE(s);
+}

src/io/source_sndfile.c

-                      r5b46bc3
+                      r633400d
 */
+#include "config.h"
+#include "aubio_priv.h"
 #ifdef HAVE_SNDFILE
 …
 #include <sndfile.h>
-#include "aubio_priv.h"
 #include "fvec.h"
 #include "fmat.h"
 …
 #include "temporal/resampler.h"
-#define MAX_CHANNELS 6
 #define MAX_SIZE 4096
 #define MAX_SAMPLES MAX_CHANNELS * MAX_SIZE
+#define MAX_SAMPLES AUBIO_MAX_CHANNELS * MAX_SIZE
 #if !HAVE_AUBIO_DOUBLE
 …
     if (s->ratio > 1) {
       // we would need to add a ring buffer for these
       if ( (uint_t)(s->input_hop_size * s->ratio + .5)  != s->hop_size ) {
+      if ( (uint_t)FLOOR(s->input_hop_size * s->ratio + .5)  != s->hop_size ) {
         AUBIO_ERR("source_sndfile: can not upsample %s from %d to %d\n", s->path,
             s->input_samplerate, s->samplerate);
 …
 uint_t aubio_source_sndfile_seek (aubio_source_sndfile_t * s, uint_t pos) {
   uint_t resampled_pos = (uint_t)ROUND(pos / s->ratio);
+  sf_count_t sf_ret = sf_seek (s->handle, resampled_pos, SEEK_SET);
+  sf_count_t sf_ret;
+  if (s->handle == NULL) {
+    AUBIO_ERR("source_sndfile: failed seeking in %s (file not opened?)\n",
+        s->path);
+    return AUBIO_FAIL;
+  }
+  if ((sint_t)pos < 0) {
+    AUBIO_ERR("source_sndfile: could not seek %s at %d (seeking position"
+       " should be >= 0)\n", s->path, pos);
+    return AUBIO_FAIL;
+  }
+  sf_ret = sf_seek (s->handle, resampled_pos, SEEK_SET);
   if (sf_ret == -1) {
     AUBIO_ERR("source_sndfile: Failed seeking %s at %d: %s\n", s->path, pos, sf_strerror (NULL));
 …
 uint_t aubio_source_sndfile_close (aubio_source_sndfile_t *s) {
   if (!s->handle) {
     return AUBIO_FAIL;
+    return AUBIO_OK;
+  }
   if(sf_close(s->handle)) {
 …
     return AUBIO_FAIL;
+  }
+  s->handle = NULL;
   return AUBIO_OK;
+}

src/io/source_wavread.c

-                      r5b46bc3
+                      r633400d
 */
 #include "config.h"
+#include "aubio_priv.h"
 #ifdef HAVE_WAVREAD
-#include "aubio_priv.h"
 #include "fvec.h"
 #include "fmat.h"
 …
   aubio_source_wavread_t * s = AUBIO_NEW(aubio_source_wavread_t);
   size_t bytes_read = 0, bytes_junk = 0, bytes_expected = 44;
   unsigned char buf[5];
+  unsigned char buf[5] = "\0";
   unsigned int format, channels, sr, byterate, blockalign, duration, bitspersample;//, data_size;
 …
   buf[4] = '\0';
   if ( strcmp((const char *)buf, "RIFF") != 0 ) {
     AUBIO_ERR("source_wavread: could not find RIFF header in %s\n", s->path);
+    AUBIO_ERR("source_wavread: Failed opening %s (could not find RIFF header)\n", s->path);
     goto beach;
+  }
 …
   buf[4] = '\0';
   if ( strcmp((const char *)buf, "WAVE") != 0 ) {
     AUBIO_ERR("source_wavread: wrong format in RIFF header in %s\n", s->path);
+    AUBIO_ERR("source_wavread: Failed opening %s (wrong format in RIFF header)\n", s->path);
     goto beach;
+  }
 …
     bytes_junk += read_little_endian(buf, 4);
     if (fseek(s->fid, bytes_read + bytes_junk, SEEK_SET) != 0) {
       AUBIO_ERR("source_wavread: could not seek past JUNK Chunk in %s (%s)\n",
+      AUBIO_ERR("source_wavread: Failed opening %s (could not seek past JUNK Chunk: %s)\n",
           s->path, strerror(errno));
       goto beach;
 …
   // get the fmt chunk
   if ( strcmp((const char *)buf, "fmt ") != 0 ) {
     AUBIO_ERR("source_wavread: failed finding fmt RIFF header in %s\n", s->path);
+    AUBIO_ERR("source_wavread: Failed opening %s (could not find 'fmt ' in RIFF header)\n", s->path);
     goto beach;
+  }
 …
   if ( format != 16 ) {
     // TODO accept format 18
     AUBIO_ERR("source_wavread: file %s is not encoded with PCM\n", s->path);
+    AUBIO_ERR("source_wavread: Failed opening %s (not encoded with PCM)\n", s->path);
     goto beach;
+  }
   if ( buf[1] || buf[2] | buf[3] ) {
     AUBIO_ERR("source_wavread: Subchunk1Size should be 0, in %s\n", s->path);
+    AUBIO_ERR("source_wavread: Failed opening %s (Subchunk1Size should be 0)\n", s->path);
     goto beach;
+  }
 …
   bytes_read += fread(buf, 1, 2, s->fid);
   if ( buf[0] != 1 || buf[1] != 0) {
     AUBIO_ERR("source_wavread: AudioFormat should be PCM, in %s\n", s->path);
+    AUBIO_ERR("source_wavread: Failed opening %s (AudioFormat should be PCM)\n", s->path);
     goto beach;
+  }
 …
   bytes_read += fread(buf, 1, 2, s->fid);
   bitspersample = read_little_endian(buf, 2);
+  if ( channels == 0 ) {
+    AUBIO_ERR("source_wavread: Failed opening %s (number of channels can not be 0)\n", s->path);
+    goto beach;
+  }
+  if ( (sint_t)sr <= 0 ) {
+    AUBIO_ERR("source_wavread: Failed opening %s (samplerate can not be <= 0)\n", s->path);
+    goto beach;
+  }
+  if ( byterate == 0 ) {
+    AUBIO_ERR("source_wavread: Failed opening %s (byterate can not be 0)\n", s->path);
+    goto beach;
+  }
+  if ( bitspersample == 0 ) {
+    AUBIO_ERR("source_wavread: Failed opening %s (bitspersample can not be 0)\n", s->path);
+    goto beach;
+  }
 #if 0
   if ( bitspersample != 16 ) {
 …
   if ( byterate * 8 != sr * channels * bitspersample ) {
     AUBIO_ERR("source_wavread: wrong byterate in %s\n", s->path);
+    AUBIO_ERR("source_wavread: Failed opening %s (wrong byterate)\n", s->path);
     goto beach;
+  }
   if ( blockalign * 8 != channels * bitspersample ) {
     AUBIO_ERR("source_wavread: wrong blockalign in %s\n", s->path);
+    AUBIO_ERR("source_wavread: Failed opening %s (wrong blockalign)\n", s->path);
     goto beach;
+  }
 …
   uint_t end = 0;
   uint_t total_wrote = 0;
+  if (s->fid == NULL) {
+    AUBIO_ERR("source_wavread: could not read from %s (file not opened)\n",
+        s->path);
+    return;
+  }
   while (total_wrote < s->hop_size) {
     end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote);
 …
   uint_t end = 0;
   uint_t total_wrote = 0;
+  if (s->fid == NULL) {
+    AUBIO_ERR("source_wavread: could not read from %s (file not opened)\n",
+        s->path);
+    return;
+  }
   while (total_wrote < s->hop_size) {
     end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote);
 …
 uint_t aubio_source_wavread_seek (aubio_source_wavread_t * s, uint_t pos) {
   uint_t ret = 0;
+  if (s->fid == NULL) {
+    AUBIO_ERR("source_wavread: could not seek %s (file not opened?)\n", s->path, pos);
+    return AUBIO_FAIL;
+  }
   if ((sint_t)pos < 0) {
+    AUBIO_ERR("source_wavread: could not seek %s at %d (seeking position should be >= 0)\n", s->path, pos);
     return AUBIO_FAIL;
+  }
 …
 uint_t aubio_source_wavread_close (aubio_source_wavread_t * s) {
   if (!s->fid) {
     return AUBIO_FAIL;
+  if (s->fid == NULL) {
+    return AUBIO_OK;
+  }
   if (fclose(s->fid)) {

src/io/utils_apple_audio.c

-                      r5b46bc3
+                      r633400d
 #include "config.h"
+#include "aubio_priv.h"
 #if defined(HAVE_SOURCE_APPLE_AUDIO) || defined(HAVE_SINK_APPLE_AUDIO)
 …
 // ExtAudioFileRef, AudioStreamBasicDescription, AudioBufferList, ...
 #include <AudioToolbox/AudioToolbox.h>
-#include "aubio_priv.h"
 int createAubioBufferList(AudioBufferList *bufferList, int channels, int segmentSize);

src/mathutils.c

-                      r5b46bc3
+                      r633400d
 #include "mathutils.h"
 #include "musicutils.h"
-#include "config.h"
 /** Window types */
 typedef enum
+{
+  aubio_win_ones,
   aubio_win_rectangle,
   aubio_win_hamming,
 …
       AUBIO_ERR ("window type can not be null.\n");
       return 1;
+  } else if (strcmp (window_type, "rectangle") == 0)
+  } else if (strcmp (window_type, "ones") == 0)
+      wintype = aubio_win_ones;
+  else if (strcmp (window_type, "rectangle") == 0)
       wintype = aubio_win_rectangle;
   else if (strcmp (window_type, "hamming") == 0)
 …
+  }
   switch(wintype) {
+    case aubio_win_ones:
+      fvec_ones(win);
+      break;
     case aubio_win_rectangle:
+      for (i=0;i<size;i++)
+        w[i] = 0.5;
+      fvec_set_all(win, .5);
       break;
     case aubio_win_hamming:
 …
+{
   smpl_t tmp = 0.0;
+#ifndef HAVE_ACCELERATE
+#if defined(HAVE_INTEL_IPP)
+  aubio_ippsMean(s->data, (int)s->length, &tmp);
+  return tmp;
+#elif defined(HAVE_ACCELERATE)
+  aubio_vDSP_meanv(s->data, 1, &tmp, s->length);
+  return tmp;
+#else
   uint_t j;
   for (j = 0; j < s->length; j++) {
     tmp += s->data[j];
+  }
+  return tmp / (smpl_t) (s->length);
+#else
+  aubio_vDSP_meanv(s->data, 1, &tmp, s->length);
+  return tmp;
+#endif /* HAVE_ACCELERATE */
+  return tmp / (smpl_t)(s->length);
+#endif
+}
 …
+{
   smpl_t tmp = 0.0;
+#ifndef HAVE_ACCELERATE
+#if defined(HAVE_INTEL_IPP)
+  aubio_ippsSum(s->data, (int)s->length, &tmp);
+#elif defined(HAVE_ACCELERATE)
+  aubio_vDSP_sve(s->data, 1, &tmp, s->length);
+#else
   uint_t j;
   for (j = 0; j < s->length; j++) {
     tmp += s->data[j];
+  }
+#else
+  aubio_vDSP_sve(s->data, 1, &tmp, s->length);
+#endif /* HAVE_ACCELERATE */
+#endif
   return tmp;
+}
 …
 fvec_max (fvec_t * s)
+{
+#ifndef HAVE_ACCELERATE
+  uint_t j;
+  smpl_t tmp = 0.0;
+  for (j = 0; j < s->length; j++) {
+#if defined(HAVE_INTEL_IPP)
+  smpl_t tmp = 0.;
+  aubio_ippsMax( s->data, (int)s->length, &tmp);
+#elif defined(HAVE_ACCELERATE)
+  smpl_t tmp = 0.;
+  aubio_vDSP_maxv( s->data, 1, &tmp, s->length );
+#else
+  uint_t j;
+  smpl_t tmp = s->data[0];
+  for (j = 1; j < s->length; j++) {
     tmp = (tmp > s->data[j]) ? tmp : s->data[j];
+  }
+#else
+#endif
+  return tmp;
+}
+smpl_t
+fvec_min (fvec_t * s)
+{
+#if defined(HAVE_INTEL_IPP)
   smpl_t tmp = 0.;
+  aubio_vDSP_maxv(s->data, 1, &tmp, s->length);
+#endif
+  return tmp;
+}
+smpl_t
+fvec_min (fvec_t * s)
+{
+#ifndef HAVE_ACCELERATE
+  uint_t j;
+  smpl_t tmp = s->data[0];
+  for (j = 0; j < s->length; j++) {
+    tmp = (tmp < s->data[j]) ? tmp : s->data[j];
+  }
+#else
+  aubio_ippsMin(s->data, (int)s->length, &tmp);
+#elif defined(HAVE_ACCELERATE)
   smpl_t tmp = 0.;
   aubio_vDSP_minv(s->data, 1, &tmp, s->length);
+#else
+  uint_t j;
+  smpl_t tmp = s->data[0];
+  for (j = 1; j < s->length; j++) {
+    tmp = (tmp < s->data[j]) ? tmp : s->data[j];
+  }
 #endif
   return tmp;
 …
 #else
   smpl_t tmp = 0.;
   uint_t pos = 0.;
   aubio_vDSP_minvi(s->data, 1, &tmp, (vDSP_Length *)&pos, s->length);
 #endif
   return pos;
+  vDSP_Length pos = 0;
+  aubio_vDSP_minvi(s->data, 1, &tmp, &pos, s->length);
+#endif
+  return (uint_t)pos;
+}
 …
 #else
   smpl_t tmp = 0.;
   uint_t pos = 0.;
   aubio_vDSP_maxvi(s->data, 1, &tmp, (vDSP_Length *)&pos, s->length);
 #endif
   return pos;
+  vDSP_Length pos = 0;
+  aubio_vDSP_maxvi(s->data, 1, &tmp, &pos, s->length);
+#endif
+  return (uint_t)pos;
+}
 …
   // if length is odd, middle element is moved to the end
   if (2 * half < s->length) start ++;
 #ifndef HAVE_ATLAS
+#ifndef HAVE_BLAS
   for (j = 0; j < half; j++) {
     ELEM_SWAP (s->data[j], s->data[j + start]);
 …
   // if length is odd, middle element is moved to the beginning
   if (2 * half < s->length) start ++;
 #ifndef HAVE_ATLAS
+#ifndef HAVE_BLAS
   for (j = 0; j < half; j++) {
     ELEM_SWAP (s->data[j], s->data[j + start]);
 …
+}
+void fvec_push(fvec_t *in, smpl_t new_elem) {
+  uint_t i;
+  for (i = 0; i < in->length - 1; i++) {
+    in->data[i] = in->data[i + 1];
+  }
+  in->data[in->length - 1] = new_elem;
+}
+void fvec_clamp(fvec_t *in, smpl_t absmax) {
+  uint_t i;
+  for (i = 0; i < in->length; i++) {
+    if (in->data[i] > 0 && in->data[i] > ABS(absmax)) {
+      in->data[i] = absmax;
+    } else if (in->data[i] < 0 && in->data[i] < -ABS(absmax)) {
+      in->data[i] = -absmax;
+    }
+  }
+}
 smpl_t
 aubio_level_lin (const fvec_t * f)
+{
   smpl_t energy = 0.;
 #ifndef HAVE_ATLAS
+#ifndef HAVE_BLAS
   uint_t j;
   for (j = 0; j < f->length; j++) {
 …
   for (j = 0; j < o->length; j++) {
     o->data[j] += val;
+  }
+}
+void
+fvec_mul (fvec_t *o, smpl_t val)
+{
+  uint_t j;
+  for (j = 0; j < o->length; j++) {
+    o->data[j] *= val;
+  }
+}
 …
   /* log(freq/A-2)/log(2) */
   midi = freq / 6.875;
   midi = LOG (midi) / 0.69314718055995;
+  midi = LOG (midi) / 0.6931471805599453;
   midi *= 12;
   midi -= 3;
 …
   if (midi > 140.) return 0.; // avoid infs
   freq = (midi + 3.) / 12.;
   freq = EXP (freq * 0.69314718055995);
+  freq = EXP (freq * 0.6931471805599453);
   freq *= 6.875;
   return freq;
 …
   while (i < a) i <<= 1;
   return i;
+}
+uint_t
+aubio_power_of_two_order (uint_t a)
+{
+  int order = 0;
+  int temp = aubio_next_power_of_two(a);
+  while (temp >>= 1) {
+    ++order;
+  }
+  return order;
+}

src/mathutils.h

-                      r5b46bc3
+                      r633400d
 void fvec_ishift (fvec_t * v);
+/** push a new element to the end of a vector, erasing the first element and
+ * sliding all others
+  \param in vector to push to
+  \param new_elem new_element to add at the end of the vector
+  In numpy words, this is equivalent to: in = np.concatenate([in, [new_elem]])[1:]
+*/
+void fvec_push(fvec_t *in, smpl_t new_elem);
 /** compute the sum of all elements of a vector
 …
 */
 void fvec_add (fvec_t * v, smpl_t c);
+/** multiply each elements of a vector by a scalar
+  \param v vector to add constant to
+  \param s constant to scale v with
+*/
+void fvec_mul (fvec_t * v, smpl_t s);
 /** remove the minimum value of the vector to each elements
 …
 uint_t aubio_next_power_of_two(uint_t a);
+/** return the log2 factor of the given power of 2 value a */
+uint_t aubio_power_of_two_order(uint_t a);
 /** compute normalised autocorrelation function

src/musicutils.h

-                      r5b46bc3
+                      r633400d
 smpl_t aubio_freqtobin (smpl_t freq, smpl_t samplerate, smpl_t fftsize);
+/** convert frequency (Hz) to mel
+  \param freq input frequency, in Hz
+  \return output mel
+  Converts a scalar from the frequency domain to the mel scale using Slaney
+  Auditory Toolbox's implementation:
+  If \f$ f < 1000 \f$, \f$ m = 3 f / 200 \f$.
+  If \f$ f >= 1000 \f$, \f$ m = 1000 + 27 \frac{{ln}(f) - ln(1000))}
+  {{ln}(6400) - ln(1000)}
+  \f$
+  See also
+  --------
+  aubio_meltohz(), aubio_hztomel_htk().
+*/
+smpl_t aubio_hztomel (smpl_t freq);
+/** convert mel to frequency (Hz)
+  \param mel input mel
+  \return output frequency, in Hz
+  Converts a scalar from the mel scale to the frequency domain using Slaney
+  Auditory Toolbox's implementation:
+  If \f$ f < 1000 \f$, \f$ f = 200 m/3 \f$.
+  If \f$ f \geq 1000 \f$, \f$ f = 1000 + \left(\frac{6400}{1000}\right)
+  ^{\frac{m - 1000}{27}} \f$
+  See also
+  --------
+  aubio_hztomel(), aubio_meltohz_htk().
+  References
+  ----------
+  Malcolm Slaney, *Auditory Toolbox Version 2, Technical Report #1998-010*
+  https://engineering.purdue.edu/~malcolm/interval/1998-010/
+*/
+smpl_t aubio_meltohz (smpl_t mel);
+/** convert frequency (Hz) to mel
+  \param freq input frequency, in Hz
+  \return output mel
+  Converts a scalar from the frequency domain to the mel scale, using the
+  equation defined by O'Shaughnessy, as implemented in the HTK speech
+  recognition toolkit:
+  \f$ m = 1127 + ln(1 + \frac{f}{700}) \f$
+  See also
+  --------
+  aubio_meltohz_htk(), aubio_hztomel().
+  References
+  ----------
+  Douglas O'Shaughnessy (1987). *Speech communication: human and machine*.
+  Addison-Wesley. p. 150. ISBN 978-0-201-16520-3.
+  HTK Speech Recognition Toolkit: http://htk.eng.cam.ac.uk/
+ */
+smpl_t aubio_hztomel_htk (smpl_t freq);
+/** convert mel to frequency (Hz)
+  \param mel input mel
+  \return output frequency, in Hz
+  Converts a scalar from the mel scale to the frequency domain, using the
+  equation defined by O'Shaughnessy, as implemented in the HTK speech
+  recognition toolkit:
+  \f$ f = 700 * {e}^\left(\frac{f}{1127} - 1\right) \f$
+  See also
+  --------
+  aubio_hztomel_htk(), aubio_meltohz().
+*/
+smpl_t aubio_meltohz_htk (smpl_t mel);
 /** convert frequency (Hz) to midi value (0-128) */
 smpl_t aubio_freqtomidi (smpl_t freq);
 …
 */
 smpl_t aubio_level_detection (const fvec_t * v, smpl_t threshold);
+/** clamp the values of a vector within the range [-abs(max), abs(max)]
+  \param in vector to clamp
+  \param absmax maximum value over which input vector elements should be clamped
+*/
+void fvec_clamp(fvec_t *in, smpl_t absmax);
 #ifdef __cplusplus

src/notes/notes.c

-                      r5b46bc3
+                      r633400d
 /*
   Copyright (C) 2014 Paul Brossier <piem@aubio.org>
+  Copyright (C) 2014-2018 Paul Brossier <piem@aubio.org>
   This file is part of aubio.
 …
 #include "notes/notes.h"
+#define AUBIO_DEFAULT_NOTES_SILENCE -70.
+#define AUBIO_DEFAULT_NOTES_RELEASE_DROP 10.
+// increase to 10. for .1  cent precision
+//      or to 100. for .01 cent precision
+#define AUBIO_DEFAULT_CENT_PRECISION 1.
+#define AUBIO_DEFAULT_NOTES_MINIOI_MS 30.
 struct _aubio_notes_t {
 …
   uint_t isready;
+  smpl_t last_onset_level;
+  smpl_t release_drop_level;
 };
 …
   o->onset = new_aubio_onset (onset_method, o->onset_buf_size, o->hop_size, o->samplerate);
+  if (o->onset == NULL) goto fail;
   if (o->onset_threshold != 0.) aubio_onset_set_threshold (o->onset, o->onset_threshold);
   o->onset_output = new_fvec (1);
   o->pitch = new_aubio_pitch (pitch_method, o->pitch_buf_size, o->hop_size, o->samplerate);
+  if (o->pitch == NULL) goto fail;
   if (o->pitch_tolerance != 0.) aubio_pitch_set_tolerance (o->pitch, o->pitch_tolerance);
+  aubio_pitch_set_unit (o->pitch, "midi");
   o->pitch_output = new_fvec (1);
 …
   o->note_buffer2 = new_fvec(o->median);
+  if (!o->onset_output || !o->pitch_output ||
+      !o->note_buffer || !o->note_buffer2) goto fail;
   o->curnote = -1.;
   o->newnote = 0.;
+  o->silence_threshold = -90.;
+  aubio_notes_set_silence(o, AUBIO_DEFAULT_NOTES_SILENCE);
+  aubio_notes_set_minioi_ms (o, AUBIO_DEFAULT_NOTES_MINIOI_MS);
+  o->last_onset_level = AUBIO_DEFAULT_NOTES_SILENCE;
+  o->release_drop_level = AUBIO_DEFAULT_NOTES_RELEASE_DROP;
   return o;
 …
   del_aubio_notes(o);
   return NULL;
+}
+uint_t aubio_notes_set_silence(aubio_notes_t *o, smpl_t silence)
+{
+  uint_t err = AUBIO_OK;
+  if (aubio_pitch_set_silence(o->pitch, silence) != AUBIO_OK) {
+    err = AUBIO_FAIL;
+  }
+  if (aubio_onset_set_silence(o->onset, silence) != AUBIO_OK) {
+    err = AUBIO_FAIL;
+  }
+  o->silence_threshold = silence;
+  return err;
+}
+smpl_t aubio_notes_get_silence(const aubio_notes_t *o)
+{
+  return aubio_pitch_get_silence(o->pitch);
+}
+uint_t aubio_notes_set_minioi_ms (aubio_notes_t *o, smpl_t minioi_ms)
+{
+  uint_t err = AUBIO_OK;
+  if (!o->onset || (aubio_onset_set_minioi_ms(o->onset, minioi_ms) != 0)) {
+    err = AUBIO_FAIL;
+  }
+  return err;
+}
+smpl_t aubio_notes_get_minioi_ms(const aubio_notes_t *o)
+{
+  return aubio_onset_get_minioi_ms(o->onset);
+}
+uint_t aubio_notes_set_release_drop(aubio_notes_t *o, smpl_t release_drop_level)
+{
+  uint_t err = AUBIO_OK;
+  if (release_drop_level <= 0.) {
+    AUBIO_ERR("notes: release_drop should be >= 0, got %f\n", release_drop_level);
+    err = AUBIO_FAIL;
+  } else {
+    o->release_drop_level = release_drop_level;
+  }
+  return err;
+}
+smpl_t aubio_notes_get_release_drop(const aubio_notes_t *o)
+{
+  return o->release_drop_level;
+}
 …
     note_buffer->data[i] = note_buffer->data[i + 1];
+  }
+  note_buffer->data[note_buffer->length - 1] = curnote;
+  //note_buffer->data[note_buffer->length - 1] = ROUND(10.*curnote)/10.;
+  note_buffer->data[note_buffer->length - 1] = ROUND(AUBIO_DEFAULT_CENT_PRECISION*curnote);
   return;
+}
 static uint_t
+static smpl_t
 aubio_notes_get_latest_note (aubio_notes_t *o)
+{
+  uint_t i;
+  for (i = 0; i < o->note_buffer->length; i++) {
+    o->note_buffer2->data[i] = o->note_buffer->data[i];
+  }
+  return fvec_median (o->note_buffer2);
+  fvec_copy(o->note_buffer, o->note_buffer2);
+  return fvec_median (o->note_buffer2) / AUBIO_DEFAULT_CENT_PRECISION;
+}
 …
       //notes->data[0] = o->curnote;
       //notes->data[1] = 0.;
+      //AUBIO_WRN("notes: sending note-off at onset, not enough level\n");
       notes->data[2] = o->curnote;
     } else {
 …
         /* kill old note */
         //send_noteon(o->curnote,0, o->samplerate);
+        //AUBIO_WRN("notes: sending note-off at onset, new onset detected\n");
         notes->data[2] = o->curnote;
         /* get and send new one */
 …
         o->curnote = new_pitch;
+      }
+      o->last_onset_level = curlevel;
+    }
   } else {
+    if (o->median) {
+    if (curlevel < o->last_onset_level - o->release_drop_level)
+    {
+      // send note off
+      //AUBIO_WRN("notes: sending note-off, release detected\n");
+      notes->data[0] = 0;
+      notes->data[1] = 0;
+      notes->data[2] = o->curnote;
+      // reset last_onset_level to silence_threshold
+      o->last_onset_level = o->silence_threshold;
+      o->curnote = 0;
+    }
+    else if (o->median)
+    {
       if (o->isready > 0)
         o->isready++;
 …
         /* kill old note */
         //send_noteon(curnote,0);
+        notes->data[2] = o->curnote;
+        if (o->curnote != 0)
+        {
+          //AUBIO_WRN("notes: sending note-off, new note detected\n");
+          notes->data[2] = o->curnote;
+        }
         o->newnote = aubio_notes_get_latest_note(o);
         o->curnote = o->newnote;

src/notes/notes.h

-                      r5b46bc3
+                      r633400d
   You should have received a copy of the GNU General Public License
   along with aubio.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** \file
+  Note detection object
 */
 …
   \param o note detection object as returned by new_aubio_notes()
+  \param in input signal of size [hop_size]
+  \param out output notes of size [3] ? FIXME
+  \param input input signal of size [hop_size]
+  \param output output notes, fvec of length 3
+  The notes output is a vector of length 3 containing:
+   - 0. the midi note value, or 0 if no note was found
+   - 1. the note velocity
+   - 2. the midi note to turn off
 */
 void aubio_notes_do (aubio_notes_t *o, const fvec_t * input, fvec_t * output);
+/** set notes detection silence threshold
+  \param o notes detection object as returned by new_aubio_notes()
+  \param silence new silence detection threshold
+  \return 0 on success, non-zero otherwise
+*/
+uint_t aubio_notes_set_silence(aubio_notes_t * o, smpl_t silence);
+/** get notes detection silence threshold
+  \param o notes detection object as returned by new_aubio_notes()
+  \return current silence threshold
+*/
+smpl_t aubio_notes_get_silence(const aubio_notes_t * o);
+/** get notes detection minimum inter-onset interval, in millisecond
+  \param o notes detection object as returned by new_aubio_notes()
+  \return current minimum inter onset interval
+ */
+smpl_t aubio_notes_get_minioi_ms(const aubio_notes_t *o);
+/** set notes detection minimum inter-onset interval, in millisecond
+  \param o notes detection object as returned by new_aubio_notes()
+  \param minioi_ms new inter-onset interval
+  \return 0 on success, non-zero otherwise
+*/
+uint_t aubio_notes_set_minioi_ms (aubio_notes_t *o, smpl_t minioi_ms);
+/** get notes object release drop level, in dB
+  \param o notes detection object as returned by new_aubio_notes()
+  \return current release drop level, in dB
+ */
+smpl_t aubio_notes_get_release_drop (const aubio_notes_t *o);
+/** set note release drop level, in dB
+  This function sets the release_drop_level parameter, in dB. When a new note
+  is found, the current level in dB is measured. If the measured level drops
+  under that initial level - release_drop_level, then a note-off will be
+  emitted.
+  Defaults to `10`, in dB.
+  \note This parameter was added in version `0.4.8`. Results obtained with
+  earlier versions can be reproduced by setting this value to `100`, so that
+  note-off will not be played until the next note.
+  \param o notes detection object as returned by new_aubio_notes()
+  \param release_drop new release drop level, in dB
+  \return 0 on success, non-zero otherwise
+*/
+uint_t aubio_notes_set_release_drop (aubio_notes_t *o, smpl_t release_drop);
 #ifdef __cplusplus

src/onset/onset.c

-                      r5b46bc3
+                      r633400d
 #include "spectral/specdesc.h"
 #include "spectral/phasevoc.h"
+#include "spectral/awhitening.h"
 #include "onset/peakpicker.h"
 #include "mathutils.h"
 #include "onset/onset.h"
+void aubio_onset_default_parameters (aubio_onset_t *o, const char_t * method);
 /** structure to store object state */
 …
   uint_t total_frames;          /**< total number of frames processed since the beginning */
   uint_t last_onset;            /**< last detected onset location, in frames */
+  uint_t apply_compression;
+  smpl_t lambda_compression;
+  uint_t apply_awhitening;      /**< apply adaptive spectral whitening */
+  aubio_spectral_whitening_t *spectral_whitening;
 };
 …
   smpl_t isonset = 0;
   aubio_pvoc_do (o->pv,input, o->fftgrain);
+  /*
+  if (apply_filtering) {
+  }
+  */
+  if (o->apply_awhitening) {
+    aubio_spectral_whitening_do(o->spectral_whitening, o->fftgrain);
+  }
+  if (o->apply_compression) {
+    cvec_logmag(o->fftgrain, o->lambda_compression);
+  }
   aubio_specdesc_do (o->od, o->fftgrain, o->desc);
   aubio_peakpicker_do(o->pp, o->desc, onset);
 …
       isonset  = 0;
     } else {
+      // we have an onset
       uint_t new_onset = o->total_frames + (uint_t)ROUND(isonset * o->hop_size);
+      // check if last onset time was more than minioi ago
       if (o->last_onset + o->minioi < new_onset) {
+        //AUBIO_DBG ("accepted detection, marking as onset\n");
+        o->last_onset = new_onset;
+        // start of file: make sure (new_onset - delay) >= 0
+        if (o->last_onset > 0 && o->delay > new_onset) {
+          isonset = 0;
+        } else {
+          //AUBIO_DBG ("accepted detection, marking as onset\n");
+          o->last_onset = MAX(o->delay, new_onset);
+        }
       } else {
         //AUBIO_DBG ("doubled onset, not marking as onset\n");
 …
+}
+uint_t aubio_onset_set_awhitening (aubio_onset_t *o, uint_t enable)
+{
+  o->apply_awhitening = enable == 1 ? 1 : 0;
+  return AUBIO_OK;
+}
+smpl_t aubio_onset_get_awhitening (aubio_onset_t *o)
+{
+  return o->apply_awhitening;
+}
+uint_t aubio_onset_set_compression (aubio_onset_t *o, smpl_t lambda)
+{
+  if (lambda < 0.) {
+    return AUBIO_FAIL;
+  }
+  o->lambda_compression = lambda;
+  o->apply_compression = (o->lambda_compression > 0.) ? 1 : 0;
+  return AUBIO_OK;
+}
+smpl_t aubio_onset_get_compression (aubio_onset_t *o)
+{
+  return o->apply_compression ? o->lambda_compression : 0;
+}
 uint_t aubio_onset_set_silence(aubio_onset_t * o, smpl_t silence) {
   o->silence = silence;
 …
   o->pp = new_aubio_peakpicker();
   o->od = new_aubio_specdesc(onset_mode,buf_size);
-  if (o->od == NULL) goto beach_specdesc;
   o->fftgrain = new_cvec(buf_size);
   o->desc = new_fvec(1);
+  o->spectral_whitening = new_aubio_spectral_whitening(buf_size, hop_size, samplerate);
+  if (!o->pv || !o->pp || !o->od || !o->fftgrain
+      || !o->desc || !o->spectral_whitening)
+    goto beach;
+  /* initialize internal variables */
+  aubio_onset_set_default_parameters (o, onset_mode);
+  aubio_onset_reset(o);
+  return o;
+beach:
+  del_aubio_onset(o);
+  return NULL;
+}
+void aubio_onset_reset (aubio_onset_t *o) {
+  o->last_onset = 0;
+  o->total_frames = 0;
+}
+uint_t aubio_onset_set_default_parameters (aubio_onset_t * o, const char_t * onset_mode)
+{
+  uint_t ret = AUBIO_OK;
   /* set some default parameter */
   aubio_onset_set_threshold (o, 0.3);
+  aubio_onset_set_delay(o, 4.3 * hop_size);
+  aubio_onset_set_minioi_ms(o, 20.);
+  aubio_onset_set_silence(o, -70.);
+  /* initialize internal variables */
+  o->last_onset = 0;
+  o->total_frames = 0;
+  return o;
+beach_specdesc:
+  del_aubio_peakpicker(o->pp);
+  del_aubio_pvoc(o->pv);
+beach:
+  aubio_onset_set_delay (o, 4.3 * o->hop_size);
+  aubio_onset_set_minioi_ms (o, 50.);
+  aubio_onset_set_silence (o, -70.);
+  // disable spectral whitening
+  aubio_onset_set_awhitening (o, 0);
+  // disable logarithmic magnitude
+  aubio_onset_set_compression (o, 0.);
+  /* method specific optimisations */
+  if (strcmp (onset_mode, "energy") == 0) {
+  } else if (strcmp (onset_mode, "hfc") == 0 || strcmp (onset_mode, "default") == 0) {
+    aubio_onset_set_threshold (o, 0.058);
+    aubio_onset_set_compression (o, 1.);
+  } else if (strcmp (onset_mode, "complexdomain") == 0
+             || strcmp (onset_mode, "complex") == 0) {
+    aubio_onset_set_delay (o, 4.6 * o->hop_size);
+    aubio_onset_set_threshold (o, 0.15);
+    aubio_onset_set_awhitening(o, 1);
+    aubio_onset_set_compression (o, 1.);
+  } else if (strcmp (onset_mode, "phase") == 0) {
+    o->apply_compression = 0;
+    aubio_onset_set_awhitening (o, 0);
+  } else if (strcmp (onset_mode, "wphase") == 0) {
+    // use defaults for now
+  } else if (strcmp (onset_mode, "mkl") == 0) {
+    aubio_onset_set_threshold (o, 0.05);
+    aubio_onset_set_awhitening(o, 1);
+    aubio_onset_set_compression (o, 0.02);
+  } else if (strcmp (onset_mode, "kl") == 0) {
+    aubio_onset_set_threshold (o, 0.35);
+    aubio_onset_set_awhitening(o, 1);
+    aubio_onset_set_compression (o, 0.02);
+  } else if (strcmp (onset_mode, "specflux") == 0) {
+    aubio_onset_set_threshold (o, 0.18);
+    aubio_onset_set_awhitening(o, 1);
+    aubio_spectral_whitening_set_relax_time(o->spectral_whitening, 100);
+    aubio_spectral_whitening_set_floor(o->spectral_whitening, 1.);
+    aubio_onset_set_compression (o, 10.);
+  } else if (strcmp (onset_mode, "specdiff") == 0) {
+  } else if (strcmp (onset_mode, "old_default") == 0) {
+    // used to reproduce results obtained with the previous version
+    aubio_onset_set_threshold (o, 0.3);
+    aubio_onset_set_minioi_ms (o, 20.);
+    aubio_onset_set_compression (o, 0.);
+  } else {
+    AUBIO_WRN("onset: unknown spectral descriptor type %s, "
+               "using default parameters.\n", onset_mode);
+    ret = AUBIO_FAIL;
+  }
+  return ret;
+}
+void del_aubio_onset (aubio_onset_t *o)
+{
+  if (o->spectral_whitening)
+    del_aubio_spectral_whitening(o->spectral_whitening);
+  if (o->od)
+    del_aubio_specdesc(o->od);
+  if (o->pp)
+    del_aubio_peakpicker(o->pp);
+  if (o->pv)
+    del_aubio_pvoc(o->pv);
+  if (o->desc)
+    del_fvec(o->desc);
+  if (o->fftgrain)
+    del_cvec(o->fftgrain);
   AUBIO_FREE(o);
+  return NULL;
+}
+void del_aubio_onset (aubio_onset_t *o)
+{
+  del_aubio_specdesc(o->od);
+  del_aubio_peakpicker(o->pp);
+  del_aubio_pvoc(o->pv);
+  del_fvec(o->desc);
+  del_cvec(o->fftgrain);
+  AUBIO_FREE(o);
+}
+}

src/onset/onset.h

-                      r5b46bc3
+                      r633400d
 smpl_t aubio_onset_get_last_ms (const aubio_onset_t *o);
+/** set onset detection adaptive whitening
+  \param o onset detection object as returned by new_aubio_onset()
+  \param enable 1 to enable, 0 to disable
+  \return 0 if successful, 1 otherwise
+*/
+uint_t aubio_onset_set_awhitening(aubio_onset_t * o, uint_t enable);
+/** get onset detection adaptive whitening
+  \param o onset detection object as returned by new_aubio_onset()
+  \return 1 if enabled, 0 otherwise
+*/
+smpl_t aubio_onset_get_awhitening(aubio_onset_t * o);
+/** set or disable log compression
+  \param o onset detection object as returned by new_aubio_onset()
+  \param lambda logarithmic compression factor, 0 to disable
+  \return 0 if successful, 1 otherwise
+ */
+uint_t aubio_onset_set_compression(aubio_onset_t *o, smpl_t lambda);
+/** get onset detection log compression
+  \param o onset detection object as returned by new_aubio_onset()
+  \returns 0 if disabled, compression factor otherwise
+ */
+smpl_t aubio_onset_get_compression(aubio_onset_t *o);
 /** set onset detection silence threshold
 …
 */
 smpl_t aubio_onset_get_threshold(const aubio_onset_t * o);
+/** set default parameters
+  \param o onset detection object as returned by new_aubio_onset()
+  \param onset_mode detection mode to adjust
+  This function is called at the end of new_aubio_onset().
+ */
+uint_t aubio_onset_set_default_parameters (aubio_onset_t * o, const char_t * onset_mode);
+/** reset onset detection
+  \param o onset detection object as returned by new_aubio_onset()
+  Reset current time and last onset to 0.
+  This function is called at the end of new_aubio_onset().
+ */
+void aubio_onset_reset(aubio_onset_t * o);
 /** delete onset detection object

src/onset/peakpicker.c

-                      r5b46bc3
+                      r633400d
   fvec_t *scratch = p->scratch;
   smpl_t mean = 0., median = 0.;
-  uint_t length = p->win_post + p->win_pre + 1;
   uint_t j = 0;
+  /* store onset in onset_keep */
+  /* shift all elements but last, then write last */
+  for (j = 0; j < length - 1; j++) {
+    onset_keep->data[j] = onset_keep->data[j + 1];
+    onset_proc->data[j] = onset_keep->data[j];
+  }
+  onset_keep->data[length - 1] = onset->data[0];
+  onset_proc->data[length - 1] = onset->data[0];
+  /* push new novelty to the end */
+  fvec_push(onset_keep, onset->data[0]);
+  /* store a copy */
+  fvec_copy(onset_keep, onset_proc);
+  /* filter onset_proc */
+  /** \bug filtfilt calculated post+pre times, should be only once !? */
+  /* filter this copy */
   aubio_filter_do_filtfilt (p->biquad, onset_proc, scratch);
   /* calculate mean and median for onset_proc */
   mean = fvec_mean (onset_proc);
+  /* copy to scratch */
   for (j = 0; j < length; j++)
     scratch->data[j] = onset_proc->data[j];
+  /* copy to scratch and compute its median */
+  fvec_copy(onset_proc, scratch);
   median = p->thresholdfn (scratch);
 …
    */
   t->biquad = new_aubio_filter_biquad (0.15998789, 0.31997577, 0.15998789,
+      -0.59488894, 0.23484048);
+      // FIXME: broken since c9e20ca, revert for now
+      //-0.59488894, 0.23484048);
+.23484048, 0);
   return t;

src/pitch/pitch.c

-                      r5b46bc3
+                      r633400d
 #include "pitch/pitchschmitt.h"
 #include "pitch/pitchyinfft.h"
+#include "pitch/pitchyinfast.h"
 #include "pitch/pitchspecacf.h"
 #include "pitch/pitch.h"
 …
   aubio_pitcht_fcomb,      /**< `fcomb`, Fast comb filter */
   aubio_pitcht_yinfft,     /**< `yinfft`, Spectral YIN */
+  aubio_pitcht_yinfast,    /**< `yinfast`, YIN fast */
   aubio_pitcht_specacf,    /**< `specacf`, Spectral autocorrelation */
   aubio_pitcht_default
 …
 static void aubio_pitch_do_fcomb (aubio_pitch_t * p, const fvec_t * ibuf, fvec_t * obuf);
 static void aubio_pitch_do_yinfft (aubio_pitch_t * p, const fvec_t * ibuf, fvec_t * obuf);
+static void aubio_pitch_do_yinfast (aubio_pitch_t * p, const fvec_t * ibuf, fvec_t * obuf);
 static void aubio_pitch_do_specacf (aubio_pitch_t * p, const fvec_t * ibuf, fvec_t * obuf);
 …
   aubio_pitch_t *p = AUBIO_NEW (aubio_pitch_t);
   aubio_pitch_type pitch_type;
+  if (pitch_mode == NULL) {
+    AUBIO_ERR ("pitch: can not use ‘NULL‘ for pitch detection method\n");
+    goto beach;
+  }
   if (strcmp (pitch_mode, "mcomb") == 0)
     pitch_type = aubio_pitcht_mcomb;
+  else if (strcmp (pitch_mode, "yinfast") == 0)
+    pitch_type = aubio_pitcht_yinfast;
   else if (strcmp (pitch_mode, "yinfft") == 0)
     pitch_type = aubio_pitcht_yinfft;
 …
     goto beach;
   } else if (bufsize < hopsize) {
     AUBIO_ERR("pitch: hop size (%d) is larger than win size (%d)\n", bufsize, hopsize);
+    AUBIO_ERR("pitch: hop size (%d) is larger than win size (%d)\n", hopsize, bufsize);
     goto beach;
   } else if ((sint_t)samplerate < 1) {
 …
       p->buf = new_fvec (bufsize);
       p->p_object = new_aubio_pitchyin (bufsize);
+      if (!p->p_object) goto beach;
       p->detect_cb = aubio_pitch_do_yin;
       p->conf_cb = (aubio_pitch_get_conf_t)aubio_pitchyin_get_confidence;
 …
       p->filtered = new_fvec (hopsize);
       p->pv = new_aubio_pvoc (bufsize, hopsize);
+      if (!p->pv) goto beach;
       p->fftgrain = new_cvec (bufsize);
       p->p_object = new_aubio_pitchmcomb (bufsize, hopsize);
 …
       p->buf = new_fvec (bufsize);
       p->p_object = new_aubio_pitchfcomb (bufsize, hopsize);
+      if (!p->p_object) goto beach;
       p->detect_cb = aubio_pitch_do_fcomb;
       break;
 …
       p->buf = new_fvec (bufsize);
       p->p_object = new_aubio_pitchyinfft (samplerate, bufsize);
+      if (!p->p_object) goto beach;
       p->detect_cb = aubio_pitch_do_yinfft;
       p->conf_cb = (aubio_pitch_get_conf_t)aubio_pitchyinfft_get_confidence;
       aubio_pitchyinfft_set_tolerance (p->p_object, 0.85);
       break;
+    case aubio_pitcht_yinfast:
+      p->buf = new_fvec (bufsize);
+      p->p_object = new_aubio_pitchyinfast (bufsize);
+      if (!p->p_object) goto beach;
+      p->detect_cb = aubio_pitch_do_yinfast;
+      p->conf_cb = (aubio_pitch_get_conf_t)aubio_pitchyinfast_get_confidence;
+      aubio_pitchyinfast_set_tolerance (p->p_object, 0.15);
+      break;
     case aubio_pitcht_specacf:
       p->buf = new_fvec (bufsize);
       p->p_object = new_aubio_pitchspecacf (bufsize);
+      if (!p->p_object) goto beach;
       p->detect_cb = aubio_pitch_do_specacf;
       p->conf_cb = (aubio_pitch_get_conf_t)aubio_pitchspecacf_get_tolerance;
 …
 beach:
+  if (p->filtered) del_fvec(p->filtered);
+  if (p->buf) del_fvec(p->buf);
   AUBIO_FREE(p);
   return NULL;
 …
       del_fvec (p->buf);
       del_aubio_pitchyinfft (p->p_object);
+      break;
+    case aubio_pitcht_yinfast:
+      del_fvec (p->buf);
+      del_aubio_pitchyinfast (p->p_object);
       break;
     case aubio_pitcht_specacf:
 …
       aubio_pitchyinfft_set_tolerance (p->p_object, tol);
       break;
+    case aubio_pitcht_yinfast:
+      aubio_pitchyinfast_set_tolerance (p->p_object, tol);
+      break;
     default:
       break;
 …
     case aubio_pitcht_yinfft:
       tolerance = aubio_pitchyinfft_get_tolerance (p->p_object);
+      break;
+    case aubio_pitcht_yinfast:
+      tolerance = aubio_pitchyinfast_get_tolerance (p->p_object);
       break;
     default:
 …
   aubio_pitch_slideblock (p, ibuf);
   aubio_pitchyinfft_do (p->p_object, p->buf, obuf);
+  pitch = obuf->data[0];
+  if (pitch > 0) {
+    pitch = p->samplerate / (pitch + 0.);
+  } else {
+    pitch = 0.;
+  }
+  obuf->data[0] = pitch;
+}
+void
+aubio_pitch_do_yinfast (aubio_pitch_t * p, const fvec_t * ibuf, fvec_t * obuf)
+{
+  smpl_t pitch = 0.;
+  aubio_pitch_slideblock (p, ibuf);
+  aubio_pitchyinfast_do (p->p_object, p->buf, obuf);
   pitch = obuf->data[0];
   if (pitch > 0) {

src/pitch/pitch.h

-                      r5b46bc3
+                      r633400d
   see http://recherche.ircam.fr/equipes/pcm/pub/people/cheveign.html
+  \b \p yinfast : Yinfast algorithm
+  This algorithm is equivalent to the YIN algorithm, but computed in the
+  spectral domain for efficiency. See also `python/demos/demo_yin_compare.py`.
   \b \p yinfft : Yinfft algorithm
 …
   \param mode set pitch units for output
+  mode can be one of "Hz", "midi", "cent", or "bin". Defaults to "Hz".
   \return 0 if successfull, non-zero otherwise

src/pitch/pitchfcomb.c

-                      r5b46bc3
+                      r633400d
   p->fftSize = bufsize;
   p->stepSize = hopsize;
+  p->fft = new_aubio_fft (bufsize);
+  if (!p->fft) goto beach;
   p->winput = new_fvec (bufsize);
   p->fftOut = new_cvec (bufsize);
   p->fftLastPhase = new_fvec (bufsize);
-  p->fft = new_aubio_fft (bufsize);
   p->win = new_aubio_window ("hanning", bufsize);
   return p;
+beach:
+  AUBIO_FREE(p);
+  return NULL;
+}

src/pitch/pitchmcomb.c

-                      r5b46bc3
+                      r633400d
  * sort_pitchpeak(peaks, length);
  */
+#if 0
 /** spectral_peak comparison function (must return signed int) */
 static sint_t aubio_pitchmcomb_sort_peak_comp (const void *x, const void *y);
 …
 uint_t aubio_pitch_cands (aubio_pitchmcomb_t * p, const cvec_t * fftgrain,
     smpl_t * cands);
+#endif
 /** sort spectral_candidate against their comb ene */
 void aubio_pitchmcomb_sort_cand_ene (aubio_spectralcandidate_t ** candidates,
     uint_t nbins);
+#if 0
 /** sort spectral_candidate against their frequency */
 void aubio_pitchmcomb_sort_cand_freq (aubio_spectralcandidate_t ** candidates,
     uint_t nbins);
+#endif
 struct _aubio_pitchmcomb_t
 …
+}
+#if 0
 uint_t
 aubio_pitch_cands (aubio_pitchmcomb_t * p, const cvec_t * fftgrain, smpl_t * cands)
 …
+  }
+}
+#endif
 void
 …
+}
+#if 0
 void
 aubio_pitchmcomb_sort_peak (aubio_spectralpeak_t * peaks, uint_t nbins)
 …
+}
 void
 aubio_pitchmcomb_sort_cand_freq (aubio_spectralcandidate_t ** candidates,
 …
+  }
+}
+#endif
 aubio_pitchmcomb_t *

src/pitch/pitchspecacf.c

-                      r5b46bc3
+                      r633400d
+{
   aubio_pitchspecacf_t *p = AUBIO_NEW (aubio_pitchspecacf_t);
+  p->fft = new_aubio_fft (bufsize);
+  if (!p->fft) goto beach;
   p->win = new_aubio_window ("hanningz", bufsize);
   p->winput = new_fvec (bufsize);
-  p->fft = new_aubio_fft (bufsize);
   p->fftout = new_fvec (bufsize);
   p->sqrmag = new_fvec (bufsize);
 …
   p->confidence = 0.;
   return p;
+beach:
+  AUBIO_FREE(p);
+  return NULL;
+}

src/pitch/pitchyin.c

-                      r5b46bc3
+                      r633400d
   fvec_t *yin;
   smpl_t tol;
   smpl_t confidence;
+  uint_t peak_pos;
 };
+#if 0
 /** compute difference function
 …
 */
 uint_t aubio_pitchyin_getpitch (const fvec_t * yinbuf);
+#endif
 aubio_pitchyin_t *
 …
   o->yin = new_fvec (bufsize / 2);
   o->tol = 0.15;
+  o->peak_pos = 0;
   return o;
+}
 …
+}
+#if 0
 /* outputs the difference function */
 void
 …
   return 0;
+}
+#endif
 /* all the above in one */
 …
 aubio_pitchyin_do (aubio_pitchyin_t * o, const fvec_t * input, fvec_t * out)
+{
+  smpl_t tol = o->tol;
+  fvec_t *yin = o->yin;
+  uint_t j, tau = 0;
+  const smpl_t tol = o->tol;
+  fvec_t* yin = o->yin;
+  const smpl_t *input_data = input->data;
+  const uint_t length = yin->length;
+  smpl_t *yin_data = yin->data;
+  uint_t j, tau;
   sint_t period;
+  smpl_t tmp = 0., tmp2 = 0.;
+  yin->data[0] = 1.;
+  for (tau = 1; tau < yin->length; tau++) {
+    yin->data[tau] = 0.;
+    for (j = 0; j < yin->length; j++) {
+      tmp = input->data[j] - input->data[j + tau];
+      yin->data[tau] += SQR (tmp);
+  smpl_t tmp, tmp2 = 0.;
+  yin_data[0] = 1.;
+  for (tau = 1; tau < length; tau++) {
+    yin_data[tau] = 0.;
+    for (j = 0; j < length; j++) {
+      tmp = input_data[j] - input_data[j + tau];
+      yin_data[tau] += SQR (tmp);
+    }
     tmp2 += yin->data[tau];
+    tmp2 += yin_data[tau];
     if (tmp2 != 0) {
       yin->data[tau] *= tau / tmp2;
 …
+    }
     period = tau - 3;
+    if (tau > 4 && (yin->data[period] < tol) &&
+        (yin->data[period] < yin->data[period + 1])) {
+      out->data[0] = fvec_quadratic_peak_pos (yin, period);
+      goto beach;
+    if (tau > 4 && (yin_data[period] < tol) &&
+        (yin_data[period] < yin_data[period + 1])) {
+      o->peak_pos = (uint_t)period;
+      out->data[0] = fvec_quadratic_peak_pos (yin, o->peak_pos);
+      return;
+    }
+  }
+  out->data[0] = fvec_quadratic_peak_pos (yin, fvec_min_elem (yin));
+beach:
+  return;
+  o->peak_pos = (uint_t)fvec_min_elem (yin);
+  out->data[0] = fvec_quadratic_peak_pos (yin, o->peak_pos);
+}
 smpl_t
 aubio_pitchyin_get_confidence (aubio_pitchyin_t * o) {
+  o->confidence = 1. - fvec_min (o->yin);
+  return o->confidence;
+  return 1. - o->yin->data[o->peak_pos];
+}

src/pitch/pitchyinfft.c

-                      r5b46bc3
+                      r633400d
   fvec_t *yinfft;     /**< Yin function */
   smpl_t tol;         /**< Yin tolerance */
   smpl_t confidence;  /**< confidence */
+  uint_t peak_pos;    /**< currently selected peak pos*/
   uint_t short_period; /** shortest period under which to check for octave error */
 };
 …
 .,   200.,   250.,   315.,   400.,   500.,   630.,   800.,  1000.,  1250.,
 .,  2000.,  2500.,  3150.,  4000.,  5000.,  6300.,  8000.,  9000., 10000.,
 ., 15000., 20000., 25100
+., 15000., 20000., 25100., -1.
 };
 …
   p->winput = new_fvec (bufsize);
   p->fft = new_aubio_fft (bufsize);
+  if (!p->fft) goto beach;
   p->fftout = new_fvec (bufsize);
   p->sqrmag = new_fvec (bufsize);
   p->yinfft = new_fvec (bufsize / 2 + 1);
   p->tol = 0.85;
+  p->peak_pos = 0;
   p->win = new_aubio_window ("hanningz", bufsize);
   p->weight = new_fvec (bufsize / 2 + 1);
   for (i = 0; i < p->weight->length; i++) {
     freq = (smpl_t) i / (smpl_t) bufsize *(smpl_t) samplerate;
+    while (freq > freqs[j]) {
+    while (freq > freqs[j] && freqs[j] > 0) {
+      //AUBIO_DBG("freq %3.5f > %3.5f \tsamplerate %d (Hz) \t"
+      //    "(weight length %d, bufsize %d) %d %d\n", freq, freqs[j],
+      //    samplerate, p->weight->length, bufsize, i, j);
       j += 1;
+    }
 …
   p->short_period = (uint_t)ROUND(samplerate / 1300.);
   return p;
+beach:
+  if (p->winput) del_fvec(p->winput);
+  AUBIO_FREE(p);
+  return NULL;
+}
 …
       halfperiod = FLOOR (tau / 2 + .5);
       if (yin->data[halfperiod] < p->tol)
         output->data[0] = fvec_quadratic_peak_pos (yin, halfperiod);
+        p->peak_pos = halfperiod;
       else
+        output->data[0] = fvec_quadratic_peak_pos (yin, tau);
+        p->peak_pos = tau;
+      output->data[0] = fvec_quadratic_peak_pos (yin, p->peak_pos);
+    }
   } else {
+    p->peak_pos = 0;
     output->data[0] = 0.;
+  }
 …
 smpl_t
 aubio_pitchyinfft_get_confidence (aubio_pitchyinfft_t * o) {
+  o->confidence = 1. - fvec_min (o->yinfft);
+  return o->confidence;
+  return 1. - o->yinfft->data[o->peak_pos];
+}

src/spectral/fft.c

-                      r5b46bc3
+                      r633400d
 pthread_mutex_t aubio_fftw_mutex = PTHREAD_MUTEX_INITIALIZER;
+#else
+#ifdef HAVE_ACCELERATE        // using ACCELERATE
+#elif defined HAVE_ACCELERATE        // using ACCELERATE
 // https://developer.apple.com/library/mac/#documentation/Accelerate/Reference/vDSPRef/Reference/reference.html
 #include <Accelerate/Accelerate.h>
 …
 #define aubio_vDSP_vsadd               vDSP_vsadd
 #define aubio_vDSP_vsmul               vDSP_vsmul
-#define aubio_vDSP_create_fftsetup     vDSP_create_fftsetup
-#define aubio_vDSP_destroy_fftsetup    vDSP_destroy_fftsetup
 #define aubio_DSPComplex               DSPComplex
 #define aubio_DSPSplitComplex          DSPSplitComplex
+#define aubio_FFTSetup                 FFTSetup
+#define aubio_vDSP_DFT_Setup           vDSP_DFT_Setup
+#define aubio_vDSP_DFT_zrop_CreateSetup vDSP_DFT_zrop_CreateSetup
+#define aubio_vDSP_DFT_Execute         vDSP_DFT_Execute
+#define aubio_vDSP_DFT_DestroySetup    vDSP_DFT_DestroySetup
 #define aubio_vvsqrt                   vvsqrtf
 #else
 …
 #define aubio_vDSP_vsadd               vDSP_vsaddD
 #define aubio_vDSP_vsmul               vDSP_vsmulD
-#define aubio_vDSP_create_fftsetup     vDSP_create_fftsetupD
-#define aubio_vDSP_destroy_fftsetup    vDSP_destroy_fftsetupD
 #define aubio_DSPComplex               DSPDoubleComplex
 #define aubio_DSPSplitComplex          DSPDoubleSplitComplex
+#define aubio_FFTSetup                 FFTSetupD
+#define aubio_vDSP_DFT_Setup           vDSP_DFT_SetupD
+#define aubio_vDSP_DFT_zrop_CreateSetup vDSP_DFT_zrop_CreateSetupD
+#define aubio_vDSP_DFT_Execute         vDSP_DFT_ExecuteD
+#define aubio_vDSP_DFT_DestroySetup    vDSP_DFT_DestroySetupD
 #define aubio_vvsqrt                   vvsqrt
 #endif /* HAVE_AUBIO_DOUBLE */
+#else                         // using OOURA
+#elif defined HAVE_INTEL_IPP // using INTEL IPP
+#if !HAVE_AUBIO_DOUBLE
+#define aubio_IppFloat                 Ipp32f
+#define aubio_IppComplex               Ipp32fc
+#define aubio_FFTSpec                  FFTSpec_R_32f
+#define aubio_ippsMalloc_complex       ippsMalloc_32fc
+#define aubio_ippsFFTInit_R            ippsFFTInit_R_32f
+#define aubio_ippsFFTGetSize_R         ippsFFTGetSize_R_32f
+#define aubio_ippsFFTInv_CCSToR        ippsFFTInv_CCSToR_32f
+#define aubio_ippsFFTFwd_RToCCS        ippsFFTFwd_RToCCS_32f
+#define aubio_ippsAtan2                ippsAtan2_32f_A21
+#else /* HAVE_AUBIO_DOUBLE */
+#define aubio_IppFloat                 Ipp64f
+#define aubio_IppComplex               Ipp64fc
+#define aubio_FFTSpec                  FFTSpec_R_64f
+#define aubio_ippsMalloc_complex       ippsMalloc_64fc
+#define aubio_ippsFFTInit_R            ippsFFTInit_R_64f
+#define aubio_ippsFFTGetSize_R         ippsFFTGetSize_R_64f
+#define aubio_ippsFFTInv_CCSToR        ippsFFTInv_CCSToR_64f
+#define aubio_ippsFFTFwd_RToCCS        ippsFFTFwd_RToCCS_64f
+#define aubio_ippsAtan2                ippsAtan2_64f_A50
+#endif
+#else // using OOURA
 // let's use ooura instead
 extern void aubio_ooura_rdft(int, int, smpl_t *, int *, smpl_t *);
+#endif /* HAVE_ACCELERATE */
+#endif /* HAVE_FFTW3 */
+#endif
 struct _aubio_fft_t {
   uint_t winsize;
   uint_t fft_size;
 #ifdef HAVE_FFTW3             // using FFTW3
   real_t *in, *out;
   fftw_plan pfw, pbw;
   fft_data_t * specdata;      /* complex spectral data */
+#else
 #ifdef HAVE_ACCELERATE        // using ACCELERATE
   int log2fftsize;
   aubio_FFTSetup fftSetup;
+  fft_data_t * specdata; /* complex spectral data */
+#elif defined HAVE_ACCELERATE  // using ACCELERATE
+  aubio_vDSP_DFT_Setup fftSetupFwd;
+  aubio_vDSP_DFT_Setup fftSetupBwd;
   aubio_DSPSplitComplex spec;
   smpl_t *in, *out;
+#elif defined HAVE_INTEL_IPP  // using Intel IPP
+  smpl_t *in, *out;
+  Ipp8u* memSpec;
+  Ipp8u* memInit;
+  Ipp8u* memBuffer;
+  struct aubio_FFTSpec* fftSpec;
+  aubio_IppComplex* complexOut;
 #else                         // using OOURA
   smpl_t *in, *out;
   smpl_t *w;
   int *ip;
 #endif /* HAVE_ACCELERATE */
+#endif /* HAVE_FFTW3 */
+#endif /* using OOURA */
   fvec_t * compspec;
 };
 …
     goto beach;
+  }
 #ifdef HAVE_FFTW3
   uint_t i;
 …
     s->specdata[i] = 0.;
+  }
+#else
+#ifdef HAVE_ACCELERATE        // using ACCELERATE
+#elif defined HAVE_ACCELERATE  // using ACCELERATE
+  {
+    uint_t radix = winsize;
+    uint_t order = 0;
+    while ((radix / 2) * 2 == radix) {
+      radix /= 2;
+      order++;
+    }
+    if (order < 4 || (radix != 1 && radix != 3 && radix != 5 && radix != 15)) {
+      AUBIO_ERR("fft: vDSP/Accelerate supports FFT with sizes = "
+          "f * 2 ** n, where n > 4 and f in [1, 3, 5, 15], but requested %d. "
+          "Use the closest power of two, or try recompiling aubio with "
+          "--enable-fftw3.\n", winsize);
+      goto beach;
+    }
+  }
   s->winsize = winsize;
   s->fft_size = winsize;
   s->compspec = new_fvec(winsize);
-  s->log2fftsize = (uint_t)log2f(s->fft_size);
   s->in = AUBIO_ARRAY(smpl_t, s->fft_size);
   s->out = AUBIO_ARRAY(smpl_t, s->fft_size);
   s->spec.realp = AUBIO_ARRAY(smpl_t, s->fft_size/2);
   s->spec.imagp = AUBIO_ARRAY(smpl_t, s->fft_size/2);
+  s->fftSetup = aubio_vDSP_create_fftsetup(s->log2fftsize, FFT_RADIX2);
+  s->fftSetupFwd = aubio_vDSP_DFT_zrop_CreateSetup(NULL,
+      s->fft_size, vDSP_DFT_FORWARD);
+  s->fftSetupBwd = aubio_vDSP_DFT_zrop_CreateSetup(s->fftSetupFwd,
+      s->fft_size, vDSP_DFT_INVERSE);
+#elif defined HAVE_INTEL_IPP  // using Intel IPP
+  const IppHintAlgorithm qualityHint = ippAlgHintAccurate; // OR ippAlgHintFast;
+  const int flags = IPP_FFT_NODIV_BY_ANY; // we're scaling manually afterwards
+  int order = aubio_power_of_two_order(winsize);
+  int sizeSpec, sizeInit, sizeBuffer;
+  IppStatus status;
+  if (winsize <= 4 || aubio_is_power_of_two(winsize) != 1)
+  {
+    AUBIO_ERR("intel IPP fft: can only create with sizes > 4 and power of two, requested %d,"
+      " try recompiling aubio with --enable-fftw3\n", winsize);
+    goto beach;
+  }
+  status = aubio_ippsFFTGetSize_R(order, flags, qualityHint,
+      &sizeSpec, &sizeInit, &sizeBuffer);
+  if (status != ippStsNoErr) {
+    AUBIO_ERR("fft: failed to initialize fft. IPP error: %d\n", status);
+    goto beach;
+  }
+  s->fft_size = s->winsize = winsize;
+  s->compspec = new_fvec(winsize);
+  s->in = AUBIO_ARRAY(smpl_t, s->winsize);
+  s->out = AUBIO_ARRAY(smpl_t, s->winsize);
+  s->memSpec = ippsMalloc_8u(sizeSpec);
+  s->memBuffer = ippsMalloc_8u(sizeBuffer);
+  if (sizeInit > 0 ) {
+    s->memInit = ippsMalloc_8u(sizeInit);
+  }
+  s->complexOut = aubio_ippsMalloc_complex(s->fft_size / 2 + 1);
+  status = aubio_ippsFFTInit_R(
+    &s->fftSpec, order, flags, qualityHint, s->memSpec, s->memInit);
+  if (status != ippStsNoErr) {
+    AUBIO_ERR("fft: failed to initialize. IPP error: %d\n", status);
+    goto beach;
+  }
 #else                         // using OOURA
   if (aubio_is_power_of_two(winsize) != 1) {
 …
   s->w     = AUBIO_ARRAY(smpl_t, s->fft_size);
   s->ip[0] = 0;
 #endif /* HAVE_ACCELERATE */
+#endif /* HAVE_FFTW3 */
+#endif /* using OOURA */
   return s;
 beach:
   AUBIO_FREE(s);
 …
 void del_aubio_fft(aubio_fft_t * s) {
   /* destroy data */
-  del_fvec(s->compspec);
 #ifdef HAVE_FFTW3             // using FFTW3
   pthread_mutex_lock(&aubio_fftw_mutex);
 …
   fftw_free(s->specdata);
   pthread_mutex_unlock(&aubio_fftw_mutex);
+#else /* HAVE_FFTW3 */
 #ifdef HAVE_ACCELERATE        // using ACCELERATE
+#elif defined HAVE_ACCELERATE // using ACCELERATE
   AUBIO_FREE(s->spec.realp);
   AUBIO_FREE(s->spec.imagp);
+  aubio_vDSP_destroy_fftsetup(s->fftSetup);
+  aubio_vDSP_DFT_DestroySetup(s->fftSetupBwd);
+  aubio_vDSP_DFT_DestroySetup(s->fftSetupFwd);
+#elif defined HAVE_INTEL_IPP  // using Intel IPP
+  ippFree(s->memSpec);
+  ippFree(s->memInit);
+  ippFree(s->memBuffer);
+  ippFree(s->complexOut);
 #else                         // using OOURA
   AUBIO_FREE(s->w);
   AUBIO_FREE(s->ip);
+#endif /* HAVE_ACCELERATE */
+#endif /* HAVE_FFTW3 */
+#endif
+  del_fvec(s->compspec);
+  AUBIO_FREE(s->in);
   AUBIO_FREE(s->out);
-  AUBIO_FREE(s->in);
   AUBIO_FREE(s);
+}
 …
   memcpy(s->in, input->data, s->winsize * sizeof(smpl_t));
 #endif /* HAVE_MEMCPY_HACKS */
 #ifdef HAVE_FFTW3             // using FFTW3
   fftw_execute(s->pfw);
 …
+  }
 #endif /* HAVE_COMPLEX_H */
+#else /* HAVE_FFTW3 */
 #ifdef HAVE_ACCELERATE        // using ACCELERATE
+#elif defined HAVE_ACCELERATE // using ACCELERATE
   // convert real data to even/odd format used in vDSP
   aubio_vDSP_ctoz((aubio_DSPComplex*)s->in, 2, &s->spec, 1, s->fft_size/2);
   // compute the FFT
+  aubio_vDSP_fft_zrip(s->fftSetup, &s->spec, 1, s->log2fftsize, FFT_FORWARD);
+  aubio_vDSP_DFT_Execute(s->fftSetupFwd, s->spec.realp, s->spec.imagp,
+      s->spec.realp, s->spec.imagp);
   // convert from vDSP complex split to [ r0, r1, ..., rN, iN-1, .., i2, i1]
   compspec->data[0] = s->spec.realp[0];
 …
   smpl_t scale = 1./2.;
   aubio_vDSP_vsmul(compspec->data, 1, &scale, compspec->data, 1, s->fft_size);
+#elif defined HAVE_INTEL_IPP  // using Intel IPP
+  // apply fft
+  aubio_ippsFFTFwd_RToCCS(s->in, (aubio_IppFloat*)s->complexOut, s->fftSpec, s->memBuffer);
+  // convert complex buffer to [ r0, r1, ..., rN, iN-1, .., i2, i1]
+  compspec->data[0] = s->complexOut[0].re;
+  compspec->data[s->fft_size / 2] = s->complexOut[s->fft_size / 2].re;
+  for (i = 1; i < s->fft_size / 2; i++) {
+    compspec->data[i] = s->complexOut[i].re;
+    compspec->data[s->fft_size - i] = s->complexOut[i].im;
+  }
 #else                         // using OOURA
   aubio_ooura_rdft(s->winsize, 1, s->in, s->ip, s->w);
 …
     compspec->data[s->winsize - i] = - s->in[2 * i + 1];
+  }
+#endif /* HAVE_ACCELERATE */
+#endif /* HAVE_FFTW3 */
+#endif /* using OOURA */
+}
 …
     output->data[i] = s->out[i]*renorm;
+  }
+#else /* HAVE_FFTW3 */
 #ifdef HAVE_ACCELERATE        // using ACCELERATE
+#elif defined HAVE_ACCELERATE // using ACCELERATE
   // convert from real imag  [ r0, r1, ..., rN, iN-1, .., i2, i1]
   // to vDSP packed format   [ r0, rN, r1, i1, ..., rN-1, iN-1 ]
 …
   aubio_vDSP_ctoz((aubio_DSPComplex*)s->out, 2, &s->spec, 1, s->fft_size/2);
   // compute the FFT
+  aubio_vDSP_fft_zrip(s->fftSetup, &s->spec, 1, s->log2fftsize, FFT_INVERSE);
+  aubio_vDSP_DFT_Execute(s->fftSetupBwd, s->spec.realp, s->spec.imagp,
+      s->spec.realp, s->spec.imagp);
   // convert result to real output
   aubio_vDSP_ztoc(&s->spec, 1, (aubio_DSPComplex*)output->data, 2, s->fft_size/2);
 …
   smpl_t scale = 1.0 / s->winsize;
   aubio_vDSP_vsmul(output->data, 1, &scale, output->data, 1, s->fft_size);
+#elif defined HAVE_INTEL_IPP  // using Intel IPP
+  // convert from real imag  [ r0, 0, ..., rN, iN-1, .., i2, i1, iN-1] to complex format
+  s->complexOut[0].re = compspec->data[0];
+  s->complexOut[0].im = 0;
+  s->complexOut[s->fft_size / 2].re = compspec->data[s->fft_size / 2];
+  s->complexOut[s->fft_size / 2].im = 0.0;
+  for (i = 1; i < s->fft_size / 2; i++) {
+    s->complexOut[i].re = compspec->data[i];
+    s->complexOut[i].im = compspec->data[s->fft_size - i];
+  }
+  // apply fft
+  aubio_ippsFFTInv_CCSToR((const aubio_IppFloat *)s->complexOut, output->data, s->fftSpec, s->memBuffer);
+  // apply scaling
+  aubio_ippsMulC(output->data, 1.0 / s->winsize, output->data, s->fft_size);
 #else                         // using OOURA
   smpl_t scale = 2.0 / s->winsize;
 …
     output->data[i] = s->out[i] * scale;
+  }
+#endif /* HAVE_ACCELERATE */
+#endif /* HAVE_FFTW3 */
+#endif
+}
 …
     spectrum->phas[0] = 0.;
+  }
+#if defined(HAVE_INTEL_IPP)
+  // convert from real imag  [ r0, r1, ..., rN, iN-1, ..., i2, i1, i0]
+  //                     to  [ r0, r1, ..., rN, i0, i1, i2, ..., iN-1]
+  for (i = 1; i < spectrum->length / 2; i++) {
+    ELEM_SWAP(compspec->data[compspec->length - i],
+        compspec->data[spectrum->length + i - 1]);
+  }
+  aubio_ippsAtan2(compspec->data + spectrum->length,
+      compspec->data + 1, spectrum->phas + 1, spectrum->length - 1);
+  // revert the imaginary part back again
+  for (i = 1; i < spectrum->length / 2; i++) {
+    ELEM_SWAP(compspec->data[spectrum->length + i - 1],
+        compspec->data[compspec->length - i]);
+  }
+#else
   for (i=1; i < spectrum->length - 1; i++) {
     spectrum->phas[i] = ATAN2(compspec->data[compspec->length-i],
         compspec->data[i]);
+  }
+  if (compspec->data[compspec->length/2] < 0) {
+    spectrum->phas[spectrum->length - 1] = PI;
+#endif
+#ifdef HAVE_FFTW3
+  // for even length only, make sure last element is 0 or PI
+  if (2 * (compspec->length / 2) == compspec->length) {
+#endif
+    if (compspec->data[compspec->length/2] < 0) {
+      spectrum->phas[spectrum->length - 1] = PI;
+    } else {
+      spectrum->phas[spectrum->length - 1] = 0.;
+    }
+#ifdef HAVE_FFTW3
   } else {
+    spectrum->phas[spectrum->length - 1] = 0.;
+  }
+    i = spectrum->length - 1;
+    spectrum->phas[i] = ATAN2(compspec->data[compspec->length-i],
+        compspec->data[i]);
+  }
+#endif
+}
 …
         + SQR(compspec->data[compspec->length - i]) );
+  }
+  spectrum->norm[spectrum->length-1] =
+    ABS(compspec->data[compspec->length/2]);
+#ifdef HAVE_FFTW3
+  // for even length, make sure last element is > 0
+  if (2 * (compspec->length / 2) == compspec->length) {
+#endif
+    spectrum->norm[spectrum->length-1] =
+      ABS(compspec->data[compspec->length/2]);
+#ifdef HAVE_FFTW3
+  } else {
+    i = spectrum->length - 1;
+    spectrum->norm[i] = SQRT(SQR(compspec->data[i])
+        + SQR(compspec->data[compspec->length - i]) );
+  }
+#endif
+}

src/spectral/filterbank.c

-                      r5b46bc3
+                      r633400d
 #include "fmat.h"
 #include "cvec.h"
+#include "vecutils.h"
 #include "spectral/filterbank.h"
 #include "mathutils.h"
 …
   uint_t n_filters;
   fmat_t *filters;
+  smpl_t norm;
+  smpl_t power;
 };
 …
   /* allocate space for filterbank object */
   aubio_filterbank_t *fb = AUBIO_NEW (aubio_filterbank_t);
+  if ((sint_t)n_filters <= 0) {
+    AUBIO_ERR("filterbank: n_filters should be > 0, got %d\n", n_filters);
+    goto fail;
+  }
+  if ((sint_t)win_s <= 0) {
+    AUBIO_ERR("filterbank: win_s should be > 0, got %d\n", win_s);
+    goto fail;
+  }
   fb->win_s = win_s;
   fb->n_filters = n_filters;
 …
   fb->filters = new_fmat (n_filters, win_s / 2 + 1);
+  fb->norm = 1;
+  fb->power = 1;
   return fb;
+fail:
+  AUBIO_FREE (fb);
+  return NULL;
+}
 …
   tmp.data = in->norm;
+  if (f->power != 1.) fvec_pow(&tmp, f->power);
   fmat_vecmul(f->filters, &tmp, out);
 …
   return 0;
+}
+uint_t
+aubio_filterbank_set_norm (aubio_filterbank_t *f, smpl_t norm)
+{
+  if (norm != 0 && norm != 1) return AUBIO_FAIL;
+  f->norm = norm;
+  return AUBIO_OK;
+}
+smpl_t
+aubio_filterbank_get_norm (aubio_filterbank_t *f)
+{
+  return f->norm;
+}
+uint_t
+aubio_filterbank_set_power (aubio_filterbank_t *f, smpl_t power)
+{
+  f->power = power;
+  return AUBIO_OK;
+}
+smpl_t
+aubio_filterbank_get_power (aubio_filterbank_t *f)
+{
+  return f->power;
+}

src/spectral/filterbank.h

-                      r5b46bc3
+                      r633400d
 uint_t aubio_filterbank_set_coeffs (aubio_filterbank_t * f, const fmat_t * filters);
+/** set norm parameter
+  \param f filterbank object, as returned by new_aubio_filterbank()
+  \param norm `1` to norm the filters, `0` otherwise.
+  If set to `0`, the filters will not be normalized. If set to `1`,
+  each filter will be normalized to one. Defaults to `1`.
+  This function should be called *before* setting the filters with one of
+  aubio_filterbank_set_triangle_bands(), aubio_filterbank_set_mel_coeffs(),
+  aubio_filterbank_set_mel_coeffs_htk(), or
+  aubio_filterbank_set_mel_coeffs_slaney().
+ */
+uint_t aubio_filterbank_set_norm (aubio_filterbank_t *f, smpl_t norm);
+/** get norm parameter
+  \param f filterbank object, as returned by new_aubio_filterbank()
+  \returns `1` if norm is set, `0` otherwise. Defaults to `1`.
+ */
+smpl_t aubio_filterbank_get_norm (aubio_filterbank_t *f);
+/** set power parameter
+  \param f filterbank object, as returned by new_aubio_filterbank()
+  \param power Raise norm of the input spectrum norm to this power before
+  computing filterbank.  Defaults to `1`.
+ */
+uint_t aubio_filterbank_set_power (aubio_filterbank_t *f, smpl_t power);
+/** get power parameter
+  \param f filterbank object, as returned by new_aubio_filterbank()
+  \return current power parameter. Defaults to `1`.
+ */
+smpl_t aubio_filterbank_get_power (aubio_filterbank_t *f);
 #ifdef __cplusplus
+}

src/spectral/filterbank_mel.c

-                      r5b46bc3
+                      r633400d
+  }
+  if (freqs->data[freqs->length - 1] > samplerate / 2) {
+    AUBIO_WRN ("Nyquist frequency is %fHz, but highest frequency band ends at \
+%fHz\n", samplerate / 2, freqs->data[freqs->length - 1]);
+  for (fn = 0; fn < freqs->length; fn++) {
+    if (freqs->data[fn] < 0) {
+      AUBIO_ERR("filterbank_mel: freqs must contain only positive values.\n");
+      return AUBIO_FAIL;
+    } else if (freqs->data[fn] > samplerate / 2) {
+      AUBIO_WRN("filterbank_mel: freqs should contain only "
+          "values < samplerate / 2.\n");
+    } else if (fn > 0 && freqs->data[fn] < freqs->data[fn-1]) {
+      AUBIO_ERR("filterbank_mel: freqs should be a list of frequencies "
+          "sorted from low to high, but freq[%d] < freq[%d-1]\n", fn, fn);
+      return AUBIO_FAIL;
+    } else if (fn > 0 && freqs->data[fn] == freqs->data[fn-1]) {
+      AUBIO_WRN("filterbank_mel: set_triangle_bands received a list "
+          "with twice the frequency %f\n", freqs->data[fn]);
+    }
+  }
 …
   /* compute triangle heights so that each triangle has unit area */
+  for (fn = 0; fn < n_filters; fn++) {
+    triangle_heights->data[fn] =
+. / (upper_freqs->data[fn] - lower_freqs->data[fn]);
+  if (aubio_filterbank_get_norm(fb)) {
+    for (fn = 0; fn < n_filters; fn++) {
+      triangle_heights->data[fn] =
+. / (upper_freqs->data[fn] - lower_freqs->data[fn]);
+    }
+  } else {
+    fvec_ones (triangle_heights);
+  }
 …
   /* zeroing of all filters */
   fmat_zeros (filters);
-  if (fft_freqs->data[1] >= lower_freqs->data[0]) {
-    /* - 1 to make sure we don't miss the smallest power of two */
-    uint_t min_win_s =
-        (uint_t) FLOOR (samplerate / lower_freqs->data[0]) - 1;
-    AUBIO_WRN ("Lowest frequency bin (%.2fHz) is higher than lowest frequency \
-band (%.2f-%.2fHz). Consider increasing the window size from %d to %d.\n",
-        fft_freqs->data[1], lower_freqs->data[0],
-        upper_freqs->data[0], (win_s - 1) * 2,
-        aubio_next_power_of_two (min_win_s));
+  }
   /* building each filter table */
 …
     /* compute positive slope step size */
+    riseInc =
+        triangle_heights->data[fn] /
+        (center_freqs->data[fn] - lower_freqs->data[fn]);
+    riseInc = triangle_heights->data[fn]
+      / (center_freqs->data[fn] - lower_freqs->data[fn]);
     /* compute coefficients in positive slope */
 …
     /* compute negative slope step size */
+    downInc =
+        triangle_heights->data[fn] /
+        (upper_freqs->data[fn] - center_freqs->data[fn]);
+    downInc = triangle_heights->data[fn]
+      / (upper_freqs->data[fn] - center_freqs->data[fn]);
     /* compute coefficents in negative slope */
 …
   del_fvec (fft_freqs);
   return 0;
+  return AUBIO_OK;
+}
 …
     smpl_t samplerate)
+{
-  uint_t retval;
   /* Malcolm Slaney parameters */
+  smpl_t lowestFrequency = 133.3333;
+  smpl_t linearSpacing = 66.66666666;
+  smpl_t logSpacing = 1.0711703;
+  uint_t linearFilters = 13;
+  uint_t logFilters = 27;
+  uint_t n_filters = linearFilters + logFilters;
+  uint_t fn;                    /* filter counter */
+  const smpl_t lowestFrequency = 133.3333;
+  const smpl_t linearSpacing = 66.66666666;
+  const smpl_t logSpacing = 1.0711703;
+  const uint_t linearFilters = 13;
+  const uint_t logFilters = 27;
+  const uint_t n_filters = linearFilters + logFilters;
+  uint_t fn, retval;
   smpl_t lastlinearCF;
   /* buffers to compute filter frequencies */
+  fvec_t *freqs = new_fvec (n_filters + 2);
+  fvec_t *freqs;
+  if (samplerate <= 0) {
+    AUBIO_ERR("filterbank: set_mel_coeffs_slaney samplerate should be > 0\n");
+    return AUBIO_FAIL;
+  }
+  freqs = new_fvec (n_filters + 2);
   /* first step: fill all the linear filter frequencies */
 …
   return retval;
+}
+static uint_t aubio_filterbank_check_freqs (aubio_filterbank_t *fb UNUSED,
+    smpl_t samplerate, smpl_t *freq_min, smpl_t *freq_max)
+{
+  if (samplerate <= 0) {
+    AUBIO_ERR("filterbank: set_mel_coeffs samplerate should be > 0\n");
+    return AUBIO_FAIL;
+  }
+  if (*freq_max < 0) {
+    AUBIO_ERR("filterbank: set_mel_coeffs freq_max should be > 0\n");
+    return AUBIO_FAIL;
+  } else if (*freq_max == 0) {
+    *freq_max = samplerate / 2.;
+  }
+  if (*freq_min < 0) {
+    AUBIO_ERR("filterbank: set_mel_coeffs freq_min should be > 0\n");
+    return AUBIO_FAIL;
+  }
+  return AUBIO_OK;
+}
+uint_t
+aubio_filterbank_set_mel_coeffs (aubio_filterbank_t * fb, smpl_t samplerate,
+    smpl_t freq_min, smpl_t freq_max)
+{
+  uint_t m, retval;
+  smpl_t start = freq_min, end = freq_max, step;
+  fvec_t *freqs;
+  fmat_t *coeffs = aubio_filterbank_get_coeffs(fb);
+  uint_t n_bands = coeffs->height;
+  if (aubio_filterbank_check_freqs(fb, samplerate, &start, &end)) {
+    return AUBIO_FAIL;
+  }
+  start = aubio_hztomel(start);
+  end = aubio_hztomel(end);
+  freqs = new_fvec(n_bands + 2);
+  step = (end - start) / (n_bands + 1);
+  for (m = 0; m < n_bands + 2; m++)
+  {
+    freqs->data[m] = MIN(aubio_meltohz(start + step * m), samplerate/2.);
+  }
+  retval = aubio_filterbank_set_triangle_bands (fb, freqs, samplerate);
+  /* destroy vector used to store frequency limits */
+  del_fvec (freqs);
+  return retval;
+}
+uint_t
+aubio_filterbank_set_mel_coeffs_htk (aubio_filterbank_t * fb, smpl_t samplerate,
+    smpl_t freq_min, smpl_t freq_max)
+{
+  uint_t m, retval;
+  smpl_t start = freq_min, end = freq_max, step;
+  fvec_t *freqs;
+  fmat_t *coeffs = aubio_filterbank_get_coeffs(fb);
+  uint_t n_bands = coeffs->height;
+  if (aubio_filterbank_check_freqs(fb, samplerate, &start, &end)) {
+    return AUBIO_FAIL;
+  }
+  start = aubio_hztomel_htk(start);
+  end = aubio_hztomel_htk(end);
+  freqs = new_fvec (n_bands + 2);
+  step = (end - start) / (n_bands + 1);
+  for (m = 0; m < n_bands + 2; m++)
+  {
+    freqs->data[m] = MIN(aubio_meltohz_htk(start + step * m), samplerate/2.);
+  }
+  retval = aubio_filterbank_set_triangle_bands (fb, freqs, samplerate);
+  /* destroy vector used to store frequency limits */
+  del_fvec (freqs);
+  return retval;
+}

src/spectral/filterbank_mel.h

-                      r5b46bc3
+                      r633400d
   \param fb filterbank object
   \param samplerate audio sampling rate
+  \param samplerate audio sampling rate, in Hz
+  The filter coefficients are built according to Malcolm Slaney's Auditory
+  Toolbox, available at http://engineering.purdue.edu/~malcolm/interval/1998-010/
+  (see file mfcc.m).
+  The filter coefficients are built to match exactly Malcolm Slaney's Auditory
+  Toolbox implementation (see file mfcc.m). The number of filters should be 40.
+  References
+  ----------
+  Malcolm Slaney, *Auditory Toolbox Version 2, Technical Report #1998-010*
+  https://engineering.purdue.edu/~malcolm/interval/1998-010/
 */
 uint_t aubio_filterbank_set_mel_coeffs_slaney (aubio_filterbank_t * fb,
     smpl_t samplerate);
+/** Mel filterbank initialization
+  \param fb filterbank object
+  \param samplerate audio sampling rate
+  \param fmin start frequency, in Hz
+  \param fmax end frequency, in Hz
+  The filterbank will be initialized with bands linearly spaced in the mel
+  scale, from `fmin` to `fmax`.
+  References
+  ----------
+  Malcolm Slaney, *Auditory Toolbox Version 2, Technical Report #1998-010*
+  https://engineering.purdue.edu/~malcolm/interval/1998-010/
+*/
+uint_t aubio_filterbank_set_mel_coeffs(aubio_filterbank_t * fb,
+    smpl_t samplerate, smpl_t fmin, smpl_t fmax);
+/** Mel filterbank initialization
+  \param fb filterbank object
+  \param samplerate audio sampling rate
+  \param fmin start frequency, in Hz
+  \param fmax end frequency, in Hz
+  The bank of filters will be initalized to to cover linearly spaced bands in
+  the Htk mel scale, from `fmin` to `fmax`.
+  References
+  ----------
+  Douglas O'Shaughnessy (1987). *Speech communication: human and machine*.
+  Addison-Wesley. p. 150. ISBN 978-0-201-16520-3.
+  HTK Speech Recognition Toolkit: http://htk.eng.cam.ac.uk/
+*/
+uint_t aubio_filterbank_set_mel_coeffs_htk(aubio_filterbank_t * fb,
+    smpl_t samplerate, smpl_t fmin, smpl_t fmax);
 #ifdef __cplusplus

src/spectral/mfcc.c

-                      r5b46bc3
+                      r633400d
 #include "spectral/filterbank.h"
 #include "spectral/filterbank_mel.h"
+#include "spectral/dct.h"
 #include "spectral/mfcc.h"
 …
   uint_t win_s;             /** grain length */
   uint_t samplerate;        /** sample rate (needed?) */
   uint_t n_filters;         /** number of  *filters */
+  uint_t n_filters;         /** number of filters */
   uint_t n_coefs;           /** number of coefficients (<= n_filters/2 +1) */
   aubio_filterbank_t *fb;   /** filter bank */
   fvec_t *in_dct;           /** input buffer for dct * [fb->n_filters] */
+  fmat_t *dct_coeffs;       /** DCT transform n_filters * n_coeffs */
+  aubio_dct_t *dct;         /** dct object */
+  fvec_t *output;           /** dct output */
+  smpl_t scale;
 };
 …
   /* allocate space for mfcc object */
   aubio_mfcc_t *mfcc = AUBIO_NEW (aubio_mfcc_t);
-  smpl_t scaling;
+  uint_t i, j;
+  if ((sint_t)n_coefs <= 0) {
+    AUBIO_ERR("mfcc: n_coefs should be > 0, got %d\n", n_coefs);
+    goto failure;
+  }
+  if ((sint_t)samplerate <= 0) {
+    AUBIO_ERR("mfcc: samplerate should be > 0, got %d\n", samplerate);
+    goto failure;
+  }
   mfcc->win_s = win_s;
 …
   /* filterbank allocation */
   mfcc->fb = new_aubio_filterbank (n_filters, mfcc->win_s);
+  aubio_filterbank_set_mel_coeffs_slaney (mfcc->fb, samplerate);
+  if (!mfcc->fb)
+    goto failure;
+  if (n_filters == 40)
+    aubio_filterbank_set_mel_coeffs_slaney (mfcc->fb, samplerate);
+  else
+    aubio_filterbank_set_mel_coeffs(mfcc->fb, samplerate,
+, samplerate/2.);
   /* allocating buffers */
   mfcc->in_dct = new_fvec (n_filters);
+  mfcc->dct_coeffs = new_fmat (n_coefs, n_filters);
+  mfcc->dct = new_aubio_dct (n_filters);
+  mfcc->output = new_fvec (n_filters);
+  /* compute DCT transform dct_coeffs[j][i] as
+     cos ( j * (i+.5) * PI / n_filters ) */
+  scaling = 1. / SQRT (n_filters / 2.);
+  for (i = 0; i < n_filters; i++) {
+    for (j = 0; j < n_coefs; j++) {
+      mfcc->dct_coeffs->data[j][i] =
+          scaling * COS (j * (i + 0.5) * PI / n_filters);
+    }
+    mfcc->dct_coeffs->data[0][i] *= SQRT (2.) / 2.;
+  }
+  if (!mfcc->in_dct || !mfcc->dct || !mfcc->output)
+    goto failure;
+  mfcc->scale = 1.;
   return mfcc;
+failure:
+  del_aubio_mfcc(mfcc);
+  return NULL;
+}
 …
 del_aubio_mfcc (aubio_mfcc_t * mf)
+{
+  /* delete filterbank */
+  del_aubio_filterbank (mf->fb);
+  /* delete buffers */
+  del_fvec (mf->in_dct);
+  del_fmat (mf->dct_coeffs);
+  /* delete mfcc object */
+  if (mf->fb)
+    del_aubio_filterbank (mf->fb);
+  if (mf->in_dct)
+    del_fvec (mf->in_dct);
+  if (mf->dct)
+    del_aubio_dct (mf->dct);
+  if (mf->output)
+    del_fvec (mf->output);
   AUBIO_FREE (mf);
+}
 …
 aubio_mfcc_do (aubio_mfcc_t * mf, const cvec_t * in, fvec_t * out)
+{
+  fvec_t tmp;
   /* compute filterbank */
   aubio_filterbank_do (mf->fb, in, mf->in_dct);
 …
   fvec_log10 (mf->in_dct);
+  /* raise power */
+  //fvec_pow (mf->in_dct, 3.);
+  if (mf->scale != 1) fvec_mul (mf->in_dct, mf->scale);
   /* compute mfccs */
+  fmat_vecmul(mf->dct_coeffs, mf->in_dct, out);
+  aubio_dct_do(mf->dct, mf->in_dct, mf->output);
+  // copy only first n_coeffs elements
+  // TODO assert mf->output->length == n_coeffs
+  tmp.data = mf->output->data;
+  tmp.length = out->length;
+  fvec_copy(&tmp, out);
   return;
+}
+uint_t aubio_mfcc_set_power (aubio_mfcc_t *mf, smpl_t power)
+{
+  return aubio_filterbank_set_power(mf->fb, power);
+}
+smpl_t aubio_mfcc_get_power (aubio_mfcc_t *mf)
+{
+  return aubio_filterbank_get_power(mf->fb);
+}
+uint_t aubio_mfcc_set_scale (aubio_mfcc_t *mf, smpl_t scale)
+{
+  mf->scale = scale;
+  return AUBIO_OK;
+}
+smpl_t aubio_mfcc_get_scale (aubio_mfcc_t *mf)
+{
+  return mf->scale;
+}
+uint_t aubio_mfcc_set_mel_coeffs (aubio_mfcc_t *mf, smpl_t freq_min,
+    smpl_t freq_max)
+{
+  return aubio_filterbank_set_mel_coeffs(mf->fb, mf->samplerate,
+      freq_min, freq_max);
+}
+uint_t aubio_mfcc_set_mel_coeffs_htk (aubio_mfcc_t *mf, smpl_t freq_min,
+    smpl_t freq_max)
+{
+  return aubio_filterbank_set_mel_coeffs_htk(mf->fb, mf->samplerate,
+      freq_min, freq_max);
+}
+uint_t aubio_mfcc_set_mel_coeffs_slaney (aubio_mfcc_t *mf)
+{
+  return aubio_filterbank_set_mel_coeffs_slaney (mf->fb, mf->samplerate);
+}

src/spectral/mfcc.h

-                      r5b46bc3
+                      r633400d
   The implementation follows the specifications established by Malcolm Slaney
+  in its Auditory Toolbox, available online (see file mfcc.m).
+  in its Auditory Toolbox, available online at the following address (see
+  file mfcc.m):
   http://engineering.ecn.purdue.edu/~malcolm/interval/1998-010/
+  https://engineering.purdue.edu/~malcolm/interval/1998-010/
   \example spectral/test-mfcc.c
 …
 void aubio_mfcc_do (aubio_mfcc_t * mf, const cvec_t * in, fvec_t * out);
+/** set power parameter
+  \param mf mfcc object, as returned by new_aubio_mfcc()
+  \param power Raise norm of the input spectrum norm to this power before
+  computing filterbank.  Defaults to `1`.
+  See aubio_filterbank_set_power().
+ */
+uint_t aubio_mfcc_set_power (aubio_mfcc_t *mf, smpl_t power);
+/** get power parameter
+  \param mf mfcc object, as returned by new_aubio_mfcc()
+  \return current power parameter. Defaults to `1`.
+  See aubio_filterbank_get_power().
+ */
+smpl_t aubio_mfcc_get_power (aubio_mfcc_t *mf);
+/** set scaling parameter
+  \param mf mfcc object, as returned by new_aubio_mfcc()
+  \param scale Scaling value to apply.
+  Scales the output of the filterbank after taking its logarithm and before
+  computing the DCT. Defaults to `1`.
+*/
+uint_t aubio_mfcc_set_scale (aubio_mfcc_t *mf, smpl_t scale);
+/** get scaling parameter
+  \param mf mfcc object, as returned by new_aubio_mfcc()
+  \return current scaling parameter. Defaults to `1`.
+ */
+smpl_t aubio_mfcc_get_scale (aubio_mfcc_t *mf);
+/** Mel filterbank initialization
+  \param mf mfcc object
+  \param fmin start frequency, in Hz
+  \param fmax end frequency, in Hz
+  The filterbank will be initialized with bands linearly spaced in the mel
+  scale, from `fmin` to `fmax`.
+  See also
+  --------
+  aubio_filterbank_set_mel_coeffs()
+*/
+uint_t aubio_mfcc_set_mel_coeffs (aubio_mfcc_t *mf,
+        smpl_t fmin, smpl_t fmax);
+/** Mel filterbank initialization
+  \param mf mfcc object
+  \param fmin start frequency, in Hz
+  \param fmax end frequency, in Hz
+  The bank of filters will be initalized to to cover linearly spaced bands in
+  the Htk mel scale, from `fmin` to `fmax`.
+  See also
+  --------
+  aubio_filterbank_set_mel_coeffs_htk()
+*/
+uint_t aubio_mfcc_set_mel_coeffs_htk (aubio_mfcc_t *mf,
+        smpl_t fmin, smpl_t fmax);
+/** Mel filterbank initialization (Auditory Toolbox's parameters)
+  \param mf mfcc object
+  The filter coefficients are built to match exactly Malcolm Slaney's Auditory
+  Toolbox implementation. The number of filters should be 40.
+  This is the default filterbank when `mf` was created with `n_filters = 40`.
+  See also
+  --------
+  aubio_filterbank_set_mel_coeffs_slaney()
+*/
+uint_t aubio_mfcc_set_mel_coeffs_slaney (aubio_mfcc_t *mf);
 #ifdef __cplusplus
+}

src/spectral/ooura_fft8g.c

-                      r5b46bc3
+                      r633400d
 //  - include "aubio_priv.h" (for config.h and types.h)
 //  - add missing prototypes
+//  - use COS and SIN macros
+//  - use COS, SIN, and ATAN macros
+//  - add cast to (smpl_t) to avoid float conversion warnings
 //  - declare initialization as static
 //  - prefix public function with aubio_ooura_
 …
         a[1] = xi;
     } else {
         a[1] = 0.5 * (a[0] - a[1]);
+        a[1] = (smpl_t)0.5 * (a[0] - a[1]);
         a[0] -= a[1];
         if (n > 4) {
 …
     if (nw > 2) {
         nwh = nw >> 1;
         delta = atan(1.0) / nwh;
+        delta = ATAN(1.0) / nwh;
         w[0] = 1;
         w[1] = 0;
 …
     if (nc > 1) {
         nch = nc >> 1;
         delta = atan(1.0) / nch;
         c[0] = cos(delta * nch);
         c[nch] = 0.5 * c[0];
+        delta = ATAN(1.0) / nch;
+        c[0] = COS(delta * nch);
+        c[nch] = (smpl_t)0.5 * c[0];
         for (j = 1; j < nch; j++) {
             c[j] = 0.5 * cos(delta * j);
             c[nc - j] = 0.5 * sin(delta * j);
+            c[j] = (smpl_t)0.5 * COS(delta * j);
+            c[nc - j] = (smpl_t)0.5 * SIN(delta * j);
+        }
+    }
 …
         k = n - j;
         kk += ks;
         wkr = 0.5 - c[nc - kk];
+        wkr = (smpl_t)0.5 - c[nc - kk];
         wki = c[kk];
         xr = a[j] - a[k];
 …
         k = n - j;
         kk += ks;
         wkr = 0.5 - c[nc - kk];
+        wkr = (smpl_t)0.5 - c[nc - kk];
         wki = c[kk];
         xr = a[j] - a[k];

src/spectral/phasevoc.c

-                      r5b46bc3
+                      r633400d
     goto beach;
   } else if (win_s < hop_s) {
     AUBIO_ERR("pvoc: hop size (%d) is larger than win size (%d)\n", win_s, hop_s);
+    AUBIO_ERR("pvoc: hop size (%d) is larger than win size (%d)\n", hop_s, win_s);
     goto beach;
+  }
 …
   AUBIO_FREE (pv);
   return NULL;
+}
+uint_t aubio_pvoc_set_window(aubio_pvoc_t *pv, const char_t *window) {
+  return fvec_set_window(pv->w, (char_t*)window);
+}
 …
     synthold[i] += synth[i + pv->hop_s] * pv->scale;
+}
+uint_t aubio_pvoc_get_win(aubio_pvoc_t* pv)
+{
+  return pv->win_s;
+}
+uint_t aubio_pvoc_get_hop(aubio_pvoc_t* pv)
+{
+  return pv->hop_s;
+}

src/spectral/phasevoc.h

-                      r5b46bc3
+                      r633400d
 */
 uint_t aubio_pvoc_get_win(aubio_pvoc_t* pv);
 /** get hop size
 …
 uint_t aubio_pvoc_get_hop(aubio_pvoc_t* pv);
+/** set window type
+  \param pv phase vocoder to set the window type
+  \param window_type a string representing a window
+  \return 0 if successful, non-zero otherwise
+ */
+uint_t aubio_pvoc_set_window(aubio_pvoc_t *pv, const char_t *window_type);
 #ifdef __cplusplus
+}

src/spectral/specdesc.c

-                      r5b46bc3
+                      r633400d
 void aubio_specdesc_complex(aubio_specdesc_t *o, const cvec_t * fftgrain, fvec_t * onset);
 void aubio_specdesc_phase(aubio_specdesc_t *o, const cvec_t * fftgrain, fvec_t * onset);
+void aubio_specdesc_wphase(aubio_specdesc_t *o, const cvec_t * fftgrain, fvec_t * onset);
 void aubio_specdesc_specdiff(aubio_specdesc_t *o, const cvec_t * fftgrain, fvec_t * onset);
 void aubio_specdesc_kl(aubio_specdesc_t *o, const cvec_t * fftgrain, fvec_t * onset);
 …
         aubio_onset_complex,        /**< complex domain */
         aubio_onset_phase,          /**< phase fast */
+        aubio_onset_wphase,         /**< weighted phase */
         aubio_onset_kl,             /**< Kullback Liebler */
         aubio_onset_mkl,            /**< modified Kullback Liebler */
 …
   onset->data[0] = aubio_hist_mean(o->histog);
   //onset->data[0] = fvec_mean(o->dev1);
+}
+/* weighted phase */
+void
+aubio_specdesc_wphase(aubio_specdesc_t *o,
+    const cvec_t *fftgrain, fvec_t *onset) {
+  uint_t i;
+  aubio_specdesc_phase(o, fftgrain, onset);
+  for (i = 0; i < fftgrain->length; i++) {
+    o->dev1->data[i] *= fftgrain->norm[i];
+  }
+  /* apply o->histogram */
+  aubio_hist_dyn_notnull(o->histog,o->dev1);
+  /* weight it */
+  aubio_hist_weight(o->histog);
+  /* its mean is the result */
+  onset->data[0] = aubio_hist_mean(o->histog);
+}
 …
   else if (strcmp (onset_mode, "phase") == 0)
       onset_type = aubio_onset_phase;
+  else if (strcmp (onset_mode, "wphase") == 0)
+      onset_type = aubio_onset_wphase;
   else if (strcmp (onset_mode, "mkl") == 0)
       onset_type = aubio_onset_mkl;
 …
   else if (strcmp (onset_mode, "rolloff") == 0)
       onset_type = aubio_specmethod_rolloff;
+  else if (strcmp (onset_mode, "old_default") == 0)
+      onset_type = aubio_onset_default;
   else if (strcmp (onset_mode, "default") == 0)
       onset_type = aubio_onset_default;
   else {
+      AUBIO_ERR("unknown spectral descriptor type %s\n", onset_mode);
+      AUBIO_ERR("specdesc: unknown spectral descriptor type '%s'\n",
+          onset_mode);
       AUBIO_FREE(o);
       return NULL;
 …
       break;
     case aubio_onset_phase:
+    case aubio_onset_wphase:
       o->dev1   = new_fvec(rsize);
       o->theta1 = new_fvec(rsize);
 …
       o->funcpointer = aubio_specdesc_phase;
       break;
+    case aubio_onset_wphase:
+      o->funcpointer = aubio_specdesc_wphase;
+      break;
     case aubio_onset_specdiff:
       o->funcpointer = aubio_specdesc_specdiff;
 …
       break;
     case aubio_onset_phase:
+    case aubio_onset_wphase:
       del_fvec(o->dev1);
       del_fvec(o->theta1);

src/spectral/specdesc.h

-                      r5b46bc3
+                      r633400d
   Hong-Kong, 2003.
+  \b \p wphase : Weighted Phase Deviation onset detection function
+  S. Dixon. Onset detection revisited. In Proceedings of the 9th International
+  Conference on Digital Audio Ef- fects (DAFx) , pages 133–137, 2006.
+  http://www.eecs.qmul.ac.uk/~simond/pub/2006/dafx.pdf
   \b \p specdiff : Spectral difference method onset detection function
 …
   The parameter \p method is a string that can be any of:
+    - `energy`, `hfc`, `complex`, `phase`, `specdiff`, `kl`, `mkl`, `specflux`
+    - `centroid`, `spread`, `skewness`, `kurtosis`, `slope`, `decrease`, `rolloff`
+    - onset novelty functions: `complex`, `energy`, `hfc`, `kl`, `mkl`,
+    `phase`, `specdiff`, `specflux`, `wphase`,
+    - spectral descriptors: `centroid`, `decrease`, `kurtosis`, `rolloff`,
+    `skewness`, `slope`, `spread`.
 */

src/synth/sampler.c

r5b46bc3	r633400d
20	20
21	21
22		~~#include "config.h"~~
23	22	#include "aubio_priv.h"
24	23	#include "fvec.h"

src/synth/wavetable.c

-                      r5b46bc3
+                      r633400d
-#include "config.h"
 #include "aubio_priv.h"
 #include "fvec.h"
 …
       output->data[i] += input->data[i];
+    }
+    fvec_clamp(output, 1.);
+  }
+}
 …
   aubio_wavetable_set_amp (s, 0.);
   //s->last_pos = 0;
+  return aubio_wavetable_set_playing (s, 1);
+  return aubio_wavetable_set_playing (s, 0);
+}
+uint_t
+aubio_wavetable_load ( aubio_wavetable_t *s UNUSED, const char_t *uri UNUSED)
+{
+  AUBIO_ERR("wavetable: load method not implemented yet, see sampler\n");
+  return AUBIO_FAIL;
+}

src/synth/wavetable.h

r5b46bc3	r633400d
53	53
54	54	/** load source in wavetable
	55
	56	TODO: This function is not implemented yet. See new_aubio_sampler() instead.
55	57
56	58	\param o wavetable, created by new_aubio_wavetable()

src/tempo/beattracking.h

r5b46bc3	r633400d
32	32	Matthew E. P. Davies, Paul Brossier, and Mark D. Plumbley. Beat tracking
33	33	towards automatic musical accompaniment. In Proceedings of the Audio
34		Eng~~eeni~~ring Society 118th Convention, Barcelona, Spain, May 2005.
	34	Engineering Society 118th Convention, Barcelona, Spain, May 2005.
35	35
36	36	\example tempo/test-beattracking.c

src/tempo/tempo.c

-                      r5b46bc3
+                      r633400d
 uint_t aubio_tempo_set_delay_ms(aubio_tempo_t * o, smpl_t delay) {
+  o->delay = 1000. * delay * o->samplerate;
+  return AUBIO_OK;
+  return aubio_tempo_set_delay_s(o, delay / 1000.);
+}
 …
 smpl_t aubio_tempo_get_delay_ms(aubio_tempo_t * o) {
   return o->delay / (smpl_t)(o->samplerate) / 1000.;
+  return aubio_tempo_get_delay_s(o) * 1000.;
+}
 …
+{
   aubio_tempo_t * o = AUBIO_NEW(aubio_tempo_t);
   char_t specdesc_func[20];
+  char_t specdesc_func[PATH_MAX];
   o->samplerate = samplerate;
   // check parameters are valid
 …
   aubio_peakpicker_set_threshold (o->pp, o->threshold);
   if ( strcmp(tempo_mode, "default") == 0 ) {
     strcpy(specdesc_func, "specflux");
+    strncpy(specdesc_func, "specflux", PATH_MAX - 1);
   } else {
+    strcpy(specdesc_func, tempo_mode);
+    strncpy(specdesc_func, tempo_mode, PATH_MAX - 1);
+    specdesc_func[PATH_MAX - 1] = '\0';
+  }
   o->od       = new_aubio_specdesc(specdesc_func,buf_size);
 …
     onset2 = new_fvec(1);
   }*/
+  if (!o->dfframe || !o->fftgrain || !o->out || !o->pv ||
+      !o->pp || !o->od || !o->of || !o->bt || !o->onset) {
+    AUBIO_ERR("tempo: failed creating tempo object\n");
+    goto beach;
+  }
   o->last_tatum = 0;
   o->tatum_signature = 4;
 …
 beach:
   AUBIO_FREE(o);
+  del_aubio_tempo(o);
   return NULL;
+}
 …
 void del_aubio_tempo (aubio_tempo_t *o)
+{
+  del_aubio_specdesc(o->od);
+  del_aubio_beattracking(o->bt);
+  del_aubio_peakpicker(o->pp);
+  del_aubio_pvoc(o->pv);
+  del_fvec(o->out);
+  del_fvec(o->of);
+  del_cvec(o->fftgrain);
+  del_fvec(o->dfframe);
+  del_fvec(o->onset);
+  if (o->od)
+    del_aubio_specdesc(o->od);
+  if (o->bt)
+    del_aubio_beattracking(o->bt);
+  if (o->pp)
+    del_aubio_peakpicker(o->pp);
+  if (o->pv)
+    del_aubio_pvoc(o->pv);
+  if (o->out)
+    del_fvec(o->out);
+  if (o->of)
+    del_fvec(o->of);
+  if (o->fftgrain)
+    del_cvec(o->fftgrain);
+  if (o->dfframe)
+    del_fvec(o->dfframe);
+  if (o->onset)
+    del_fvec(o->onset);
   AUBIO_FREE(o);
+  return;
+}
+}

src/tempo/tempo.h

-                      r5b46bc3
+                      r633400d
   \param o beat tracking object
   \return confidence with which the tempo has been observed, `0` if no
   consistent value is found.
+  \return confidence with which the tempo has been observed, the higher the
+  more confidence, `0` if no consistent value is found.
 */

src/temporal/biquad.c

r5b46bc3	r633400d
42	42	as->data[0] = 1.;
43	43	as->data[1] = a1;
44		as->data[1] = a2;
	44	as->data[2] = a2;
45	45	return AUBIO_OK;
46	46	}

src/temporal/resampler.c

-                      r5b46bc3
+                      r633400d
 */
-#include "config.h"
 #include "aubio_priv.h"
 #include "fvec.h"
 …
 #ifdef HAVE_SAMPLERATE
+#if HAVE_AUBIO_DOUBLE
+#error "Should not use libsamplerate with aubio in double precision"
+#endif
 #include <samplerate.h>         /* from libsamplerate */

src/utils/hist.c

-                      r5b46bc3
+                      r633400d
   smpl_t accum = step;
   uint_t i;
+  if ((sint_t)nelems <= 0) {
+    return NULL;
+  }
   s->nelems = nelems;
   s->hist = new_fvec(nelems);

src/utils/log.c

-                      r5b46bc3
+                      r633400d
 */
-#include "config.h"
 #include "aubio_priv.h"
 #include "log.h"
 …
   FILE *out;
   out = stdout;
   if (level == AUBIO_LOG_DBG || level == AUBIO_LOG_ERR) {
+  if (level == AUBIO_LOG_ERR || level == AUBIO_LOG_DBG || level == AUBIO_LOG_WRN) {
     out = stderr;
+  }

src/utils/log.h

-                      r5b46bc3
+                      r633400d
 enum aubio_log_level {
   AUBIO_LOG_ERR, /**< critical errors */
   AUBIO_LOG_WRN, /**< warnings */
+  AUBIO_LOG_INF, /**< infos */
   AUBIO_LOG_MSG, /**< general messages */
   AUBIO_LOG_DBG, /**< debug messages */
+  AUBIO_LOG_WRN, /**< warnings */
   AUBIO_LOG_LAST_LEVEL, /**< number of valid levels */
 };

src/utils/parameter.c

r5b46bc3	r633400d
19	19	*/
20	20
21		~~#include "config.h"~~
22	21	#include "aubio_priv.h"
23	22	#include "parameter.h"

src/utils/windll.c

-                      r5b46bc3
+                      r633400d
 */
 #include "config.h"
+#include "aubio_priv.h"
 #ifdef HAVE_WIN_HACKS
 …
 #include "aubio.h"
 BOOL APIENTRY DllMain( HMODULE hModule,
+BOOL APIENTRY DllMain( HMODULE hModule UNUSED,
                        DWORD  ul_reason_for_call,
                        LPVOID lpReserved )
+                       LPVOID lpReserved UNUSED)
+{
   switch (ul_reason_for_call)

src/vecutils.c

r5b46bc3	r633400d
1		~~#include "config.h"~~
2	1	#include "aubio_priv.h"
3	2	#include "types.h"

src/wscript_build

-                      r5b46bc3
+                      r633400d
 uselib += ['M']
 uselib += ['FFTW3', 'FFTW3F']
+uselib += ['INTEL_IPP']
 uselib += ['SAMPLERATE']
 uselib += ['SNDFILE']
 …
 uselib += ['AVCODEC']
 uselib += ['AVFORMAT']
+uselib += ['SWRESAMPLE']
 uselib += ['AVRESAMPLE']
 uselib += ['AVUTIL']
 …
     build_features = ['cstlib', 'cshlib']
 elif ctx.env['DEST_OS'] in ['win32', 'win64']:
+    build_features = ['cstlib', 'cshlib gensyms']
+elif ctx.env['DEST_OS'] in ['emscripten']:
+    build_features = ['cstlib','cshlib']
+elif '--static' in ctx.env['LDFLAGS'] or '--static' in ctx.env['LINKFLAGS']:
+    # static in cflags, ...
+    build_features = ['cstlib']
+else:
+    # linux, darwin, android, mingw, ...
     build_features = ['cstlib', 'cshlib']
+elif ctx.env['DEST_OS'] in ['emscripten']:
+    build_features = ['cstlib']
+else: #linux, darwin, android, mingw, ...
+    build_features = ['cstlib', 'cshlib']
+# also install static lib
+from waflib.Tools.c import cstlib
+cstlib.inst_to = '${LIBDIR}'
 for target in build_features:
 …
             use = uselib + ['lib_objects'],
             target = 'aubio',
+            export_symbols_regex=r'(?:.*aubio|fvec|lvec|cvec|fmat|new|del)_.*',
             vnum = ctx.env['LIB_VERSION'])
 # install headers, except _priv.h ones
 ctx.install_files('${PREFIX}/include/aubio/',
+ctx.install_files('${INCLUDEDIR}/aubio/',
         ctx.path.ant_glob('**/*.h', excl = ['**_priv.h', 'config.h']),
         relative_trick=True)

Context Navigation

Legend:

Download in other formats: