Changeset 695e171 for src


Ignore:
Timestamp:
Sep 6, 2015, 10:40:14 AM (9 years ago)
Author:
Paul Brossier <piem@piem.org>
Branches:
feature/autosink, feature/cnn, feature/cnn_org, feature/constantq, feature/crepe, feature/crepe_org, feature/pitchshift, feature/pydocstrings, feature/timestretch, fix/ffmpeg5, master, sampler
Children:
3d30b90
Parents:
65c352e (diff), 827267b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'develop' into awhitening

Location:
src
Files:
35 edited

Legend:

Unmodified
Added
Removed

  • src/aubio.h

    r65c352e r695e171  
    11/*
    2   Copyright (C) 2003-2013 Paul Brossier <piem@aubio.org>
     2  Copyright (C) 2003-2015 Paul Brossier <piem@aubio.org>
    33
    44  This file is part of aubio.
    … …  
    1919*/
    2020
    21 /** \mainpage 
    22  
     21/** \mainpage
     22
    2323  \section introduction Introduction
    24  
     24
    2525  aubio is a library to extract annotations from audio signals: it provides a
    2626  set of functions that take an input audio signal, and output pitch estimates,
    2727  attack times (onset), beat location estimates, and other annotation tasks.
    28  
    29   \section basics Basics 
    30  
     28
     29  \section basics Basics
     30
    3131  All object structures in aubio share the same function prefixes and suffixes:
    32  
     32
    3333    - \p new_aubio_foo creates the object \p foo
    3434    - \p aubio_foo_do executes the object \p foo
    … …  
    3838  functions. Optionally, more than one \p _do methods are available.
    3939  Additional parameters can be adjusted and observed using:
    40  
     40
    4141    - \p aubio_foo_get_param, getter function, gets the value of a parameter
    4242    - \p aubio_foo_set_param, setter function, changes the value of a parameter

  • src/aubio_priv.h

    r65c352e r695e171  
    11/*
    2   Copyright (C) 2003-2009 Paul Brossier <piem@aubio.org>
     2  Copyright (C) 2003-2015 Paul Brossier <piem@aubio.org>
    33
    44  This file is part of aubio.
    … …  
    2121/** @file
    2222 * Private include file
    23  * 
     23 *
    2424 * This file is for inclusion from _within_ the library only.
    2525 */
    … …  
    3030/*********************
    3131 *
    32  * External includes 
     32 * External includes
    3333 *
    3434 */
    … …  
    6565#endif
    6666
     67#ifdef HAVE_ACCELERATE
     68#define HAVE_ATLAS 1
     69#include <Accelerate/Accelerate.h>
     70#elif HAVE_ATLAS_CBLAS_H
     71#define HAVE_ATLAS 1
     72#include <atlas/cblas.h>
     73#else
     74#undef HAVE_ATLAS
     75#endif
     76
     77#ifdef HAVE_ACCELERATE
     78#include <Accelerate/Accelerate.h>
     79#if !HAVE_AUBIO_DOUBLE
     80#define aubio_vDSP_mmov       vDSP_mmov
     81#define aubio_vDSP_vmul       vDSP_vmul
     82#define aubio_vDSP_vfill      vDSP_vfill
     83#define aubio_vDSP_meanv      vDSP_meanv
     84#define aubio_vDSP_sve        vDSP_sve
     85#define aubio_vDSP_maxv       vDSP_maxv
     86#define aubio_vDSP_maxvi      vDSP_maxvi
     87#define aubio_vDSP_minv       vDSP_minv
     88#define aubio_vDSP_minvi      vDSP_minvi
     89#else /* HAVE_AUBIO_DOUBLE */
     90#define aubio_vDSP_mmov       vDSP_mmovD
     91#define aubio_vDSP_vmul       vDSP_vmulD
     92#define aubio_vDSP_vfill      vDSP_vfillD
     93#define aubio_vDSP_meanv      vDSP_meanvD
     94#define aubio_vDSP_sve        vDSP_sveD
     95#define aubio_vDSP_maxv       vDSP_maxvD
     96#define aubio_vDSP_maxvi      vDSP_maxviD
     97#define aubio_vDSP_minv       vDSP_minvD
     98#define aubio_vDSP_minvi      vDSP_minviD
     99#endif /* HAVE_AUBIO_DOUBLE */
     100#endif /* HAVE_ACCELERATE */
     101
     102#ifdef HAVE_ATLAS
     103#if !HAVE_AUBIO_DOUBLE
     104#define aubio_catlas_set      catlas_sset
     105#define aubio_cblas_copy      cblas_scopy
     106#define aubio_cblas_swap      cblas_sswap
     107#define aubio_cblas_dot       cblas_sdot
     108#else /* HAVE_AUBIO_DOUBLE */
     109#define aubio_catlas_set      catlas_dset
     110#define aubio_cblas_copy      cblas_dcopy
     111#define aubio_cblas_swap      cblas_dswap
     112#define aubio_cblas_dot       cblas_ddot
     113#endif /* HAVE_AUBIO_DOUBLE */
     114#endif /* HAVE_ATLAS */
     115
     116#if !defined(HAVE_MEMCPY_HACKS) && !defined(HAVE_ACCELERATE) && !defined(HAVE_ATLAS)
     117#define HAVE_NOOPT 1
     118#else
     119#undef HAVE_NOOPT
     120#endif
     121
    67122#include "types.h"
    68123
    … …  
    72127
    73128/****
    74  * 
     129 *
    75130 * SYSTEM INTERFACE
    76131 *
    … …  
    197252#define DB2LIN(g) (POW(10.0,(g)*0.05f))
    198253#define LIN2DB(v) (20.0*LOG10(v))
    199 #define SQR(_a)   (_a*_a)
    200 
    201 #define MAX(a,b)  ( a > b ? a : b)
    202 #define MIN(a,b)  ( a < b ? a : b)
     254#define SQR(_a)   ((_a)*(_a))
     255
     256#ifndef MAX
     257#define MAX(a,b)  (((a)>(b))?(a):(b))
     258#endif /* MAX */
     259#ifndef MIN
     260#define MIN(a,b)  (((a)<(b))?(a):(b))
     261#endif /* MIN */
    203262
    204263#define ELEM_SWAP(a,b) { register smpl_t t=(a);(a)=(b);(b)=t; }

  • src/cvec.h

    r65c352e r695e171  
    11/*
    2   Copyright (C) 2003-2013 Paul Brossier <piem@aubio.org>
     2  Copyright (C) 2003-2015 Paul Brossier <piem@aubio.org>
    33
    44  This file is part of aubio.

  • src/fmat.h

    r65c352e r695e171  
    11/*
    2   Copyright (C) 2009-2013 Paul Brossier <piem@aubio.org>
     2  Copyright (C) 2009-2015 Paul Brossier <piem@aubio.org>
    33
    44  This file is part of aubio.
    … …  
    6363  \param s vector to read from
    6464  \param channel channel to read from
    65   \param position sample position to read from 
     65  \param position sample position to read from
    6666
    6767*/
    … …  
    7070/** write sample value in a buffer
    7171
    72   \param s vector to write to 
     72  \param s vector to write to
    7373  \param data value to write in s->data[channel][position]
    74   \param channel channel to write to 
    75   \param position sample position to write to 
     74  \param channel channel to write to
     75  \param position sample position to write to
    7676
    7777*/
    … …  
    102102smpl_t ** fmat_get_data(fmat_t *s);
    103103
    104 /** print out fmat data 
     104/** print out fmat data
    105105
    106   \param s vector to print out 
     106  \param s vector to print out
    107107
    108108*/
    … …  
    117117void fmat_set(fmat_t *s, smpl_t val);
    118118
    119 /** set all elements to zero 
     119/** set all elements to zero
    120120
    121121  \param s vector to modify
    … …  
    124124void fmat_zeros(fmat_t *s);
    125125
    126 /** set all elements to ones 
     126/** set all elements to ones
    127127
    128128  \param s vector to modify
    … …  
    149149void fmat_weight(fmat_t *s, fmat_t *weight);
    150150
    151 /** make a copy of a matrix 
     151/** make a copy of a matrix
    152152
    153153  \param s source vector

  • src/fvec.c

    r65c352e r695e171  
    6161
    6262void fvec_set_all (fvec_t *s, smpl_t val) {
     63#if !defined(HAVE_ACCELERATE) && !defined(HAVE_ATLAS)
    6364  uint_t j;
    6465  for (j=0; j< s->length; j++) {
    6566    s->data[j] = val;
    6667  }
     68#elif defined(HAVE_ATLAS)
     69  aubio_catlas_set(s->length, val, s->data, 1);
     70#elif defined(HAVE_ACCELERATE)
     71  aubio_vDSP_vfill(&val, s->data, 1, s->length);
     72#endif
    6773}
    6874
    6975void fvec_zeros(fvec_t *s) {
    70 #if HAVE_MEMCPY_HACKS
     76#if !defined(HAVE_MEMCPY_HACKS) && !defined(HAVE_ACCELERATE)
     77  fvec_set_all (s, 0.);
     78#else
     79#if defined(HAVE_MEMCPY_HACKS)
    7180  memset(s->data, 0, s->length * sizeof(smpl_t));
    7281#else
    73   fvec_set_all (s, 0.);
     82  aubio_vDSP_vclr(s->data, 1, s->length);
     83#endif
    7484#endif
    7585}
    … …  
    8797
    8898void fvec_weight(fvec_t *s, fvec_t *weight) {
     99#ifndef HAVE_ACCELERATE
    89100  uint_t j;
    90101  uint_t length = MIN(s->length, weight->length);
    … …  
    92103    s->data[j] *= weight->data[j];
    93104  }
     105#else
     106  aubio_vDSP_vmul(s->data, 1, weight->data, 1, s->data, 1, s->length);
     107#endif /* HAVE_ACCELERATE */
     108}
     109
     110void fvec_weighted_copy(fvec_t *in, fvec_t *weight, fvec_t *out) {
     111#ifndef HAVE_ACCELERATE
     112  uint_t j;
     113  uint_t length = MIN(out->length, weight->length);
     114  for (j=0; j< length; j++) {
     115    out->data[j] = in->data[j] * weight->data[j];
     116  }
     117#else
     118  aubio_vDSP_vmul(in->data, 1, weight->data, 1, out->data, 1, out->length);
     119#endif /* HAVE_ACCELERATE */
    94120}
    95121
    … …  
    100126    return;
    101127  }
    102 #if HAVE_MEMCPY_HACKS
    103   memcpy(t->data, s->data, t->length * sizeof(smpl_t));
    104 #else
     128#if HAVE_NOOPT
    105129  uint_t j;
    106130  for (j=0; j< t->length; j++) {
    107131    t->data[j] = s->data[j];
    108132  }
     133#elif defined(HAVE_MEMCPY_HACKS)
     134  memcpy(t->data, s->data, t->length * sizeof(smpl_t));
     135#elif defined(HAVE_ATLAS)
     136  aubio_cblas_copy(s->length, s->data, 1, t->data, 1);
     137#elif defined(HAVE_ACCELERATE)
     138  aubio_vDSP_mmov(s->data, t->data, 1, s->length, 1, 1);
    109139#endif
    110140}

  • src/fvec.h

    r65c352e r695e171  
    11/*
    2   Copyright (C) 2003-2013 Paul Brossier <piem@aubio.org>
     2  Copyright (C) 2003-2015 Paul Brossier <piem@aubio.org>
    33
    44  This file is part of aubio.
    … …  
    8787
    8888  \param s vector to read from
    89   \param position sample position to read from 
     89  \param position sample position to read from
    9090
    9191*/
    … …  
    9494/** write sample value in a buffer
    9595
    96   \param s vector to write to 
     96  \param s vector to write to
    9797  \param data value to write in s->data[position]
    98   \param position sample position to write to 
     98  \param position sample position to write to
    9999
    100100*/
    … …  
    108108smpl_t * fvec_get_data(fvec_t *s);
    109109
    110 /** print out fvec data 
     110/** print out fvec data
    111111
    112   \param s vector to print out 
     112  \param s vector to print out
    113113
    114114*/
    … …  
    123123void fvec_set_all (fvec_t *s, smpl_t val);
    124124
    125 /** set all elements to zero 
     125/** set all elements to zero
    126126
    127127  \param s vector to modify
    … …  
    130130void fvec_zeros(fvec_t *s);
    131131
    132 /** set all elements to ones 
     132/** set all elements to ones
    133133
    134134  \param s vector to modify
    … …  
    163163void fvec_copy(fvec_t *s, fvec_t *t);
    164164
     165/** make a copy of a vector, applying weights to each element
     166
     167  \param in input vector
     168  \param weight weights vector
     169  \param out output vector
     170
     171*/
     172void fvec_weighted_copy(fvec_t *in, fvec_t *weight, fvec_t *out);
     173
    165174#ifdef __cplusplus
    166175}

  • src/io/audio_unit.c

    r65c352e r695e171  
    2020
    2121#include "config.h"
    22 #ifdef TARGET_OS_IPHONE
     22#ifdef HAVE_AUDIO_UNIT
    2323#include "aubio_priv.h"
    2424
    … …  
    775775}
    776776
    777 #endif /* TARGET_OS_IPHONE */
     777#endif /* HAVE_AUDIO_UNIT */

  • src/io/sink_sndfile.c

    r65c352e r695e171  
    3333#define MAX_CHANNELS 6
    3434#define MAX_SIZE 4096
     35
     36#if !HAVE_AUBIO_DOUBLE
     37#define aubio_sf_write_smpl sf_write_float
     38#else /* HAVE_AUBIO_DOUBLE */
     39#define aubio_sf_write_smpl sf_write_double
     40#endif /* HAVE_AUBIO_DOUBLE */
    3541
    3642struct _aubio_sink_sndfile_t {
    … …  
    126132    AUBIO_ERR("sink_sndfile: Failed opening %s. %s\n", s->path, sf_strerror (NULL));
    127133    return AUBIO_FAIL;
    128   }     
     134  }
    129135
    130136  s->scratch_size = s->max_size*s->channels;
    … …  
    135141    return AUBIO_FAIL;
    136142  }
    137   s->scratch_data = AUBIO_ARRAY(float,s->scratch_size);
     143  s->scratch_data = AUBIO_ARRAY(smpl_t,s->scratch_size);
    138144
    139145  return AUBIO_OK;
    … …  
    141147
    142148void aubio_sink_sndfile_do(aubio_sink_sndfile_t *s, fvec_t * write_data, uint_t write){
    143   uint_t i, j,  channels = s->channels;
     149  uint_t i, j, channels = s->channels;
    144150  int nsamples = 0;
    145151  smpl_t *pwrite;
    … …  
    162168  }
    163169
    164   written_frames = sf_write_float (s->handle, s->scratch_data, nsamples);
     170  written_frames = aubio_sf_write_smpl (s->handle, s->scratch_data, nsamples);
    165171  if (written_frames/channels != write) {
    166172    AUBIO_WRN("sink_sndfile: trying to write %d frames to %s, but only %d could be written\n",
    … …  
    171177
    172178void aubio_sink_sndfile_do_multi(aubio_sink_sndfile_t *s, fmat_t * write_data, uint_t write){
    173   uint_t i, j,  channels = s->channels;
     179  uint_t i, j, channels = s->channels;
    174180  int nsamples = 0;
    175181  smpl_t *pwrite;
    … …  
    192198  }
    193199
    194   written_frames = sf_write_float (s->handle, s->scratch_data, nsamples);
     200  written_frames = aubio_sf_write_smpl (s->handle, s->scratch_data, nsamples);
    195201  if (written_frames/channels != write) {
    196202    AUBIO_WRN("sink_sndfile: trying to write %d frames to %s, but only %d could be written\n",

  • src/io/source_avcodec.c

    r65c352e r695e171  
    2323
    2424#ifdef HAVE_LIBAV
     25
     26// determine whether we use libavformat from ffmpe or libav
     27#define FFMPEG_LIBAVFORMAT (LIBAVFORMAT_VERSION_MICRO > 99)
    2528
    2629#include <libavcodec/avcodec.h>
    … …  
    101104
    102105  // try to make sure max_analyze_duration is big enough for most songs
     106#if FFMPEG_LIBAVFORMAT
     107  avFormatCtx->max_analyze_duration2 *= 100;
     108#else
    103109  avFormatCtx->max_analyze_duration *= 100;
     110#endif
    104111
    105112  // retrieve stream information

  • src/io/source_sndfile.c

    r65c352e r695e171  
    9191    AUBIO_ERR("source_sndfile: Failed opening %s: %s\n", s->path, sf_strerror (NULL));
    9292    goto beach;
    93   }     
     93  }
    9494
    9595  /* get input specs */

  • src/lvec.h

    r65c352e r695e171  
    11/*
    2   Copyright (C) 2003-2013 Paul Brossier <piem@aubio.org>
     2  Copyright (C) 2003-2015 Paul Brossier <piem@aubio.org>
    33
    44  This file is part of aubio.
    … …  
    6262
    6363  \param s vector to read from
    64   \param position sample position to read from 
     64  \param position sample position to read from
    6565
    6666*/
    … …  
    6969/** write sample value in a buffer
    7070
    71   \param s vector to write to 
     71  \param s vector to write to
    7272  \param data value to write in s->data[position]
    73   \param position sample position to write to 
     73  \param position sample position to write to
    7474
    7575*/
    … …  
    8383lsmp_t * lvec_get_data(lvec_t *s);
    8484
    85 /** print out lvec data 
     85/** print out lvec data
    8686
    87   \param s vector to print out 
     87  \param s vector to print out
    8888
    8989*/
    … …  
    9898void lvec_set_all(lvec_t *s, smpl_t val);
    9999
    100 /** set all elements to zero 
     100/** set all elements to zero
    101101
    102102  \param s vector to modify
    … …  
    105105void lvec_zeros(lvec_t *s);
    106106
    107 /** set all elements to ones 
     107/** set all elements to ones
    108108
    109109  \param s vector to modify

  • src/mathutils.c

    r65c352e r695e171  
    2626#include "musicutils.h"
    2727#include "config.h"
    28 
    29 #ifdef HAVE_ACCELERATE
    30 #include <Accelerate/Accelerate.h>
    31 #endif
    3228
    3329/** Window types */
    … …  
    159155fvec_mean (fvec_t * s)
    160156{
    161   uint_t j;
    162157  smpl_t tmp = 0.0;
     158#ifndef HAVE_ACCELERATE
     159  uint_t j;
    163160  for (j = 0; j < s->length; j++) {
    164161    tmp += s->data[j];
    165162  }
    166163  return tmp / (smpl_t) (s->length);
     164#else
     165  aubio_vDSP_meanv(s->data, 1, &tmp, s->length);
     166  return tmp;
     167#endif /* HAVE_ACCELERATE */
    167168}
    168169
    … …  
    170171fvec_sum (fvec_t * s)
    171172{
    172   uint_t j;
    173173  smpl_t tmp = 0.0;
     174#ifndef HAVE_ACCELERATE
     175  uint_t j;
    174176  for (j = 0; j < s->length; j++) {
    175177    tmp += s->data[j];
    176178  }
     179#else
     180  aubio_vDSP_sve(s->data, 1, &tmp, s->length);
     181#endif /* HAVE_ACCELERATE */
    177182  return tmp;
    178183}
    … …  
    189194#else
    190195  smpl_t tmp = 0.;
    191 #if !HAVE_AUBIO_DOUBLE
    192   vDSP_maxv(s->data, 1, &tmp, s->length);
    193 #else
    194   vDSP_maxvD(s->data, 1, &tmp, s->length);
    195 #endif
     196  aubio_vDSP_maxv(s->data, 1, &tmp, s->length);
    196197#endif
    197198  return tmp;
    … …  
    209210#else
    210211  smpl_t tmp = 0.;
    211 #if !HAVE_AUBIO_DOUBLE
    212   vDSP_minv(s->data, 1, &tmp, s->length);
    213 #else
    214   vDSP_minvD(s->data, 1, &tmp, s->length);
    215 #endif
     212  aubio_vDSP_minv(s->data, 1, &tmp, s->length);
    216213#endif
    217214  return tmp;
    … …  
    231228  smpl_t tmp = 0.;
    232229  uint_t pos = 0.;
    233 #if !HAVE_AUBIO_DOUBLE
    234   vDSP_minvi(s->data, 1, &tmp, (vDSP_Length *)&pos, s->length);
    235 #else
    236   vDSP_minviD(s->data, 1, &tmp, (vDSP_Length *)&pos, s->length);
    237 #endif
     230  aubio_vDSP_minvi(s->data, 1, &tmp, (vDSP_Length *)&pos, s->length);
    238231#endif
    239232  return pos;
    … …  
    253246  smpl_t tmp = 0.;
    254247  uint_t pos = 0.;
    255 #if !HAVE_AUBIO_DOUBLE
    256   vDSP_maxvi(s->data, 1, &tmp, (vDSP_Length *)&pos, s->length);
    257 #else
    258   vDSP_maxviD(s->data, 1, &tmp, (vDSP_Length *)&pos, s->length);
    259 #endif
     248  aubio_vDSP_maxvi(s->data, 1, &tmp, (vDSP_Length *)&pos, s->length);
    260249#endif
    261250  return pos;
    … …  
    265254fvec_shift (fvec_t * s)
    266255{
     256#ifndef HAVE_ATLAS
    267257  uint_t j;
    268258  for (j = 0; j < s->length / 2; j++) {
    269259    ELEM_SWAP (s->data[j], s->data[j + s->length / 2]);
    270260  }
     261#else
     262  uint_t half = s->length / 2;
     263  aubio_cblas_swap(half, s->data, 1, s->data + half, 1);
     264#endif
    271265}
    272266
    … …  
    275269{
    276270  smpl_t energy = 0.;
     271#ifndef HAVE_ATLAS
    277272  uint_t j;
    278273  for (j = 0; j < f->length; j++) {
    279274    energy += SQR (f->data[j]);
    280275  }
     276#else
     277  energy = aubio_cblas_dot(f->length, f->data, 1, f->data, 1);
     278#endif
    281279  return energy / f->length;
    282280}

  • src/mathutils.h

    r65c352e r695e171  
    11/*
    2   Copyright (C) 2003-2014 Paul Brossier <piem@aubio.org>
     2  Copyright (C) 2003-2015 Paul Brossier <piem@aubio.org>
    33
    44  This file is part of aubio.
    … …  
    8383
    8484/** swap the left and right halves of a vector
    85  
     85
    8686  This function swaps the left part of the signal with the right part of the
    8787signal. Therefore
    8888
    8989  \f$ a[0], a[1], ..., a[\frac{N}{2}], a[\frac{N}{2}+1], ..., a[N-1], a[N] \f$
    90  
     90
    9191  becomes
    92  
     92
    9393  \f$ a[\frac{N}{2}+1], ..., a[N-1], a[N], a[0], a[1], ..., a[\frac{N}{2}] \f$
    9494
    … …  
    9696can be used before computing the FFT to simplify the phase relationship of the
    9797resulting spectrum. See Amalia de Götzen's paper referred to above.
    98  
     98
    9999*/
    100100void fvec_shift (fvec_t * v);
    … …  
    112112
    113113  The High Frequency Content is defined as \f$ \sum_0^{N-1} (k+1) v[k] \f$.
    114  
    115   \param v vector to get the energy from 
     114
     115  \param v vector to get the energy from
    116116
    117117  \return the HFC of v
    118  
     118
    119119*/
    120120smpl_t fvec_local_hfc (fvec_t * v);
    121121
    122 /** computes the p-norm of a vector 
    123  
     122/** computes the p-norm of a vector
     123
    124124  Computes the p-norm of a vector for \f$ p = \alpha \f$
    125125
    126126  \f$ L^p = ||x||_p = (|x_1|^p + |x_2|^p + ... + |x_n|^p ) ^ \frac{1}{p} \f$
    127  
     127
    128128  If p = 1, the result is the Manhattan distance.
    129129
    … …  
    134134
    135135  References:
    136  
     136
    137137    - <a href="http://en.wikipedia.org/wiki/Lp_space">\f$L^p\f$ space</a> on
    138138  Wikipedia
    … …  
    142142
    143143  \return the p-norm of v
    144  
     144
    145145*/
    146146smpl_t fvec_alpha_norm (fvec_t * v, smpl_t p);
    … …  
    148148/**  alpha normalisation
    149149
    150   This function divides all elements of a vector by the p-norm as computed by 
     150  This function divides all elements of a vector by the p-norm as computed by
    151151fvec_alpha_norm().
    152152
    … …  
    166166
    167167/** remove the minimum value of the vector to each elements
    168  
     168
    169169  \param v vector to remove minimum from
    170170
    … …  
    177177position of a vector, taking the median among post elements before and up to
    178178pre elements after pos.
    179  
     179
    180180  \param v input vector
    181181  \param tmp temporary vector of length post+1+pre
    182   \param post length of causal part to take before pos 
     182  \param post length of causal part to take before pos
    183183  \param pre length of anti-causal part to take after pos
    184   \param pos index to compute threshold for 
    185 
    186   \return moving median threshold value 
     184  \param pos index to compute threshold for
     185
     186  \return moving median threshold value
    187187
    188188*/
    … …  
    197197  \param v input vector
    198198  \param tmp temporary vector of length post+1+pre
    199   \param post length of causal part to take before pos 
     199  \param post length of causal part to take before pos
    200200  \param pre length of anti-causal part to take after pos
    201201
    … …  
    203203void fvec_adapt_thres (fvec_t * v, fvec_t * tmp, uint_t post, uint_t pre);
    204204
    205 /** returns the median of a vector 
     205/** returns the median of a vector
    206206
    207207  The QuickSelect routine is based on the algorithm described in "Numerical
    … …  
    216216
    217217  \return the median of v
    218  
     218
    219219*/
    220220smpl_t fvec_median (fvec_t * v);
    … …  
    249249
    250250/** Quadratic interpolation using Lagrange polynomial.
    251  
     251
    252252  Inspired from ``Comparison of interpolation algorithms in real-time sound
    253 processing'', Vladimir Arnost, 
    254  
    255   \param s0,s1,s2 are 3 consecutive samples of a curve 
     253processing'', Vladimir Arnost,
     254
     255  \param s0,s1,s2 are 3 consecutive samples of a curve
    256256  \param pf is the floating point index [0;2]
    257  
     257
    258258  \return \f$ s0 + (pf/2.)*((pf-3.)*s0-2.*(pf-2.)*s1+(pf-1.)*s2); \f$
    259259

  • src/musicutils.h

    r65c352e r695e171  
    11/*
    2   Copyright (C) 2003-2013 Paul Brossier <piem@aubio.org>
     2  Copyright (C) 2003-2015 Paul Brossier <piem@aubio.org>
    33
    44  This file is part of aubio.
    … …  
    3030#endif
    3131
    32 /** create window 
     32/** create window
    3333
    3434  \param window_type type of the window to create
    3535  \param size length of the window to create (see fvec_set_window())
    36  
     36
    3737*/
    3838fvec_t *new_aubio_window (char_t * window_type, uint_t size);
    … …  
    5050
    5151  References:
    52    
     52
    5353    - <a href="http://en.wikipedia.org/wiki/Window_function">Window
    5454function</a> on Wikipedia
    … …  
    6969
    7070  \param phase unwrapped phase to map to the unit circle
    71  
     71
    7272  \return equivalent phase wrapped to the unit circle
    7373
    … …  
    9494
    9595/** clean up cached memory at the end of program
    96  
     96
    9797  This function should be used at the end of programs to purge all cached
    9898  memory. So far it is only useful to clean FFTW's cache.
    … …  
    138138
    139139/** check if buffer level in dB SPL is under a given threshold
    140  
     140
    141141  \param v vector to get level from
    142142  \param threshold threshold in dB SPL

  • src/onset/peakpicker.h

    r65c352e r695e171  
    1919*/
    2020
    21 /** \file 
    22  
     21/** \file
     22
    2323  Peak picking utilities function
    2424
    2525  \example onset/test-peakpicker.c
    26  
     26
    2727*/
    2828

  • src/pitch/pitch.c

    r65c352e r695e171  
    240240aubio_pitch_slideblock (aubio_pitch_t * p, fvec_t * ibuf)
    241241{
    242   uint_t j = 0, overlap_size = 0;
    243   overlap_size = p->buf->length - ibuf->length;
     242  uint_t overlap_size = p->buf->length - ibuf->length;
     243#if !HAVE_MEMCPY_HACKS
     244  uint_t j;
    244245  for (j = 0; j < overlap_size; j++) {
    245246    p->buf->data[j] = p->buf->data[j + ibuf->length];
    … …  
    248249    p->buf->data[j + overlap_size] = ibuf->data[j];
    249250  }
     251#else
     252  smpl_t *data = p->buf->data;
     253  smpl_t *newdata = ibuf->data;
     254  memmove(data, data + ibuf->length, overlap_size);
     255  memcpy(data + overlap_size, newdata, ibuf->length);
     256#endif
    250257}
    251258

  • src/pitch/pitchyinfft.c

    r65c352e r695e171  
    108108  smpl_t tmp = 0., sum = 0.;
    109109  // window the input
    110   for (l = 0; l < input->length; l++) {
    111     p->winput->data[l] = p->win->data[l] * input->data[l];
    112   }
     110  fvec_weighted_copy(input, p->win, p->winput);
    113111  // get the real / imag parts of its fft
    114112  aubio_fft_do_complex (p->fft, p->winput, fftout);

  • src/pitch/pitchyinfft.h

    r65c352e r695e171  
    11/*
    2   Copyright (C) 2003-2013 Paul Brossier <piem@aubio.org>
     2  Copyright (C) 2003-2015 Paul Brossier <piem@aubio.org>
    33
    44  This file is part of aubio.
    … …  
    2020
    2121/** \file
    22  
     22
    2323  Pitch detection using a spectral implementation of the YIN algorithm
    24  
     24
    2525  This algorithm was derived from the YIN algorithm. In this implementation, a
    2626  Fourier transform is used to compute a tapered square difference function,
    2727  which allows spectral weighting. Because the difference function is tapered,
    2828  the selection of the period is simplified.
    29  
     29
    3030  Paul Brossier, [Automatic annotation of musical audio for interactive
    3131  systems](http://aubio.org/phd/), Chapter 3, Pitch Analysis, PhD thesis,
    … …  
    4646typedef struct _aubio_pitchyinfft_t aubio_pitchyinfft_t;
    4747
    48 /** execute pitch detection on an input buffer 
    49  
     48/** execute pitch detection on an input buffer
     49
    5050  \param o pitch detection object as returned by new_aubio_pitchyinfft
    5151  \param samples_in input signal vector (length as specified at creation time)
    5252  \param cands_out pitch period candidates, in samples
    53  
     53
    5454*/
    5555void aubio_pitchyinfft_do (aubio_pitchyinfft_t * o, fvec_t * samples_in, fvec_t * cands_out);
    5656/** creation of the pitch detection object
    57  
     57
    5858  \param samplerate samplerate of the input signal
    59   \param buf_size size of the input buffer to analyse 
    60  
     59  \param buf_size size of the input buffer to analyse
     60
    6161*/
    6262aubio_pitchyinfft_t *new_aubio_pitchyinfft (uint_t samplerate, uint_t buf_size);
    6363/** deletion of the pitch detection object
    64  
     64
    6565  \param o pitch detection object as returned by new_aubio_pitchyinfft()
    66  
     66
    6767*/
    6868void del_aubio_pitchyinfft (aubio_pitchyinfft_t * o);
    6969
    70 /** get tolerance parameter for YIN algorithm 
    71  
    72   \param o YIN pitch detection object 
     70/** get tolerance parameter for YIN algorithm
     71
     72  \param o YIN pitch detection object
    7373
    7474  \return tolerance parameter for minima selection [default 0.15]
    … …  
    7777smpl_t aubio_pitchyinfft_get_tolerance (aubio_pitchyinfft_t * o);
    7878
    79 /** set tolerance parameter for YIN algorithm 
    80  
    81   \param o YIN pitch detection object 
     79/** set tolerance parameter for YIN algorithm
     80
     81  \param o YIN pitch detection object
    8282  \param tol tolerance parameter for minima selection [default 0.15]
    8383

  • src/spectral/fft.c

    r65c352e r695e171  
    6767#warning "Using aubio in double precision with fftw3 in single precision"
    6868#endif /* HAVE_AUBIO_DOUBLE */
    69 #define real_t float 
     69#define real_t float
    7070#else /* HAVE_FFTW3F */
    7171#if !HAVE_AUBIO_DOUBLE
    7272#warning "Using aubio in single precision with fftw3 in double precision"
    7373#endif /* HAVE_AUBIO_DOUBLE */
    74 #define real_t double 
     74#define real_t double
    7575#endif /* HAVE_FFTW3F */
    7676
    … …  
    8282// https://developer.apple.com/library/mac/#documentation/Accelerate/Reference/vDSPRef/Reference/reference.html
    8383#include <Accelerate/Accelerate.h>
     84
     85#if !HAVE_AUBIO_DOUBLE
     86#define aubio_vDSP_ctoz                vDSP_ctoz
     87#define aubio_vDSP_fft_zrip            vDSP_fft_zrip
     88#define aubio_vDSP_ztoc                vDSP_ztoc
     89#define aubio_vDSP_zvmags              vDSP_zvmags
     90#define aubio_vDSP_zvphas              vDSP_zvphas
     91#define aubio_vDSP_vsadd               vDSP_vsadd
     92#define aubio_vDSP_vsmul               vDSP_vsmul
     93#define aubio_vDSP_create_fftsetup     vDSP_create_fftsetup
     94#define aubio_vDSP_destroy_fftsetup    vDSP_destroy_fftsetup
     95#define aubio_DSPComplex               DSPComplex
     96#define aubio_DSPSplitComplex          DSPSplitComplex
     97#define aubio_FFTSetup                 FFTSetup
     98#define aubio_vvsqrt                   vvsqrtf
     99#else
     100#define aubio_vDSP_ctoz                vDSP_ctozD
     101#define aubio_vDSP_fft_zrip            vDSP_fft_zripD
     102#define aubio_vDSP_ztoc                vDSP_ztocD
     103#define aubio_vDSP_zvmags              vDSP_zvmagsD
     104#define aubio_vDSP_zvphas              vDSP_zvphasD
     105#define aubio_vDSP_vsadd               vDSP_vsaddD
     106#define aubio_vDSP_vsmul               vDSP_vsmulD
     107#define aubio_vDSP_create_fftsetup     vDSP_create_fftsetupD
     108#define aubio_vDSP_destroy_fftsetup    vDSP_destroy_fftsetupD
     109#define aubio_DSPComplex               DSPDoubleComplex
     110#define aubio_DSPSplitComplex          DSPDoubleSplitComplex
     111#define aubio_FFTSetup                 FFTSetupD
     112#define aubio_vvsqrt                   vvsqrt
     113#endif /* HAVE_AUBIO_DOUBLE */
    84114
    85115#else                         // using OOURA
    … …  
    96126  real_t *in, *out;
    97127  fftw_plan pfw, pbw;
    98   fft_data_t * specdata;     /* complex spectral data */
     128  fft_data_t * specdata;      /* complex spectral data */
    99129#else
    100130#ifdef HAVE_ACCELERATE        // using ACCELERATE
    101131  int log2fftsize;
    102 #if !HAVE_AUBIO_DOUBLE
    103   FFTSetup fftSetup;
    104   DSPSplitComplex spec;
    105   float *in, *out;
    106 #else
    107   FFTSetupD fftSetup;
    108   DSPDoubleSplitComplex spec;
    109   double *in, *out;
    110 #endif
     132  aubio_FFTSetup fftSetup;
     133  aubio_DSPSplitComplex spec;
     134  smpl_t *in, *out;
    111135#else                         // using OOURA
    112136  smpl_t *in, *out;
    … …  
    120144aubio_fft_t * new_aubio_fft (uint_t winsize) {
    121145  aubio_fft_t * s = AUBIO_NEW(aubio_fft_t);
     146  if ((sint_t)winsize < 1) {
     147    AUBIO_ERR("fft: got winsize %d, but can not be < 1\n", winsize);
     148    goto beach;
     149  }
    122150#ifdef HAVE_FFTW3
    123151  uint_t i;
    … …  
    154182  s->compspec = new_fvec(winsize);
    155183  s->log2fftsize = (uint_t)log2f(s->fft_size);
    156 #if !HAVE_AUBIO_DOUBLE
    157   s->in = AUBIO_ARRAY(float, s->fft_size);
    158   s->out = AUBIO_ARRAY(float, s->fft_size);
    159   s->spec.realp = AUBIO_ARRAY(float, s->fft_size/2);
    160   s->spec.imagp = AUBIO_ARRAY(float, s->fft_size/2);
    161   s->fftSetup = vDSP_create_fftsetup(s->log2fftsize, FFT_RADIX2);
    162 #else
    163   s->in = AUBIO_ARRAY(double, s->fft_size);
    164   s->out = AUBIO_ARRAY(double, s->fft_size);
    165   s->spec.realp = AUBIO_ARRAY(double, s->fft_size/2);
    166   s->spec.imagp = AUBIO_ARRAY(double, s->fft_size/2);
    167   s->fftSetup = vDSP_create_fftsetupD(s->log2fftsize, FFT_RADIX2);
    168 #endif
    169 #else                         // using OOURA
     184  s->in = AUBIO_ARRAY(smpl_t, s->fft_size);
     185  s->out = AUBIO_ARRAY(smpl_t, s->fft_size);
     186  s->spec.realp = AUBIO_ARRAY(smpl_t, s->fft_size/2);
     187  s->spec.imagp = AUBIO_ARRAY(smpl_t, s->fft_size/2);
     188  s->fftSetup = aubio_vDSP_create_fftsetup(s->log2fftsize, FFT_RADIX2);
     189#else                         // using OOURA
     190  if (aubio_is_power_of_two(winsize) != 1) {
     191    AUBIO_ERR("fft: can only create with sizes power of two,"
     192              " requested %d\n", winsize);
     193    goto beach;
     194  }
    170195  s->winsize = winsize;
    171196  s->fft_size = winsize / 2 + 1;
    … …  
    179204#endif /* HAVE_FFTW3 */
    180205  return s;
     206beach:
     207  AUBIO_FREE(s);
     208  return NULL;
    181209}
    182210
    … …  
    192220  AUBIO_FREE(s->spec.realp);
    193221  AUBIO_FREE(s->spec.imagp);
    194 #if !HAVE_AUBIO_DOUBLE
    195   vDSP_destroy_fftsetup(s->fftSetup);
    196 #else
    197   vDSP_destroy_fftsetupD(s->fftSetup);
    198 #endif
     222  aubio_vDSP_destroy_fftsetup(s->fftSetup);
    199223#else                         // using OOURA
    200224  AUBIO_FREE(s->w);
    … …  
    219243void aubio_fft_do_complex(aubio_fft_t * s, fvec_t * input, fvec_t * compspec) {
    220244  uint_t i;
     245#ifndef HAVE_MEMCPY_HACKS
    221246  for (i=0; i < s->winsize; i++) {
    222247    s->in[i] = input->data[i];
    223248  }
     249#else
     250  memcpy(s->in, input->data, s->winsize * sizeof(smpl_t));
     251#endif /* HAVE_MEMCPY_HACKS */
    224252#ifdef HAVE_FFTW3             // using FFTW3
    225253  fftw_execute(s->pfw);
    … …  
    238266#else /* HAVE_FFTW3 */
    239267#ifdef HAVE_ACCELERATE        // using ACCELERATE
    240 #if !HAVE_AUBIO_DOUBLE
    241268  // convert real data to even/odd format used in vDSP
    242   vDSP_ctoz((DSPComplex*)s->in, 2, &s->spec, 1, s->fft_size/2);
     269  aubio_vDSP_ctoz((aubio_DSPComplex*)s->in, 2, &s->spec, 1, s->fft_size/2);
    243270  // compute the FFT
    244   vDSP_fft_zrip(s->fftSetup, &s->spec, 1, s->log2fftsize, FFT_FORWARD);
    245 #else
    246   // convert real data to even/odd format used in vDSP
    247   vDSP_ctozD((DSPDoubleComplex*)s->in, 2, &s->spec, 1, s->fft_size/2);
    248   // compute the FFT
    249   vDSP_fft_zripD(s->fftSetup, &s->spec, 1, s->log2fftsize, FFT_FORWARD);
    250 #endif
     271  aubio_vDSP_fft_zrip(s->fftSetup, &s->spec, 1, s->log2fftsize, FFT_FORWARD);
    251272  // convert from vDSP complex split to [ r0, r1, ..., rN, iN-1, .., i2, i1]
    252273  compspec->data[0] = s->spec.realp[0];
    … …  
    258279  // apply scaling
    259280  smpl_t scale = 1./2.;
    260 #if !HAVE_AUBIO_DOUBLE
    261   vDSP_vsmul(compspec->data, 1, &scale, compspec->data, 1, s->fft_size);
    262 #else
    263   vDSP_vsmulD(compspec->data, 1, &scale, compspec->data, 1, s->fft_size);
    264 #endif
     281  aubio_vDSP_vsmul(compspec->data, 1, &scale, compspec->data, 1, s->fft_size);
    265282#else                         // using OOURA
    266283  rdft(s->winsize, 1, s->in, s->ip, s->w);
    … …  
    305322    s->out[2 * i + 1] = compspec->data[s->winsize - i];
    306323  }
    307 #if !HAVE_AUBIO_DOUBLE
    308324  // convert to split complex format used in vDSP
    309   vDSP_ctoz((DSPComplex*)s->out, 2, &s->spec, 1, s->fft_size/2);
     325  aubio_vDSP_ctoz((aubio_DSPComplex*)s->out, 2, &s->spec, 1, s->fft_size/2);
    310326  // compute the FFT
    311   vDSP_fft_zrip(s->fftSetup, &s->spec, 1, s->log2fftsize, FFT_INVERSE);
     327  aubio_vDSP_fft_zrip(s->fftSetup, &s->spec, 1, s->log2fftsize, FFT_INVERSE);
    312328  // convert result to real output
    313   vDSP_ztoc(&s->spec, 1, (DSPComplex*)output->data, 2, s->fft_size/2);
     329  aubio_vDSP_ztoc(&s->spec, 1, (aubio_DSPComplex*)output->data, 2, s->fft_size/2);
    314330  // apply scaling
    315331  smpl_t scale = 1.0 / s->winsize;
    316   vDSP_vsmul(output->data, 1, &scale, output->data, 1, s->fft_size);
    317 #else
    318   // convert to split complex format used in vDSP
    319   vDSP_ctozD((DSPDoubleComplex*)s->out, 2, &s->spec, 1, s->fft_size/2);
    320   // compute the FFT
    321   vDSP_fft_zripD(s->fftSetup, &s->spec, 1, s->log2fftsize, FFT_INVERSE);
    322   // convert result to real output
    323   vDSP_ztocD(&s->spec, 1, (DSPDoubleComplex*)output->data, 2, s->fft_size/2);
    324   // apply scaling
    325   smpl_t scale = 1.0 / s->winsize;
    326   vDSP_vsmulD(output->data, 1, &scale, output->data, 1, s->fft_size);
    327 #endif
     332  aubio_vDSP_vsmul(output->data, 1, &scale, output->data, 1, s->fft_size);
    328333#else                         // using OOURA
    329334  smpl_t scale = 2.0 / s->winsize;
    … …  
    392397  uint_t i;
    393398  for (i = 0; i < compspec->length / 2 + 1; i++) {
    394     compspec->data[i] = 
     399    compspec->data[i] =
    395400      spectrum->norm[i]*COS(spectrum->phas[i]);
    396401  }

  • src/spectral/fft.h

    r65c352e r695e171  
    1919*/
    2020
    21 /** \file 
     21/** \file
    2222
    2323  Fast Fourier Transform
    … …  
    4040
    4141/** FFT object
    42  
     42
    4343  This object computes forward and backward FFTs.
    4444
    … …  
    5252*/
    5353aubio_fft_t * new_aubio_fft (uint_t size);
    54 /** delete FFT object 
     54/** delete FFT object
    5555
    5656  \param s fft object as returned by new_aubio_fft
    … …  
    6262
    6363  \param s fft object as returned by new_aubio_fft
    64   \param input input signal 
    65   \param spectrum output spectrum 
     64  \param input input signal
     65  \param spectrum output spectrum
    6666
    6767*/
    … …  
    7070
    7171  \param s fft object as returned by new_aubio_fft
    72   \param spectrum input spectrum 
    73   \param output output signal 
     72  \param spectrum input spectrum
     73  \param output output signal
    7474
    7575*/
    … …  
    7979
    8080  \param s fft object as returned by new_aubio_fft
    81   \param input real input signal 
     81  \param input real input signal
    8282  \param compspec complex output fft real/imag
    8383
    … …  
    8787
    8888  \param s fft object as returned by new_aubio_fft
    89   \param compspec real/imag input fft array 
    90   \param output real output array 
     89  \param compspec real/imag input fft array
     90  \param output real output array
    9191
    9292*/
    9393void aubio_fft_rdo_complex (aubio_fft_t *s, fvec_t * compspec, fvec_t * output);
    9494
    95 /** convert real/imag spectrum to norm/phas spectrum 
     95/** convert real/imag spectrum to norm/phas spectrum
    9696
    97   \param compspec real/imag input fft array 
    98   \param spectrum cvec norm/phas output array 
     97  \param compspec real/imag input fft array
     98  \param spectrum cvec norm/phas output array
    9999
    100100*/
    101101void aubio_fft_get_spectrum(fvec_t * compspec, cvec_t * spectrum);
    102 /** convert real/imag spectrum to norm/phas spectrum 
     102/** convert real/imag spectrum to norm/phas spectrum
    103103
    104   \param compspec real/imag input fft array 
    105   \param spectrum cvec norm/phas output array 
     104  \param compspec real/imag input fft array
     105  \param spectrum cvec norm/phas output array
    106106
    107107*/
    108108void aubio_fft_get_realimag(cvec_t * spectrum, fvec_t * compspec);
    109109
    110 /** compute phas spectrum from real/imag parts 
     110/** compute phas spectrum from real/imag parts
    111111
    112   \param compspec real/imag input fft array 
    113   \param spectrum cvec norm/phas output array 
     112  \param compspec real/imag input fft array
     113  \param spectrum cvec norm/phas output array
    114114
    115115*/
    116116void aubio_fft_get_phas(fvec_t * compspec, cvec_t * spectrum);
    117 /** compute imaginary part from the norm/phas cvec 
     117/** compute imaginary part from the norm/phas cvec
    118118
    119   \param spectrum norm/phas input array 
    120   \param compspec real/imag output fft array 
     119  \param spectrum norm/phas input array
     120  \param compspec real/imag output fft array
    121121
    122122*/
    123123void aubio_fft_get_imag(cvec_t * spectrum, fvec_t * compspec);
    124124
    125 /** compute norm component from real/imag parts 
     125/** compute norm component from real/imag parts
    126126
    127   \param compspec real/imag input fft array 
    128   \param spectrum cvec norm/phas output array 
     127  \param compspec real/imag input fft array
     128  \param spectrum cvec norm/phas output array
    129129
    130130*/
    131131void aubio_fft_get_norm(fvec_t * compspec, cvec_t * spectrum);
    132 /** compute real part from norm/phas components 
     132/** compute real part from norm/phas components
    133133
    134   \param spectrum norm/phas input array 
    135   \param compspec real/imag output fft array 
     134  \param spectrum norm/phas input array
     135  \param compspec real/imag output fft array
    136136
    137137*/

  • src/spectral/filterbank_mel.h

    r65c352e r695e171  
    5959
    6060  The filter coefficients are built according to Malcolm Slaney's Auditory
    61   Toolbox, available at http://cobweb.ecn.purdue.edu/~malcolm/interval/1998-010/
     61  Toolbox, available at http://engineering.purdue.edu/~malcolm/interval/1998-010/
    6262  (see file mfcc.m).
    6363

  • src/spectral/mfcc.h

    r65c352e r695e171  
    2222/** \file
    2323
    24   Mel-frequency cepstrum coefficients object
     24  Mel-Frequency Cepstrum Coefficients object
     25
     26  This object computes MFCC coefficients on an input cvec_t.
     27
     28  The implementation follows the specifications established by Malcolm Slaney
     29  in its Auditory Toolbox, available online (see file mfcc.m).
     30
     31  http://engineering.ecn.purdue.edu/~malcolm/interval/1998-010/
    2532
    2633  \example spectral/test-mfcc.c

  • src/spectral/phasevoc.h

    r65c352e r695e171  
    5757
    5858/** compute spectral frame
    59  
     59
    6060  This function accepts an input vector of size [hop_s]. The
    6161  analysis buffer is rotated and filled with the new data. After windowing of
    … …  
    6464
    6565  \param pv phase vocoder object as returned by new_aubio_pvoc
    66   \param in new input signal (hop_s long) 
     66  \param in new input signal (hop_s long)
    6767  \param fftgrain output spectral frame
    6868
    … …  
    7575  synthesis is then computed using the previously synthetised frames, and the
    7676  output stored in out.
    77  
     77
    7878  \param pv phase vocoder object as returned by new_aubio_pvoc
    7979  \param fftgrain input spectral frame
    80   \param out output signal (hop_s long) 
     80  \param out output signal (hop_s long)
    8181
    8282*/
    … …  
    9898#ifdef __cplusplus
    9999}
    100 #endif 
     100#endif
    101101
    102102#endif /* _AUBIO_PHASEVOC_H */

  • src/spectral/tss.h

    r65c352e r695e171  
    6363
    6464/** split input into transient and steady states components
    65  
     65
    6666  \param o tss object as returned by new_aubio_tss()
    6767  \param input input spectral frame
    … …  
    7373    cvec_t * stead);
    7474
    75 /** set transient / steady state separation threshold 
    76  
     75/** set transient / steady state separation threshold
     76
    7777  \param o tss object as returned by new_aubio_tss()
    7878  \param thrs new threshold value
    … …  
    8282
    8383/** set parameter a, defaults to 3
    84  
     84
    8585  \param o tss object as returned by new_aubio_tss()
    8686  \param alpha new value for alpha parameter
    … …  
    9090
    9191/** set parameter b, defaults to 3
    92  
     92
    9393  \param o tss object as returned by new_aubio_tss()
    9494  \param beta new value for beta parameter

  • src/tempo/beattracking.c

    r65c352e r695e171  
    136136  uint_t numelem = 4;
    137137
    138   smpl_t phase;                 // beat alignment (step - lastbeat) 
    139   smpl_t beat;                  // beat position 
     138  smpl_t phase;                 // beat alignment (step - lastbeat)
     139  smpl_t beat;                  // beat position
    140140  smpl_t bp;                    // beat period
    141141  uint_t a, b;                  // used to build shift invariant comb filterbank
    … …  
    227227  beat = bp - phase;
    228228
    229   // AUBIO_DBG ("bp: %f, phase: %f, lastbeat: %f, step: %d, winlen: %d\n", 
     229  // AUBIO_DBG ("bp: %f, phase: %f, lastbeat: %f, step: %d, winlen: %d\n",
    230230  //    bp, phase, bt->lastbeat, step, winlen);
    231231
    … …  
    319319  }
    320320
    321   //now look for step change - i.e. a difference between gp and rp that 
     321  //now look for step change - i.e. a difference between gp and rp that
    322322  // is greater than 2*constthresh - always true in first case, since gp = 0
    323323  if (counter == 0) {
    … …  
    342342    }
    343343  } else if (counter > 0) {
    344     //if counter doesn't = 1, 
     344    //if counter doesn't = 1,
    345345    counter = counter - 1;
    346346  }

  • src/tempo/beattracking.h

    r65c352e r695e171  
    11/*
    2   Copyright (C) 2003-2013 Matthew Davies and Paul Brossier <piem@aubio.org>
     2  Copyright (C) 2003-2015 Matthew Davies and Paul Brossier <piem@aubio.org>
    33
    44  This file is part of aubio.
    … …  
    3535
    3636  \example tempo/test-beattracking.c
    37  
     37
    3838*/
    3939#ifndef _AUBIO_BEATTRACKING_H
    … …  
    5050
    5151  \param winlen length of the onset detection window
    52   \param hop_size number of onset detection samples [512] 
     52  \param hop_size number of onset detection samples [512]
    5353  \param samplerate samplerate of the input signal
    5454
    … …  
    5757    uint_t samplerate);
    5858
    59 /** track the beat 
     59/** track the beat
    6060
    6161  \param bt beat tracking object
    6262  \param dfframes current input detection function frame, smoothed by
    63   adaptive median threshold. 
    64   \param out stored detected beat locations 
     63  adaptive median threshold.
     64  \param out stored detected beat locations
    6565
    6666*/
    … …  
    7878smpl_t aubio_beattracking_get_bpm(aubio_beattracking_t * bt);
    7979
    80 /** get current tempo confidence 
     80/** get current tempo confidence
    8181
    8282  \param bt beat tracking object

  • src/temporal/a_weighting.h

    r65c352e r695e171  
    11/*
    2   Copyright (C) 2003-2013 Paul Brossier <piem@aubio.org>
     2  Copyright (C) 2003-2015 Paul Brossier <piem@aubio.org>
    33
    44  This file is part of aubio.
    … …  
    2525
    2626  A-weighting filter coefficients
    27  
     27
    2828  This file creates an A-weighting digital filter, which reduces low and high
    2929  frequencies and enhance the middle ones to reflect the ability of the human
    3030  hearing.
    31  
     31
    3232  The implementation is based on the following standard:
    3333
    3434    - IEC/CD 1672: Electroacoustics-Sound Level Meters, IEC, Geneva, Nov.  1996,
    3535  for A- and C-weighting filters.
    36  
     36
    3737  See also:
    38  
     38
    3939    - <a href="http://en.wikipedia.org/wiki/A-weighting">A-Weighting on
    4040  Wikipedia</a>
    … …  
    4343    - <a href="http://www.mathworks.com/matlabcentral/fileexchange/69">Christophe
    4444  Couvreur's 'octave' toolbox</a>
    45  
     45
    4646  The coefficients in this file have been computed using Christophe Couvreur's
    4747  scripts in octave 3.0 (debian package 1:3.0.5-6+b2 with octave-signal
    … …  
    6363/** create new A-design filter
    6464
    65   \param samplerate sampling frequency of the signal to filter. Should be one of 
     65  \param samplerate sampling frequency of the signal to filter. Should be one of
    6666  8000, 11025, 16000, 22050, 24000, 32000, 44100, 48000, 88200, 96000, and
    6767  192000 Hz
    … …  
    7575
    7676  \param f filter object to get coefficients from
    77   \param samplerate sampling frequency of the signal to filter. Should be one of 
     77  \param samplerate sampling frequency of the signal to filter. Should be one of
    7878  8000, 11025, 16000, 22050, 24000, 32000, 44100, 48000, 88200, 96000, and
    7979  192000 Hz

  • src/temporal/biquad.h

    r65c352e r695e171  
    11/*
    2   Copyright (C) 2003-2013 Paul Brossier <piem@aubio.org>
     2  Copyright (C) 2003-2015 Paul Brossier <piem@aubio.org>
    33
    44  This file is part of aubio.
    … …  
    2222#define _AUBIO_FILTER_BIQUAD_H
    2323
    24 /** \file 
     24/** \file
    2525
    2626  Second order Infinite Impulse Response filter
    2727
    2828  This file implements a normalised biquad filter (second order IIR):
    29  
     29
    3030  \f$ y[n] = b_0 x[n] + b_1 x[n-1] + b_2 x[n-2] - a_1 y[n-1] - a_2 y[n-2] \f$
    3131

  • src/temporal/c_weighting.h

    r65c352e r695e171  
    11/*
    2   Copyright (C) 2003-2013 Paul Brossier <piem@aubio.org>
     2  Copyright (C) 2003-2015 Paul Brossier <piem@aubio.org>
    33
    44  This file is part of aubio.
    … …  
    2525
    2626  C-weighting filter coefficients
    27  
     27
    2828  This file creates a C-weighting digital filter, which reduces low and high
    2929  frequencies and enhance the middle ones to reflect the ability of the human
    3030  hearing.
    31  
     31
    3232  The implementation is based on the following standard:
    3333
    3434    - IEC/CD 1672: Electroacoustics-Sound Level Meters, IEC, Geneva, Nov.  1996,
    3535  for A- and C-weighting filters.
    36  
     36
    3737  See also:
    38  
     38
    3939    - <a href="http://en.wikipedia.org/wiki/A-weighting">A-Weighting on
    4040  Wikipedia</a>
    … …  
    4343    - <a href="http://www.mathworks.com/matlabcentral/fileexchange/69">Christophe
    4444  Couvreur's 'octave' toolbox</a>
    45  
     45
    4646  The coefficients in this file have been computed using Christophe Couvreur's
    4747  scripts in octave 3.0 (debian package 1:3.0.5-6+b2 with octave-signal
    … …  
    6363/** create new C-design filter
    6464
    65   \param samplerate sampling frequency of the signal to filter. Should be one of 
     65  \param samplerate sampling frequency of the signal to filter. Should be one of
    6666  8000, 11025, 16000, 22050, 24000, 32000, 44100, 48000, 88200, 96000, and
    6767  192000 Hz
    … …  
    7575
    7676  \param f filter object to get coefficients from
    77   \param samplerate sampling frequency of the signal to filter. Should be one of 
     77  \param samplerate sampling frequency of the signal to filter. Should be one of
    7878  8000, 11025, 16000, 22050, 24000, 32000, 44100, 48000, 88200, 96000, and
    7979  192000 Hz

  • src/temporal/filter.h

    r65c352e r695e171  
    11/*
    2   Copyright (C) 2003-2013 Paul Brossier <piem@aubio.org>
     2  Copyright (C) 2003-2015 Paul Brossier <piem@aubio.org>
    33
    44  This file is part of aubio.
    … …  
    2222#define _AUBIO_FILTER_H
    2323
    24 /** \file 
     24/** \file
    2525
    2626  Digital filter
    … …  
    2828  This object stores a digital filter of order \f$n\f$.
    2929  It contains the following data:
    30     - \f$ n*1 b_i \f$ feedforward coefficients 
    31     - \f$ n*1 a_i \f$ feedback coefficients 
     30    - \f$ n*1 b_i \f$ feedforward coefficients
     31    - \f$ n*1 a_i \f$ feedback coefficients
    3232    - \f$ n*c x_i \f$ input signal
    3333    - \f$ n*c y_i \f$ output signal
    … …  
    4141  The function aubio_filter_do_outplace() computes the following output signal
    4242  \f$ y[n] \f$ from the input signal \f$ x[n] \f$:
    43  
     43
    4444  \f{eqnarray*}{
    4545     y[n] = b_0 x[n] & + & b_1 x[n-1] + b_2 x[n-2] + ... + b_P x[n-P] \\
    … …  
    5454  operation.
    5555
    56   Some convenience functions are provided: 
     56  Some convenience functions are provided:
    5757    - new_aubio_filter_a_weighting() and aubio_filter_set_a_weighting(),
    5858    - new_aubio_filter_c_weighting() and aubio_filter_set_c_weighting().
    … …  
    6060
    6161  \example temporal/test-filter.c
    62  
     62
    6363*/
    6464
    … …  
    164164
    165165/** delete a filter object
    166  
     166
    167167  \param f filter object to delete
    168168

  • src/temporal/resampler.h

    r65c352e r695e171  
    11/*
    2   Copyright (C) 2003-2013 Paul Brossier <piem@aubio.org>
     2  Copyright (C) 2003-2015 Paul Brossier <piem@aubio.org>
    33
    44  This file is part of aubio.
    … …  
    2323
    2424/** \file
    25  
     25
    2626 Resampling object
    2727
    2828 This object resamples an input vector into an output vector using
    2929 libsamplerate. See http://www.mega-nerd.com/SRC/
    30  
     30
    3131*/
    3232
    … …  
    3838typedef struct _aubio_resampler_t aubio_resampler_t;
    3939
    40 /** create resampler object 
     40/** create resampler object
    4141
    42   \param ratio output_sample_rate / input_sample_rate 
     42  \param ratio output_sample_rate / input_sample_rate
    4343  \param type libsamplerate resampling type, see http://www.mega-nerd.com/SRC/api_misc.html#Converters
    4444

  • src/types.h

    r65c352e r695e171  
    11/*
    2   Copyright (C) 2003-2013 Paul Brossier <piem@aubio.org>
     2  Copyright (C) 2003-2015 Paul Brossier <piem@aubio.org>
    33
    44  This file is part of aubio.
    … …  
    2323
    2424/** \file
    25  
     25
    2626  Definition of data types used in aubio
    27  
     27
    2828*/
    2929

  • src/utils/parameter.h

    r65c352e r695e171  
    6161uint_t aubio_parameter_set_target_value ( aubio_parameter_t * param, smpl_t value );
    6262
    63 /** get next parameter 
     63/** get next parameter
    6464
    6565  \param param parameter, created by ::new_aubio_parameter

  • src/utils/scale.h

    r65c352e r695e171  
    2121/** \file
    2222
    23  Vector scaling function 
    24  
     23 Vector scaling function
     24
    2525 This object, inspired from the scale object in FTS, the jMax engine, scales
    2626 the values of a vector according to an affine function defined as follow:
    27  
    28  \f$ y = (x - ilow)*(ohig-olow)/(ihig-ilow) + olow \f$ 
    29  
     27
     28 \f$ y = (x - ilow)*(ohig-olow)/(ihig-ilow) + olow \f$
     29
    3030*/
    3131#ifndef _AUBIO_SCALE_H
    … …  
    4040
    4141/** create a scale object
    42  
     42
    4343  \param flow lower value of output function
    4444  \param fhig higher value of output function
    … …  
    4949aubio_scale_t * new_aubio_scale(smpl_t flow, smpl_t fhig,
    5050    smpl_t ilow, smpl_t ihig);
    51 /** delete a scale object 
     51/** delete a scale object
    5252
    5353  \param s scale object as returned by new_aubio_scale
    … …  
    7676#ifdef __cplusplus
    7777}
    78 #endif 
     78#endif
    7979
    8080#endif /* _AUBIO_SCALE_H */

  • src/vecutils.h

    r65c352e r695e171  
    11/*
    2   Copyright (C) 2009-2013 Paul Brossier <piem@aubio.org>
     2  Copyright (C) 2009-2015 Paul Brossier <piem@aubio.org>
    33
    44  This file is part of aubio.
Note: See TracChangeset for help on using the changeset viewer.