Changeset c03d191


Ignore:
Timestamp:
Nov 17, 2018, 10:19:27 PM (13 months ago)
Author:
Paul Brossier <piem@piem.org>
Branches:
feature/constantq
Children:
d1d4ad4
Parents:
088760e (diff), a114fe0 (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 'master' into feature/constantq

Files:
3 added
2 deleted
42 edited

Legend:

Unmodified
Added
Removed
  • .gitignore

    r088760e rc03d191  
    4949python/tests/sounds
    5050aubio.egg-info
     51.eggs
     52.cache
  • MANIFEST.in

    r088760e rc03d191  
    22include python/README.md
    33include this_version.py
     4include waf
     5recursive-include waflib *.py
    46include Makefile wscript */wscript_build
    5 include waf waflib/* waflib/*/*
    6 exclude waflib/__pycache__/*
    77include aubio.pc.in
    88include nose2.cfg
     
    1313include tests/*.h tests/*/*.c tests/*/*/*.c
    1414include python/ext/*.h
    15 include python/__init__.py
    16 include python/lib/__init__.py
    17 include python/lib/moresetuptools.py
    18 include python/lib/gen_external.py
    19 include python/lib/gen_code.py
     15recursive-include python *.py
     16include python/README.md
    2017include python/tests/run_all_tests
    21 include python/tests/*.py
    2218include python/tests/eval_pitch
    23 include python/demos/*.py
    2419include python/tests/*.expected
    2520include doc/*.txt doc/*.rst doc/*.cfg doc/Makefile doc/make.bat doc/conf.py
  • Makefile

    r088760e rc03d191  
    234234        uninstall_python \
    235235        check_clean_python
     236
     237coverage_cycle: coverage_zero_counters coverage_report
     238
     239coverage_zero_counters:
     240        lcov --zerocounters --directory .
    236241
    237242coverage: export CFLAGS=--coverage
     
    247252        lcov -a build/coverage_python.info -a build/coverage_lib.info -o build/coverage.info
    248253
     254# make sure we don't build the doc, which builds a temporary python module
     255coverage_report: export WAFOPTS += --disable-docs
    249256coverage_report: coverage
    250257        genhtml build/coverage.info --output-directory lcov_html
  • doc/py_io.rst

    r088760e rc03d191  
    4040    down-mixed to produce the new samples.
    4141
    42     return: A tuple of one array of samples and one integer.
     42    :returns: A tuple of one array of samples and one integer.
    4343    :rtype: (array, int)
    4444
  • doc/py_utils.rst

    r088760e rc03d191  
    2828
    2929.. autofunction:: miditofreq
     30
     31.. python/ext/py-musicutils.h
     32
     33.. autofunction:: meltohz
     34
     35.. autofunction:: hztomel
    3036
    3137.. python/ext/aubiomodule.c
  • python/demos/demo_filter.py

    r088760e rc03d191  
    44import os.path
    55import aubio
     6
    67
    78def apply_filter(path, target):
     
    2829        total_frames += read
    2930        # end of file reached
    30         if read < s.hop_size: break
     31        if read < s.hop_size:
     32            break
    3133
    3234    # print some info
     
    3436    input_str = "input: {:s} ({:.2f} s, {:d} Hz)"
    3537    output_str = "output: {:s}, A-weighting filtered ({:d} frames total)"
    36     print (input_str.format(s.uri, duration, samplerate))
    37     print (output_str.format(o.uri, total_frames))
     38    print(input_str.format(s.uri, duration, samplerate))
     39    print(output_str.format(o.uri, total_frames))
    3840
    3941if __name__ == '__main__':
    4042    usage = "{:s} <input_file> [output_file]".format(sys.argv[0])
    4143    if not 1 < len(sys.argv) < 4:
    42         print (usage)
     44        print(usage)
    4345        sys.exit(1)
    4446    if len(sys.argv) < 3:
  • python/demos/demo_filterbank.py

    r088760e rc03d191  
    11#! /usr/bin/env python
    22
    3 from aubio import filterbank, fvec
    4 from pylab import loglog, show, xlim, ylim, xlabel, ylabel, title
    5 from numpy import vstack, arange
     3"""Create a filterbank from a list of frequencies.
    64
     5This demo uses `aubio.filterbank.set_triangle_bands` to build a set of
     6triangular filters from a list of frequencies.
     7
     8The filterbank coefficients are then modified before being displayed."""
     9
     10import aubio
     11import numpy as np
     12import matplotlib.pyplot as plt
     13
     14# sampling rate and size of the fft
     15samplerate = 48000
    716win_s = 2048
    8 samplerate = 48000
    917
     18# define a list of custom frequency
    1019freq_list = [60, 80, 200, 400, 800, 1600, 3200, 6400, 12800, 24000]
     20# number of filters to create
    1121n_filters = len(freq_list) - 2
    1222
    13 f = filterbank(n_filters, win_s)
    14 freqs = fvec(freq_list)
     23# create a new filterbank
     24f = aubio.filterbank(n_filters, win_s)
     25freqs = aubio.fvec(freq_list)
    1526f.set_triangle_bands(freqs, samplerate)
    1627
     28# get the coefficients from the filterbank
    1729coeffs = f.get_coeffs()
    18 coeffs[4] *= 5.
    19 
     30# apply a gain to fifth band
     31coeffs[4] *= 6.
     32# load the modified coeffs into the filterbank
    2033f.set_coeffs(coeffs)
    2134
    22 times = vstack([arange(win_s // 2 + 1) * samplerate / win_s] * n_filters)
    23 title('Bank of filters built using a simple list of boundaries\nThe middle band has been amplified by 2.')
    24 loglog(times.T, f.get_coeffs().T, '.-')
    25 xlim([50, samplerate/2])
    26 ylim([1.0e-6, 2.0e-2])
    27 xlabel('log frequency (Hz)')
    28 ylabel('log amplitude')
    29 
    30 show()
     35# display the band gains in a loglog plot
     36freqs = np.vstack([np.arange(win_s // 2 + 1) * samplerate / win_s] * n_filters)
     37plt.title('filterbank built from a list of frequencies\n'
     38          'The 5th band has been amplified by a factor 6.')
     39plt.loglog(freqs.T, f.get_coeffs().T, '.-')
     40plt.xlim([50, samplerate/2])
     41plt.ylim([1.0e-6, 2.0e-2])
     42plt.xlabel('log frequency (Hz)')
     43plt.ylabel('log amplitude')
     44plt.show()
  • python/demos/demo_source_simple.py

    r088760e rc03d191  
    11#! /usr/bin/env python
     2
     3"""A simple example using aubio.source."""
     4
    25import sys
    36import aubio
    47
    5 samplerate = 0 # use original source samplerate
    6 hop_size = 256 # number of frames to read in one block
     8samplerate = 0  # use original source samplerate
     9hop_size = 256  # number of frames to read in one block
    710src = aubio.source(sys.argv[1], samplerate, hop_size)
    811total_frames = 0
    912
    1013while True:
    11     samples, read = src()     # read hop_size new samples from source
    12     total_frames += read      # increment total number of frames
    13     if read < hop_size: break # end of file reached
     14    samples, read = src()  # read hop_size new samples from source
     15    total_frames += read   # increment total number of frames
     16    if read < hop_size:    # end of file reached
     17        break
    1418
    1519fmt_string = "read {:d} frames at {:d}Hz from {:s}"
    16 print (fmt_string.format(total_frames, src.samplerate, src.uri))
     20print(fmt_string.format(total_frames, src.samplerate, src.uri))
  • python/ext/aubiomodule.c

    r088760e rc03d191  
    373373  {"shift", Py_aubio_shift, METH_VARARGS, Py_aubio_shift_doc},
    374374  {"ishift", Py_aubio_ishift, METH_VARARGS, Py_aubio_ishift_doc},
     375  {"hztomel", Py_aubio_hztomel, METH_VARARGS|METH_KEYWORDS, Py_aubio_hztomel_doc},
     376  {"meltohz", Py_aubio_meltohz, METH_VARARGS|METH_KEYWORDS, Py_aubio_meltohz_doc},
     377  {"hztomel_htk", Py_aubio_hztomel_htk, METH_VARARGS, Py_aubio_hztomel_htk_doc},
     378  {"meltohz_htk", Py_aubio_meltohz_htk, METH_VARARGS, Py_aubio_meltohz_htk_doc},
    375379  {NULL, NULL, 0, NULL} /* Sentinel */
    376380};
  • python/ext/py-filterbank.c

    r088760e rc03d191  
    139139      &(self->freqs), samplerate);
    140140  if (err > 0) {
    141     PyErr_SetString (PyExc_ValueError,
    142         "error when running set_triangle_bands");
     141    if (PyErr_Occurred() == NULL) {
     142      PyErr_SetString (PyExc_ValueError, "error running set_triangle_bands");
     143    } else {
     144      // change the RuntimeError into ValueError
     145      PyObject *type, *value, *traceback;
     146      PyErr_Fetch(&type, &value, &traceback);
     147      PyErr_Restore(PyExc_ValueError, value, traceback);
     148    }
    143149    return NULL;
    144150  }
     
    151157  uint_t err = 0;
    152158
    153   uint_t samplerate;
    154   if (!PyArg_ParseTuple (args, "I", &samplerate)) {
     159  smpl_t samplerate;
     160  if (!PyArg_ParseTuple (args, AUBIO_NPY_SMPL_CHR, &samplerate)) {
    155161    return NULL;
    156162  }
     
    158164  err = aubio_filterbank_set_mel_coeffs_slaney (self->o, samplerate);
    159165  if (err > 0) {
    160     PyErr_SetString (PyExc_ValueError,
    161         "error when running set_mel_coeffs_slaney");
     166    if (PyErr_Occurred() == NULL) {
     167      PyErr_SetString (PyExc_ValueError, "error running set_mel_coeffs_slaney");
     168    } else {
     169      // change the RuntimeError into ValueError
     170      PyObject *type, *value, *traceback;
     171      PyErr_Fetch(&type, &value, &traceback);
     172      PyErr_Restore(PyExc_ValueError, value, traceback);
     173    }
     174    return NULL;
     175  }
     176  Py_RETURN_NONE;
     177}
     178
     179static PyObject *
     180Py_filterbank_set_mel_coeffs (Py_filterbank * self, PyObject *args)
     181{
     182  uint_t err = 0;
     183
     184  smpl_t samplerate;
     185  smpl_t freq_min;
     186  smpl_t freq_max;
     187  if (!PyArg_ParseTuple (args, AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR
     188        AUBIO_NPY_SMPL_CHR, &samplerate, &freq_min, &freq_max)) {
     189    return NULL;
     190  }
     191
     192  err = aubio_filterbank_set_mel_coeffs (self->o, samplerate,
     193      freq_min, freq_max);
     194  if (err > 0) {
     195    if (PyErr_Occurred() == NULL) {
     196      PyErr_SetString (PyExc_ValueError, "error running set_mel_coeffs");
     197    } else {
     198      // change the RuntimeError into ValueError
     199      PyObject *type, *value, *traceback;
     200      PyErr_Fetch(&type, &value, &traceback);
     201      PyErr_Restore(PyExc_ValueError, value, traceback);
     202    }
     203    return NULL;
     204  }
     205  Py_RETURN_NONE;
     206}
     207
     208static PyObject *
     209Py_filterbank_set_mel_coeffs_htk (Py_filterbank * self, PyObject *args)
     210{
     211  uint_t err = 0;
     212
     213  smpl_t samplerate;
     214  smpl_t freq_min;
     215  smpl_t freq_max;
     216  if (!PyArg_ParseTuple (args, AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR
     217        AUBIO_NPY_SMPL_CHR, &samplerate, &freq_min, &freq_max)) {
     218    return NULL;
     219  }
     220
     221  err = aubio_filterbank_set_mel_coeffs_htk (self->o, samplerate,
     222      freq_min, freq_max);
     223  if (err > 0) {
     224    if (PyErr_Occurred() == NULL) {
     225      PyErr_SetString (PyExc_ValueError, "error running set_mel_coeffs_htk");
     226    } else {
     227      // change the RuntimeError into ValueError
     228      PyObject *type, *value, *traceback;
     229      PyErr_Fetch(&type, &value, &traceback);
     230      PyErr_Restore(PyExc_ValueError, value, traceback);
     231    }
    162232    return NULL;
    163233  }
     
    194264  return (PyObject *)PyAubio_CFmatToArray(
    195265      aubio_filterbank_get_coeffs (self->o) );
     266}
     267
     268static PyObject *
     269Py_filterbank_set_power(Py_filterbank *self, PyObject *args)
     270{
     271  uint_t power;
     272
     273  if (!PyArg_ParseTuple (args, "I", &power)) {
     274    return NULL;
     275  }
     276  if(aubio_filterbank_set_power (self->o, power)) {
     277    if (PyErr_Occurred() == NULL) {
     278      PyErr_SetString (PyExc_ValueError,
     279          "error running filterbank.set_power");
     280    } else {
     281      // change the RuntimeError into ValueError
     282      PyObject *type, *value, *traceback;
     283      PyErr_Fetch(&type, &value, &traceback);
     284      PyErr_Restore(PyExc_ValueError, value, traceback);
     285    }
     286    return NULL;
     287  }
     288  Py_RETURN_NONE;
     289}
     290
     291static PyObject *
     292Py_filterbank_set_norm(Py_filterbank *self, PyObject *args)
     293{
     294  uint_t playing;
     295
     296  if (!PyArg_ParseTuple (args, "I", &playing)) {
     297    return NULL;
     298  }
     299  if(aubio_filterbank_set_norm (self->o, playing)) {
     300    if (PyErr_Occurred() == NULL) {
     301      PyErr_SetString (PyExc_ValueError,
     302          "error running filterbank.set_power");
     303    } else {
     304      // change the RuntimeError into ValueError
     305      PyObject *type, *value, *traceback;
     306      PyErr_Fetch(&type, &value, &traceback);
     307      PyErr_Restore(PyExc_ValueError, value, traceback);
     308    }
     309    return NULL;
     310  }
     311  Py_RETURN_NONE;
    196312}
    197313
     
    201317  {"set_mel_coeffs_slaney", (PyCFunction) Py_filterbank_set_mel_coeffs_slaney,
    202318    METH_VARARGS, "set coefficients of filterbank as in Auditory Toolbox"},
     319  {"set_mel_coeffs", (PyCFunction) Py_filterbank_set_mel_coeffs,
     320    METH_VARARGS, "set coefficients of filterbank to linearly spaced mel scale"},
     321  {"set_mel_coeffs_htk", (PyCFunction) Py_filterbank_set_mel_coeffs_htk,
     322    METH_VARARGS, "set coefficients of filterbank to linearly spaced mel scale"},
    203323  {"get_coeffs", (PyCFunction) Py_filterbank_get_coeffs,
    204324    METH_NOARGS, "get coefficients of filterbank"},
    205325  {"set_coeffs", (PyCFunction) Py_filterbank_set_coeffs,
    206326    METH_VARARGS, "set coefficients of filterbank"},
     327  {"set_power", (PyCFunction) Py_filterbank_set_power,
     328    METH_VARARGS, "set power applied to filterbank input spectrum"},
     329  {"set_norm", (PyCFunction) Py_filterbank_set_norm,
     330    METH_VARARGS, "set norm applied to filterbank input spectrum"},
    207331  {NULL}
    208332};
  • python/ext/py-musicutils.c

    r088760e rc03d191  
    182182  return (PyObject *) PyAubio_CFvecToArray(&vec);
    183183}
     184
     185PyObject*
     186Py_aubio_hztomel(PyObject *self, PyObject *args, PyObject *kwds)
     187{
     188  smpl_t v;
     189  PyObject *htk = NULL;
     190  static char *kwlist[] = {"f", "htk", NULL};
     191  if (!PyArg_ParseTupleAndKeywords(args, kwds, AUBIO_NPY_SMPL_CHR "|O",
     192        kwlist, &v, &htk))
     193  {
     194    return NULL;
     195  }
     196  if (htk != NULL && PyObject_IsTrue(htk) == 1)
     197    return Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_hztomel_htk(v));
     198  else
     199    return Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_hztomel(v));
     200}
     201
     202PyObject*
     203Py_aubio_meltohz(PyObject *self, PyObject *args, PyObject *kwds)
     204{
     205  smpl_t v;
     206  PyObject *htk = NULL;
     207  static char *kwlist[] = {"m", "htk", NULL};
     208  if (!PyArg_ParseTupleAndKeywords(args, kwds, AUBIO_NPY_SMPL_CHR "|O",
     209        kwlist, &v, &htk))
     210  {
     211    return NULL;
     212  }
     213  if (htk != NULL && PyObject_IsTrue(htk) == 1)
     214    return Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_meltohz_htk(v));
     215  else
     216    return Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_meltohz(v));
     217}
     218
     219PyObject*
     220Py_aubio_hztomel_htk(PyObject *self, PyObject *args)
     221{
     222  smpl_t v;
     223  if (!PyArg_ParseTuple(args, AUBIO_NPY_SMPL_CHR, &v)) {
     224    return NULL;
     225  }
     226  return Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_hztomel_htk(v));
     227}
     228
     229PyObject*
     230Py_aubio_meltohz_htk(PyObject *self, PyObject *args)
     231{
     232  smpl_t v;
     233  if (!PyArg_ParseTuple(args, AUBIO_NPY_SMPL_CHR, &v)) {
     234    return NULL;
     235  }
     236  return Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_meltohz_htk(v));
     237}
  • python/ext/py-musicutils.h

    r088760e rc03d191  
    301301PyObject * Py_aubio_ishift(PyObject *self, PyObject *args);
    302302
     303static char Py_aubio_hztomel_doc[] = ""
     304"hztomel(f, htk=False)\n"
     305"\n"
     306"Convert a scalar from frequency to mel scale.\n"
     307"\n"
     308"Parameters\n"
     309"----------\n"
     310"m : float\n"
     311"   input frequency, in Hz\n"
     312"htk : bool\n"
     313"   if `True`, use Htk mel scale instead of Slaney.\n"
     314"\n"
     315"Returns\n"
     316"-------\n"
     317"float\n"
     318"   output mel\n"
     319"\n"
     320"See Also\n"
     321"--------\n"
     322"meltohz\n"
     323"";
     324PyObject * Py_aubio_hztomel(PyObject *self, PyObject *args);
     325
     326static char Py_aubio_meltohz_doc[] = ""
     327"meltohz(m, htk=False)\n"
     328"\n"
     329"Convert a scalar from mel scale to frequency.\n"
     330"\n"
     331"Parameters\n"
     332"----------\n"
     333"m : float\n"
     334"   input mel\n"
     335"htk : bool\n"
     336"   if `True`, use Htk mel scale instead of Slaney.\n"
     337"\n"
     338"Returns\n"
     339"-------\n"
     340"float\n"
     341"   output frequency, in Hz\n"
     342"\n"
     343"See Also\n"
     344"--------\n"
     345"hztomel\n"
     346"";
     347PyObject * Py_aubio_meltohz(PyObject *self, PyObject *args);
     348
     349static char Py_aubio_hztomel_htk_doc[] = ""
     350"hztomel_htk(m)\n"
     351"\n"
     352"Same as `hztomel(m, htk=True)`\n"
     353"\n"
     354"See Also\n"
     355"--------\n"
     356"hztomel\n"
     357"";
     358PyObject * Py_aubio_hztomel_htk(PyObject *self, PyObject *args);
     359
     360static char Py_aubio_meltohz_htk_doc[] = ""
     361"meltohz_htk(m)\n"
     362"\n"
     363"Same as `meltohz(m, htk=True)`\n"
     364"\n"
     365"See Also\n"
     366"--------\n"
     367"meltohz\n"
     368"";
     369PyObject * Py_aubio_meltohz_htk(PyObject *self, PyObject *args);
     370
    303371#endif /* PY_AUBIO_MUSICUTILS_H */
  • python/ext/py-sink.c

    r088760e rc03d191  
    1515"sink(path, samplerate=44100, channels=1)\n"
    1616"\n"
    17 "Open `path` to write a WAV file.\n"
     17"Write audio samples to file.\n"
    1818"\n"
    1919"Parameters\n"
  • python/ext/py-source.c

    r088760e rc03d191  
    1919"source(path, samplerate=0, hop_size=512, channels=0)\n"
    2020"\n"
    21 "Create a new source, opening the given pathname for reading.\n"
     21"Read audio samples from a media file.\n"
    2222"\n"
    2323"`source` open the file specified in `path` and creates a callable\n"
     
    248248"Returns\n"
    249249"-------\n"
    250 "samples : numpy.ndarray, shape `(hop_size,)`, dtype aubio.float_type\n"
     250"samples : numpy.ndarray\n"
    251251"    `fvec` of size `hop_size` containing the new samples.\n"
    252252"read : int\n"
     
    284284"Returns\n"
    285285"-------\n"
    286 "samples : np.ndarray([hop_size, channels], dtype=aubio.float_type)\n"
     286"samples : numpy.ndarray\n"
    287287"    NumPy array of shape `(hop_size, channels)` containing the new\n"
    288288"    audio samples.\n"
  • python/lib/aubio/__init__.py

    r088760e rc03d191  
    2929from .midiconv import *
    3030from .slicing import *
     31
    3132
    3233class fvec(numpy.ndarray):
  • python/lib/aubio/cmd.py

    r088760e rc03d191  
    1212import sys
    1313import argparse
     14import warnings
    1415import aubio
    1516
     
    169170
    170171    def add_verbose_help(self):
    171         self.add_argument("-v","--verbose",
     172        self.add_argument("-v", "--verbose",
    172173                action="count", dest="verbose", default=1,
    173174                help="make lots of noise [default]")
    174         self.add_argument("-q","--quiet",
     175        self.add_argument("-q", "--quiet",
    175176                action="store_const", dest="verbose", const=0,
    176177                help="be quiet")
     
    181182
    182183    def add_buf_size(self, buf_size=512):
    183         self.add_argument("-B","--bufsize",
     184        self.add_argument("-B", "--bufsize",
    184185                action="store", dest="buf_size", default=buf_size,
    185186                metavar = "<size>", type=int,
     
    187188
    188189    def add_hop_size(self, hop_size=256):
    189         self.add_argument("-H","--hopsize",
     190        self.add_argument("-H", "--hopsize",
    190191                metavar = "<size>", type=int,
    191192                action="store", dest="hop_size", default=hop_size,
     
    193194
    194195    def add_method(self, method='default', helpstr='method'):
    195         self.add_argument("-m","--method",
     196        self.add_argument("-m", "--method",
    196197                metavar = "<method>", type=str,
    197198                action="store", dest="method", default=method,
     
    199200
    200201    def add_threshold(self, default=None):
    201         self.add_argument("-t","--threshold",
     202        self.add_argument("-t", "--threshold",
    202203                metavar = "<threshold>", type=float,
    203204                action="store", dest="threshold", default=default,
     
    240241
    241242    def add_slicer_options(self):
    242         self.add_argument("-o","--output", type = str,
     243        self.add_argument("-o", "--output", type = str,
    243244                metavar = "<outputdir>",
    244245                action="store", dest="output_directory", default=None,
    245                 help="specify path where slices of the original file should be created")
     246                help="specify path where slices of the original file should"
     247                " be created")
    246248        self.add_argument("--cut-until-nsamples", type = int,
    247249                metavar = "<samples>",
    248250                action = "store", dest = "cut_until_nsamples", default = None,
    249                 help="how many extra samples should be added at the end of each slice")
     251                help="how many extra samples should be added at the end of"
     252                " each slice")
    250253        self.add_argument("--cut-every-nslices", type = int,
    251254                metavar = "<samples>",
     
    255258                metavar = "<slices>",
    256259                action = "store", dest = "cut_until_nslices", default = None,
    257                 help="how many extra slices should be added at the end of each slice")
     260                help="how many extra slices should be added at the end of"
     261                " each slice")
    258262        self.add_argument("--create-first",
    259263                action = "store_true", dest = "create_first", default = False,
     
    289293        if args.verbose > 2 and hasattr(self, 'options'):
    290294            name = type(self).__name__.split('_')[1]
    291             optstr = ' '.join(['running', name, 'with options', repr(self.options), '\n'])
     295            optstr = ' '.join(['running', name, 'with options',
     296                repr(self.options), '\n'])
    292297            sys.stderr.write(optstr)
    293298    def flush(self, frames_read, samplerate):
     
    297302    def parse_options(self, args, valid_opts):
    298303        # get any valid options found in a dictionnary of arguments
    299         options = {k :v for k,v in vars(args).items() if k in valid_opts}
     304        options = {k: v for k, v in vars(args).items() if k in valid_opts}
    300305        self.options = options
    301306
     
    378383            outstr = "unknown bpm"
    379384        else:
    380             bpms = 60./ np.diff(self.beat_locations)
     385            bpms = 60. / np.diff(self.beat_locations)
    381386            median_bpm = np.mean(bpms)
    382387            if len(self.beat_locations) < 10:
     
    399404        return self.notes(block)
    400405    def repr_res(self, res, frames_read, samplerate):
    401         if res[2] != 0: # note off
     406        if res[2] != 0:  # note off
    402407            fmt_out = self.time2string(frames_read, samplerate)
    403408            sys.stdout.write(fmt_out + '\n')
    404         if res[0] != 0: # note on
     409        if res[0] != 0:  # note on
    405410            lastmidi = res[0]
    406411            fmt_out = "%f\t" % lastmidi
    407412            fmt_out += self.time2string(frames_read, samplerate)
    408             sys.stdout.write(fmt_out) # + '\t')
     413            sys.stdout.write(fmt_out)  # + '\t')
    409414    def flush(self, frames_read, samplerate):
    410415        eof = self.time2string(frames_read, samplerate)
     
    473478            if self.wassilence != 1:
    474479                self.wassilence = 1
    475                 return 2 # newly found silence
    476             return 1 # silence again
     480                return 2   # newly found silence
     481            return 1       # silence again
    477482        else:
    478483            if self.wassilence != 0:
    479484                self.wassilence = 0
    480                 return -1 # newly found noise
    481             return 0 # noise again
     485                return -1  # newly found noise
     486            return 0       # noise again
    482487
    483488    def repr_res(self, res, frames_read, samplerate):
     
    499504    def __call__(self, block):
    500505        ret = super(process_cut, self).__call__(block)
    501         if ret: self.slices.append(self.onset.get_last())
     506        if ret:
     507            self.slices.append(self.onset.get_last())
    502508        return ret
    503509
    504510    def flush(self, frames_read, samplerate):
    505         from aubio.cut import _cut_slice
    506511        _cut_slice(self.options, self.slices)
    507         duration = float (frames_read) / float(samplerate)
    508         base_info = '%(source_file)s' % {'source_file': self.options.source_uri}
     512        duration = float(frames_read) / float(samplerate)
     513        base_info = '%(source_file)s' % \
     514                    {'source_file': self.options.source_uri}
    509515        base_info += ' (total %(duration).2fs at %(samplerate)dHz)\n' % \
    510                 {'duration': duration, 'samplerate': samplerate}
     516                     {'duration': duration, 'samplerate': samplerate}
    511517        info = "created %d slices from " % len(self.slices)
    512518        info += base_info
    513519        sys.stderr.write(info)
     520
     521def _cut_slice(options, timestamps):
     522    # cutting pass
     523    nstamps = len(timestamps)
     524    if nstamps > 0:
     525        # generate output files
     526        timestamps_end = None
     527        if options.cut_every_nslices:
     528            timestamps = timestamps[::options.cut_every_nslices]
     529            nstamps = len(timestamps)
     530        if options.cut_until_nslices and options.cut_until_nsamples:
     531            msg = "using cut_until_nslices, but cut_until_nsamples is set"
     532            warnings.warn(msg)
     533        if options.cut_until_nsamples:
     534            lag = options.cut_until_nsamples
     535            timestamps_end = [t + lag for t in timestamps[1:]]
     536            timestamps_end += [1e120]
     537        if options.cut_until_nslices:
     538            slice_lag = options.cut_until_nslices
     539            timestamps_end = [t for t in timestamps[1 + slice_lag:]]
     540            timestamps_end += [1e120] * (options.cut_until_nslices + 1)
     541        aubio.slice_source_at_stamps(options.source_uri,
     542                timestamps, timestamps_end = timestamps_end,
     543                output_dir = options.output_directory,
     544                samplerate = options.samplerate,
     545                create_first = options.create_first)
    514546
    515547def main():
     
    526558                action="store_true", dest="show_version")
    527559        args, extras = parser_root.parse_known_args()
    528         if args.show_version == False: # no -V, forward to parser
     560        if not args.show_version: # no -V, forward to parser
    529561            args = parser.parse_args(extras, namespace=args)
    530         elif len(extras) != 0: # -V with other arguments, print help
     562        elif len(extras) != 0:     # -V with other arguments, print help
    531563            parser.print_help()
    532564            sys.exit(1)
    533     else: # in py3, we can simply use parser directly
     565    else:  # in py3, we can simply use parser directly
    534566        args = parser.parse_args()
    535567    if 'show_version' in args and args.show_version:
     
    538570    elif 'verbose' in args and args.verbose > 3:
    539571        sys.stderr.write('aubio version ' + aubio.version + '\n')
    540     if 'command' not in args or args.command is None or args.command in ['help']:
     572    if 'command' not in args or args.command is None \
     573            or args.command in ['help']:
    541574        # no command given, print help and return 1
    542575        parser.print_help()
     
    572605                frames_read += read
    573606                # exit loop at end of file
    574                 if read < a_source.hop_size: break
     607                if read < a_source.hop_size:
     608                    break
    575609            # flush the processor if needed
    576610            processor.flush(frames_read, a_source.samplerate)
     
    580614                fmt_string += " from {:s} at {:d}Hz\n"
    581615                sys.stderr.write(fmt_string.format(
    582                         frames_read/float(a_source.samplerate),
     616                        frames_read / float(a_source.samplerate),
    583617                        frames_read,
    584618                        frames_read // a_source.hop_size + 1,
  • python/lib/aubio/cut.py

    r088760e rc03d191  
    66
    77import sys
    8 from aubio.cmd import AubioArgumentParser
     8from aubio.cmd import AubioArgumentParser, _cut_slice
    99
    1010def aubio_cut_parser():
    1111    parser = AubioArgumentParser()
    1212    parser.add_input()
    13     parser.add_argument("-O","--onset-method",
     13    parser.add_argument("-O", "--onset-method",
    1414            action="store", dest="onset_method", default='default',
    1515            metavar = "<onset_method>",
     
    1717                    complexdomain|hfc|phase|specdiff|energy|kl|mkl")
    1818    # cutting methods
    19     parser.add_argument("-b","--beat",
     19    parser.add_argument("-b", "--beat",
    2020            action="store_true", dest="beat", default=False,
    2121            help="slice at beat locations")
    2222    """
    23     parser.add_argument("-S","--silencecut",
     23    parser.add_argument("-S", "--silencecut",
    2424            action="store_true", dest="silencecut", default=False,
    2525            help="use silence locations")
    26     parser.add_argument("-s","--silence",
     26    parser.add_argument("-s", "--silence",
    2727            metavar = "<value>",
    2828            action="store", dest="silence", default=-70,
     
    3131    # algorithm parameters
    3232    parser.add_buf_hop_size()
    33     parser.add_argument("-t","--threshold", "--onset-threshold",
     33    parser.add_argument("-t", "--threshold", "--onset-threshold",
    3434            metavar = "<threshold>", type=float,
    3535            action="store", dest="threshold", default=0.3,
    3636            help="onset peak picking threshold [default=0.3]")
    37     parser.add_argument("-c","--cut",
     37    parser.add_argument("-c", "--cut",
    3838            action="store_true", dest="cut", default=False,
    3939            help="cut input sound file at detected labels")
     
    4141
    4242    """
    43     parser.add_argument("-D","--delay",
     43    parser.add_argument("-D", "--delay",
    4444            action = "store", dest = "delay", type = float,
    4545            metavar = "<seconds>", default=0,
    4646            help="number of seconds to take back [default=system]\
    4747                    default system delay is 3*hopsize/samplerate")
    48     parser.add_argument("-C","--dcthreshold",
     48    parser.add_argument("-C", "--dcthreshold",
    4949            metavar = "<value>",
    5050            action="store", dest="dcthreshold", default=1.,
    5151            help="onset peak picking DC component [default=1.]")
    52     parser.add_argument("-L","--localmin",
     52    parser.add_argument("-L", "--localmin",
    5353            action="store_true", dest="localmin", default=False,
    5454            help="use local minima after peak detection")
    55     parser.add_argument("-d","--derivate",
     55    parser.add_argument("-d", "--derivate",
    5656            action="store_true", dest="derivate", default=False,
    5757            help="derivate onset detection function")
    58     parser.add_argument("-z","--zerocross",
     58    parser.add_argument("-z", "--zerocross",
    5959            metavar = "<value>",
    6060            action="store", dest="zerothres", default=0.008,
    6161            help="zero-crossing threshold for slicing [default=0.00008]")
    6262    # plotting functions
    63     parser.add_argument("-p","--plot",
     63    parser.add_argument("-p", "--plot",
    6464            action="store_true", dest="plot", default=False,
    6565            help="draw plot")
    66     parser.add_argument("-x","--xsize",
     66    parser.add_argument("-x", "--xsize",
    6767            metavar = "<size>",
    6868            action="store", dest="xsize", default=1.,
    6969            type=float, help="define xsize for plot")
    70     parser.add_argument("-y","--ysize",
     70    parser.add_argument("-y", "--ysize",
    7171            metavar = "<size>",
    7272            action="store", dest="ysize", default=1.,
    7373            type=float, help="define ysize for plot")
    74     parser.add_argument("-f","--function",
     74    parser.add_argument("-f", "--function",
    7575            action="store_true", dest="func", default=False,
    7676            help="print detection function")
    77     parser.add_argument("-n","--no-onsets",
     77    parser.add_argument("-n", "--no-onsets",
    7878            action="store_true", dest="nplot", default=False,
    7979            help="do not plot detected onsets")
    80     parser.add_argument("-O","--outplot",
     80    parser.add_argument("-O", "--outplot",
    8181            metavar = "<output_image>",
    8282            action="store", dest="outplot", default=None,
    8383            help="save plot to output.{ps,png}")
    84     parser.add_argument("-F","--spectrogram",
     84    parser.add_argument("-F", "--spectrogram",
    8585            action="store_true", dest="spectro", default=False,
    8686            help="add spectrogram to the plot")
     
    106106
    107107    if options.beat:
    108         o = tempo(options.onset_method, bufsize, hopsize, samplerate=samplerate)
     108        o = tempo(options.onset_method, bufsize, hopsize,
     109                samplerate=samplerate)
    109110    else:
    110         o = onset(options.onset_method, bufsize, hopsize, samplerate=samplerate)
     111        o = onset(options.onset_method, bufsize, hopsize,
     112                samplerate=samplerate)
    111113        if options.minioi:
    112114            if options.minioi.endswith('ms'):
     
    123125        samples, read = s()
    124126        if o(samples):
    125             timestamps.append (o.get_last())
    126             if options.verbose: print ("%.4f" % o.get_last_s())
     127            timestamps.append(o.get_last())
     128            if options.verbose:
     129                print("%.4f" % o.get_last_s())
    127130        total_frames += read
    128         if read < hopsize: break
     131        if read < hopsize:
     132            break
    129133    del s
    130134    return timestamps, total_frames
    131 
    132 def _cut_slice(options, timestamps):
    133     # cutting pass
    134     nstamps = len(timestamps)
    135     if nstamps > 0:
    136         # generate output files
    137         from aubio.slicing import slice_source_at_stamps
    138         timestamps_end = None
    139         if options.cut_every_nslices:
    140             timestamps = timestamps[::options.cut_every_nslices]
    141             nstamps = len(timestamps)
    142         if options.cut_until_nslices and options.cut_until_nsamples:
    143             print ("warning: using cut_until_nslices, but cut_until_nsamples is set")
    144         if options.cut_until_nsamples:
    145             timestamps_end = [t + options.cut_until_nsamples for t in timestamps[1:]]
    146             timestamps_end += [ 1e120 ]
    147         if options.cut_until_nslices:
    148             timestamps_end = [t for t in timestamps[1 + options.cut_until_nslices:]]
    149             timestamps_end += [ 1e120 ] * (options.cut_until_nslices + 1)
    150         slice_source_at_stamps(options.source_uri,
    151                 timestamps, timestamps_end = timestamps_end,
    152                 output_dir = options.output_directory,
    153                 samplerate = options.samplerate,
    154                 create_first = options.create_first)
    155135
    156136def main():
     
    168148
    169149    # print some info
    170     duration = float (total_frames) / float(options.samplerate)
     150    duration = float(total_frames) / float(options.samplerate)
    171151    base_info = '%(source_uri)s' % {'source_uri': options.source_uri}
    172152    base_info += ' (total %(duration).2fs at %(samplerate)dHz)\n' % \
  • python/lib/aubio/midiconv.py

    r088760e rc03d191  
    22""" utilities to convert midi note number to and from note names """
    33
    4 __all__ = ['note2midi', 'midi2note', 'freq2note', 'note2freq']
    5 
    64import sys
    75from ._aubio import freqtomidi, miditofreq
     6
     7__all__ = ['note2midi', 'midi2note', 'freq2note', 'note2freq']
    88
    99py3 = sys.version_info[0] == 3
     
    1414    str_instances = (str, unicode)
    1515    int_instances = (int, long)
     16
    1617
    1718def note2midi(note):
     
    5657    midi2note, freqtomidi, miditofreq
    5758    """
    58     _valid_notenames = {'C': 0, 'D': 2, 'E': 4, 'F': 5, 'G': 7, 'A': 9, 'B': 11}
     59    _valid_notenames = {'C': 0, 'D': 2, 'E': 4, 'F': 5, 'G': 7,
     60                        'A': 9, 'B': 11}
    5961    _valid_modifiers = {
    60             u'𝄫': -2,                        # double flat
    61             u'♭': -1, 'b': -1, '\u266d': -1, # simple flat
    62             u'♮': 0, '\u266e': 0, None: 0,   # natural
    63             '#': +1, u'♯': +1, '\u266f': +1, # sharp
    64             u'𝄪': +2,                        # double sharp
     62            u'𝄫': -2,                         # double flat
     63            u'♭': -1, 'b': -1, '\u266d': -1,  # simple flat
     64            u'♮': 0, '\u266e': 0, None: 0,    # natural
     65            '#': +1, u'♯': +1, '\u266f': +1,  # sharp
     66            u'𝄪': +2,                         # double sharp
    6567            }
    6668    _valid_octaves = range(-1, 10)
     
    7173        msg = "string of 2 to 4 characters expected, got {:d} ({:s})"
    7274        raise ValueError(msg.format(len(note), note))
    73     notename, modifier, octave = [None]*3
     75    notename, modifier, octave = [None] * 3
    7476
    7577    if len(note) == 4:
     
    9496        raise ValueError("%s is not a valid octave" % octave)
    9597
    96     midi = 12 + octave * 12 + _valid_notenames[notename] \
    97             + _valid_modifiers[modifier]
     98    midi = (octave + 1) * 12 + _valid_notenames[notename] \
     99                             + _valid_modifiers[modifier]
    98100    if midi > 127:
    99101        raise ValueError("%s is outside of the range C-2 to G8" % note)
    100102    return midi
     103
    101104
    102105def midi2note(midi):
     
    137140        raise ValueError(msg.format(midi))
    138141    _valid_notenames = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#',
    139             'A', 'A#', 'B']
     142                        'A', 'A#', 'B']
    140143    return _valid_notenames[midi % 12] + str(int(midi / 12) - 1)
     144
    141145
    142146def freq2note(freq):
     
    163167    return midi2note(nearest_note)
    164168
     169
    165170def note2freq(note):
    166171    """Convert note name to corresponding frequency, in Hz.
  • python/lib/aubio/slicing.py

    r088760e rc03d191  
    55
    66_max_timestamp = 1e120
     7
    78
    89def slice_source_at_stamps(source_file, timestamps, timestamps_end=None,
     
    7374    """
    7475
    75     if timestamps is None or len(timestamps) == 0:
     76    if not timestamps:
    7677        raise ValueError("no timestamps given")
    7778
     
    9091
    9192    regions = list(zip(timestamps, timestamps_end))
    92     #print regions
    9393
    9494    source_base_name, _ = os.path.splitext(os.path.basename(source_file))
     
    9898        source_base_name = os.path.join(output_dir, source_base_name)
    9999
    100     def new_sink_name(source_base_name, timestamp, samplerate):
    101         """ create a sink based on a timestamp in samples, converted in seconds """
     100    def _new_sink_name(source_base_name, timestamp, samplerate):
     101        # create name based on a timestamp in samples, converted in seconds
    102102        timestamp_seconds = timestamp / float(samplerate)
    103103        return source_base_name + "_%011.6f" % timestamp_seconds + '.wav'
     
    114114        vec, read = _source.do_multi()
    115115        # if the total number of frames read will exceed the next region start
    116         while len(regions) and total_frames + read >= regions[0][0]:
    117             #print "getting", regions[0], "at", total_frames
     116        while regions and total_frames + read >= regions[0][0]:
    118117            # get next region
    119118            start_stamp, end_stamp = regions.pop(0)
    120119            # create a name for the sink
    121             new_sink_path = new_sink_name(source_base_name, start_stamp, samplerate)
     120            new_sink_path = _new_sink_name(source_base_name, start_stamp,
     121                                           samplerate)
    122122            # create its sink
    123123            _sink = sink(new_sink_path, samplerate, _source.channels)
    124124            # create a dictionary containing all this
    125             new_slice = {'start_stamp': start_stamp, 'end_stamp': end_stamp, 'sink': _sink}
     125            new_slice = {'start_stamp': start_stamp, 'end_stamp': end_stamp,
     126                         'sink': _sink}
    126127            # append the dictionary to the current list of slices
    127128            slices.append(new_slice)
     
    135136            # number of samples yet to written be until end of region
    136137            remaining = end_stamp - total_frames + 1
    137             #print current_slice, remaining, start
    138138            # not enough frames remaining, time to split
    139139            if remaining < read:
     
    141141                    # write remaining samples from current region
    142142                    _sink.do_multi(vec[:, start:remaining], remaining - start)
    143                     #print("closing region", "remaining", remaining)
    144143                    # close this file
    145144                    _sink.close()
     
    150149        # remove old slices
    151150        slices = list(filter(lambda s: s['end_stamp'] > total_frames,
    152             slices))
     151                             slices))
    153152        if read < hopsize:
    154153            break
  • python/lib/gen_code.py

    r088760e rc03d191  
    465465""".format(**self.__dict__)
    466466        for set_param in self.prototypes['set']:
    467             params = get_params_types_names(set_param)[1]
    468             paramtype = params['type']
     467            params = get_params_types_names(set_param)[1:]
     468            param = self.shortname.split('_set_')[-1]
     469            paramdecls = "".join(["""
     470   {0} {1};""".format(p['type'], p['name']) for p in params])
    469471            method_name = get_name(set_param)
    470472            param = method_name.split('aubio_'+self.shortname+'_set_')[-1]
    471             pyparamtype = pyargparse_chars[paramtype]
     473            refs = ", ".join(["&%s" % p['name'] for p in params])
     474            paramlist = ", ".join(["%s" % p['name'] for p in params])
     475            if len(params):
     476                paramlist = "," + paramlist
     477            pyparamtypes = ''.join([pyargparse_chars[p['type']] for p in params])
    472478            out += """
    473479static PyObject *
     
    475481{{
    476482  uint_t err = 0;
    477   {paramtype} {param};
    478 
    479   if (!PyArg_ParseTuple (args, "{pyparamtype}", &{param})) {{
     483  {paramdecls}
     484""".format(param = param, paramdecls = paramdecls, **self.__dict__)
     485
     486            if len(refs) and len(pyparamtypes):
     487                out += """
     488
     489  if (!PyArg_ParseTuple (args, "{pyparamtypes}", {refs})) {{
    480490    return NULL;
    481491  }}
    482   err = aubio_{shortname}_set_{param} (self->o, {param});
     492""".format(pyparamtypes = pyparamtypes, refs = refs)
     493
     494            out += """
     495  err = aubio_{shortname}_set_{param} (self->o {paramlist});
    483496
    484497  if (err > 0) {{
     
    495508  Py_RETURN_NONE;
    496509}}
    497 """.format(param = param, paramtype = paramtype, pyparamtype = pyparamtype, **self.__dict__)
     510""".format(param = param, refs = refs, paramdecls = paramdecls,
     511        pyparamtypes = pyparamtypes, paramlist = paramlist, **self.__dict__)
    498512        return out
    499513
  • python/lib/gen_external.py

    r088760e rc03d191  
    44import subprocess
    55import glob
     6from distutils.sysconfig import customize_compiler
     7from gen_code import MappedObject
    68
    79header = os.path.join('src', 'aubio.h')
     
    5052def get_preprocessor():
    5153    # findout which compiler to use
    52     from distutils.sysconfig import customize_compiler
    5354    compiler_name = distutils.ccompiler.get_default_compiler()
    5455    compiler = distutils.ccompiler.new_compiler(compiler=compiler_name)
     
    263264
    264265    sources_list = []
    265     try:
    266         from .gen_code import MappedObject
    267     except (SystemError, ValueError):
    268         from gen_code import MappedObject
    269266    for o in lib:
    270267        out = source_header
  • python/lib/moresetuptools.py

    r088760e rc03d191  
    33import sys, os, glob, subprocess
    44import distutils, distutils.command.clean, distutils.dir_util
    5 from .gen_external import generate_external, header, output_path
     5from gen_external import generate_external, header, output_path
    66
    77from this_version import get_aubio_version
  • python/tests/test_fft.py

    r088760e rc03d191  
    143143        assert_almost_equal ( r[1:], 0)
    144144
     145class aubio_fft_odd_sizes(TestCase):
     146
     147    def test_reconstruct_with_odd_size(self):
     148        win_s = 29
     149        self.recontruct(win_s, 'odd sizes not supported')
     150
     151    def test_reconstruct_with_radix15(self):
     152        win_s = 2 ** 4 * 15
     153        self.recontruct(win_s, 'radix 15 supported')
     154
     155    def test_reconstruct_with_radix5(self):
     156        win_s = 2 ** 4 * 5
     157        self.recontruct(win_s, 'radix 5 supported')
     158
     159    def test_reconstruct_with_radix3(self):
     160        win_s = 2 ** 4 * 3
     161        self.recontruct(win_s, 'radix 3 supported')
     162
     163    def recontruct(self, win_s, skipMessage):
     164        try:
     165            f = fft(win_s)
     166        except RuntimeError:
     167            self.skipTest(skipMessage)
     168        input_signal = fvec(win_s)
     169        input_signal[win_s//2] = 1
     170        c = f(input_signal)
     171        output_signal = f.rdo(c)
     172        assert_almost_equal(input_signal, output_signal)
     173
     174class aubio_fft_wrong_params(TestCase):
     175
    145176    def test_large_input_timegrain(self):
    146177        win_s = 1024
     
    170201        with self.assertRaises(ValueError):
    171202            f.rdo(s)
    172 
    173 class aubio_fft_wrong_params(TestCase):
    174203
    175204    def test_wrong_buf_size(self):
     
    177206        with self.assertRaises(ValueError):
    178207            fft(win_s)
    179 
    180     def test_buf_size_not_power_of_two(self):
    181         # when compiled with fftw3, aubio supports non power of two fft sizes
    182         win_s = 320
    183         try:
    184             with self.assertRaises(RuntimeError):
    185                 fft(win_s)
    186         except AssertionError:
    187             self.skipTest('creating aubio.fft with size %d did not fail' % win_s)
    188208
    189209    def test_buf_size_too_small(self):
  • python/tests/test_filter.py

    r088760e rc03d191  
    7878            f.set_biquad(0., 0., 0, 0., 0.)
    7979
     80    def test_all_available_presets(self):
     81        f = digital_filter(7)
     82        for sr in [8000, 11025, 16000, 22050, 24000, 32000,
     83                44100, 48000, 88200, 96000, 192000]:
     84            f.set_a_weighting(sr)
     85        f = digital_filter(5)
     86        for sr in [8000, 11025, 16000, 22050, 24000, 32000,
     87                44100, 48000, 88200, 96000, 192000]:
     88            f.set_c_weighting(sr)
     89
    8090class aubio_filter_wrong_params(TestCase):
    8191
  • python/tests/test_filterbank_mel.py

    r088760e rc03d191  
    44from numpy.testing import TestCase, assert_equal, assert_almost_equal
    55
    6 from aubio import cvec, filterbank, float_type
     6from aubio import fvec, cvec, filterbank, float_type
    77
    88import warnings
     
    4848                    0.02133301, 0.02133301, 0.02133311, 0.02133334, 0.02133345])
    4949
     50    def test_triangle_freqs_with_zeros(self):
     51        """make sure set_triangle_bands works when list starts with 0"""
     52        freq_list = [0, 40, 80]
     53        freqs = np.array(freq_list, dtype = float_type)
     54        f = filterbank(len(freqs)-2, 1024)
     55        f.set_triangle_bands(freqs, 48000)
     56        assert_equal ( f(cvec(1024)), 0)
     57        self.assertIsInstance(f.get_coeffs(), np.ndarray)
     58
     59    def test_triangle_freqs_with_wrong_negative(self):
     60        """make sure set_triangle_bands fails when list contains a negative"""
     61        freq_list = [-10, 0, 80]
     62        f = filterbank(len(freq_list)-2, 1024)
     63        with self.assertRaises(ValueError):
     64            f.set_triangle_bands(fvec(freq_list), 48000)
     65
     66    def test_triangle_freqs_with_wrong_ordering(self):
     67        """make sure set_triangle_bands fails when list not ordered"""
     68        freq_list = [0, 80, 40]
     69        f = filterbank(len(freq_list)-2, 1024)
     70        with self.assertRaises(ValueError):
     71            f.set_triangle_bands(fvec(freq_list), 48000)
     72
     73    def test_triangle_freqs_with_large_freq(self):
     74        """make sure set_triangle_bands warns when freq > nyquist"""
     75        samplerate = 22050
     76        freq_list = [0, samplerate//4, samplerate // 2 + 1]
     77        f = filterbank(len(freq_list)-2, 1024)
     78        # TODO add assert_warns
     79        f.set_triangle_bands(fvec(freq_list), samplerate)
     80
     81    def test_triangle_freqs_with_not_enough_filters(self):
     82        """make sure set_triangle_bands warns when not enough filters"""
     83        samplerate = 22050
     84        freq_list = [0, 100, 1000, 4000, 8000, 10000]
     85        f = filterbank(len(freq_list)-3, 1024)
     86        # TODO add assert_warns
     87        f.set_triangle_bands(fvec(freq_list), samplerate)
     88
     89    def test_triangle_freqs_with_too_many_filters(self):
     90        """make sure set_triangle_bands warns when too many filters"""
     91        samplerate = 22050
     92        freq_list = [0, 100, 1000, 4000, 8000, 10000]
     93        f = filterbank(len(freq_list)-1, 1024)
     94        # TODO add assert_warns
     95        f.set_triangle_bands(fvec(freq_list), samplerate)
     96
     97    def test_triangle_freqs_with_double_value(self):
     98        """make sure set_triangle_bands works with 2 duplicate freqs"""
     99        samplerate = 22050
     100        freq_list = [0, 100, 1000, 4000, 4000, 4000, 10000]
     101        f = filterbank(len(freq_list)-2, 1024)
     102        # TODO add assert_warns
     103        f.set_triangle_bands(fvec(freq_list), samplerate)
     104
     105    def test_triangle_freqs_with_triple(self):
     106        """make sure set_triangle_bands works with 3 duplicate freqs"""
     107        samplerate = 22050
     108        freq_list = [0, 100, 1000, 4000, 4000, 4000, 10000]
     109        f = filterbank(len(freq_list)-2, 1024)
     110        # TODO add assert_warns
     111        f.set_triangle_bands(fvec(freq_list), samplerate)
     112
     113    def test_triangle_freqs_without_norm(self):
     114        """make sure set_triangle_bands works without """
     115        samplerate = 22050
     116        freq_list = fvec([0, 100, 1000, 10000])
     117        f = filterbank(len(freq_list) - 2, 1024)
     118        f.set_norm(0)
     119        f.set_triangle_bands(freq_list, samplerate)
     120        expected = f.get_coeffs()
     121        f.set_norm(1)
     122        f.set_triangle_bands(fvec(freq_list), samplerate)
     123        assert_almost_equal(f.get_coeffs().T,
     124                expected.T * 2. / (freq_list[2:] - freq_list[:-2]))
     125
     126    def test_triangle_freqs_wrong_norm(self):
     127        f = filterbank(10, 1024)
     128        with self.assertRaises(ValueError):
     129            f.set_norm(-1)
     130
     131    def test_triangle_freqs_with_power(self):
     132        f = filterbank(9, 1024)
     133        freqs = fvec([40, 80, 200, 400, 800, 1600, 3200, 6400, 12800, 15000,
     134            24000])
     135        f.set_power(2)
     136        f.set_triangle_bands(freqs, 48000)
     137        spec = cvec(1024)
     138        spec.norm[:] = .1
     139        expected = fvec([0.02070313, 0.02138672, 0.02127604, 0.02135417,
     140            0.02133301, 0.02133301, 0.02133311, 0.02133334, 0.02133345])
     141        expected /= 100.
     142        assert_almost_equal(f(spec), expected)
     143
     144    def test_mel_coeffs(self):
     145        f = filterbank(40, 1024)
     146        f.set_mel_coeffs(44100, 0, 44100 / 2)
     147
     148    def test_zero_fmax(self):
     149        f = filterbank(40, 1024)
     150        f.set_mel_coeffs(44100, 0, 0)
     151
     152    def test_wrong_mel_coeffs(self):
     153        f = filterbank(40, 1024)
     154        with self.assertRaises(ValueError):
     155            f.set_mel_coeffs_slaney(0)
     156        with self.assertRaises(ValueError):
     157            f.set_mel_coeffs(44100, 0, -44100 / 2)
     158        with self.assertRaises(ValueError):
     159            f.set_mel_coeffs(44100, -0.1, 44100 / 2)
     160        with self.assertRaises(ValueError):
     161            f.set_mel_coeffs(-44100, 0.1, 44100 / 2)
     162        with self.assertRaises(ValueError):
     163            f.set_mel_coeffs_htk(-1, 0, 0)
     164
     165    def test_mel_coeffs_htk(self):
     166        f = filterbank(40, 1024)
     167        f.set_mel_coeffs_htk(44100, 0, 44100 / 2)
     168
     169
    50170if __name__ == '__main__':
    51171    import nose2
  • python/tests/test_mfcc.py

    r088760e rc03d191  
    111111        #print coeffs
    112112
     113
     114class aubio_mfcc_fb_params(TestCase):
     115
     116    def test_set_scale(self):
     117        buf_size, n_filters, n_coeffs, samplerate = 512, 20, 10, 16000
     118        m = mfcc(buf_size, n_filters, n_coeffs, samplerate)
     119        m.set_scale(10.)
     120        m(cvec(buf_size))
     121
     122    def test_set_power(self):
     123        buf_size, n_filters, n_coeffs, samplerate = 512, 20, 10, 16000
     124        m = mfcc(buf_size, n_filters, n_coeffs, samplerate)
     125        m.set_power(2.)
     126        m(cvec(buf_size))
     127
     128    def test_set_mel_coeffs(self):
     129        buf_size, n_filters, n_coeffs, samplerate = 512, 20, 10, 16000
     130        m = mfcc(buf_size, n_filters, n_coeffs, samplerate)
     131        m.set_mel_coeffs(0., samplerate/2.)
     132        m(cvec(buf_size))
     133
     134    def test_set_mel_coeffs_htk(self):
     135        buf_size, n_filters, n_coeffs, samplerate = 512, 20, 10, 16000
     136        m = mfcc(buf_size, n_filters, n_coeffs, samplerate)
     137        m.set_mel_coeffs_htk(0., samplerate/2.)
     138        m(cvec(buf_size))
     139
     140    def test_set_mel_coeffs_slaney(self):
     141        buf_size, n_filters, n_coeffs, samplerate = 512, 40, 10, 16000
     142        m = mfcc(buf_size, n_filters, n_coeffs, samplerate)
     143        m.set_mel_coeffs_slaney(samplerate)
     144        m(cvec(buf_size))
     145        assert m.get_power() == 1
     146        assert m.get_scale() == 1
     147
    113148if __name__ == '__main__':
    114149    main()
  • python/tests/test_onset.py

    r088760e rc03d191  
    33from unittest import main
    44from numpy.testing import TestCase, assert_equal, assert_almost_equal
    5 from aubio import onset
     5from aubio import onset, fvec
    66
    77class aubio_onset_default(TestCase):
     
    8484    samplerate = 8000
    8585
     86class aubio_onset_coverate(TestCase):
     87    # extra tests to execute the C routines and improve coverage
     88
     89    def test_all_methods(self):
     90        for method in ['default', 'energy', 'hfc', 'complexdomain', 'complex',
     91                'phase', 'wphase', 'mkl', 'kl', 'specflux', 'specdiff',
     92                'old_default']:
     93            o = onset(method=method, buf_size=512, hop_size=256)
     94            o(fvec(256))
     95
     96    def test_get_methods(self):
     97        o = onset(method='default', buf_size=512, hop_size=256)
     98
     99        assert o.get_silence() == -70
     100        o.set_silence(-20)
     101        assert_almost_equal(o.get_silence(), -20)
     102
     103        assert o.get_compression() == 1
     104        o.set_compression(.99)
     105        assert_almost_equal(o.get_compression(), .99)
     106
     107        assert o.get_awhitening() == 0
     108        o.set_awhitening(1)
     109        assert o.get_awhitening() == 1
     110
     111        o.get_last()
     112        o.get_last_ms()
     113        o.get_last_s()
     114        o.get_descriptor()
     115        o.get_thresholded_descriptor()
     116
     117
    86118if __name__ == '__main__':
    87119    main()
  • setup.py

    r088760e rc03d191  
    11#! /usr/bin/env python
    22
    3 import sys, os.path, glob
     3import sys
     4import os.path
     5import glob
    46from setuptools import setup, Extension
    5 from python.lib.moresetuptools import build_ext, CleanGenerated
     7
     8# add ./python/lib to current path
     9sys.path.append(os.path.join('python', 'lib'))  # noqa
     10from moresetuptools import build_ext, CleanGenerated
     11
    612# function to generate gen/*.{c,h}
    713from this_version import get_aubio_version, get_aubio_pyversion
     
    1521extra_link_args = []
    1622
    17 include_dirs += [ 'python/ext' ]
     23include_dirs += ['python/ext']
    1824try:
    1925    import numpy
    20     include_dirs += [ numpy.get_include() ]
     26    include_dirs += [numpy.get_include()]
    2127except ImportError:
    2228    pass
    2329
    2430if sys.platform.startswith('darwin'):
    25     extra_link_args += ['-framework','CoreFoundation', '-framework','AudioToolbox']
     31    extra_link_args += ['-framework', 'CoreFoundation',
     32            '-framework', 'AudioToolbox']
    2633
    2734sources = sorted(glob.glob(os.path.join('python', 'ext', '*.c')))
     
    3441    define_macros = define_macros)
    3542
    36 if os.path.isfile('src/aubio.h'):
    37     if not os.path.isdir(os.path.join('build','src')):
    38         pass
    39         #__version__ += 'a2' # python only version
     43# TODO: find a way to track if package is built against libaubio
     44# if os.path.isfile('src/aubio.h'):
     45#     if not os.path.isdir(os.path.join('build','src')):
     46#         pass
     47#         #__version__ += 'a2' # python only version
    4048
    4149classifiers = [
     
    5159    'Programming Language :: C',
    5260    'Programming Language :: Python',
    53     'License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)',
     61    'License :: OSI Approved :: '
     62    'GNU General Public License v3 or later (GPLv3+)',
    5463    ]
    5564
     
    5766    version = __version__,
    5867    packages = ['aubio'],
    59     package_dir = {'aubio':'python/lib/aubio'},
     68    package_dir = {'aubio': 'python/lib/aubio'},
    6069    ext_modules = [aubio_extension],
    6170    description = 'a collection of tools for music analysis',
  • src/io/source_avcodec.c

    r088760e rc03d191  
    9090  sint_t selected_stream;
    9191  uint_t eof;
    92   uint_t multi;
    9392};
    9493
    9594// create or re-create the context when _do or _do_multi is called
    96 void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s,
    97     uint_t multi);
     95void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s);
    9896// actually read a frame
    9997void aubio_source_avcodec_readframe(aubio_source_avcodec_t *s,
     
    285283  s->avFrame = avFrame;
    286284
    287   // default to mono output
    288   aubio_source_avcodec_reset_resampler(s, 0);
     285  aubio_source_avcodec_reset_resampler(s);
    289286
    290287  if (s->avr == NULL) goto beach;
    291288
    292289  s->eof = 0;
    293   s->multi = 0;
    294290
    295291  //av_log_set_level(AV_LOG_QUIET);
     
    304300}
    305301
    306 void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s,
    307     uint_t multi)
     302void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s)
    308303{
    309304  // create or reset resampler to/from mono/multi-channel
    310   if ( (multi != s->multi) || (s->avr == NULL) ) {
     305  if ( s->avr == NULL ) {
    311306    int err;
    312307    int64_t input_layout = av_get_default_channel_layout(s->input_channels);
    313     uint_t output_channels = multi ? s->input_channels : 1;
    314     int64_t output_layout = av_get_default_channel_layout(output_channels);
     308    int64_t output_layout = av_get_default_channel_layout(s->input_channels);
    315309#ifdef HAVE_AVRESAMPLE
    316310    AVAudioResampleContext *avr = avresample_alloc_context();
    317     AVAudioResampleContext *oldavr = s->avr;
    318311#elif defined(HAVE_SWRESAMPLE)
    319312    SwrContext *avr = swr_alloc();
    320     SwrContext *oldavr = s->avr;
    321313#endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */
    322314
     
    346338    }
    347339    s->avr = avr;
    348     if (oldavr != NULL) {
    349 #ifdef HAVE_AVRESAMPLE
    350       avresample_close( oldavr );
    351 #elif defined(HAVE_SWRESAMPLE)
    352       swr_close ( oldavr );
    353 #endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */
    354       av_free ( oldavr );
    355       oldavr = NULL;
    356     }
    357     s->multi = multi;
    358340  }
    359341}
     
    496478void aubio_source_avcodec_do(aubio_source_avcodec_t * s, fvec_t * read_data,
    497479    uint_t * read) {
    498   uint_t i;
     480  uint_t i, j;
    499481  uint_t end = 0;
    500482  uint_t total_wrote = 0;
    501   // switch from multi
    502   if (s->multi == 1) aubio_source_avcodec_reset_resampler(s, 0);
    503483  while (total_wrote < s->hop_size) {
    504484    end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote);
    505485    for (i = 0; i < end; i++) {
    506       read_data->data[i + total_wrote] = s->output[i + s->read_index];
     486      read_data->data[i + total_wrote] = 0.;
     487      for (j = 0; j < s->input_channels; j++) {
     488        read_data->data[i + total_wrote] +=
     489          s->output[(i + s->read_index) * s->input_channels + j];
     490      }
     491      read_data->data[i + total_wrote] *= 1./s->input_channels;
    507492    }
    508493    total_wrote += end;
     
    532517  uint_t end = 0;
    533518  uint_t total_wrote = 0;
    534   // switch from mono
    535   if (s->multi == 0) aubio_source_avcodec_reset_resampler(s, 1);
    536519  while (total_wrote < s->hop_size) {
    537520    end = MIN(s->read_samples - s->read_index, s->hop_size - total_wrote);
  • src/mathutils.c

    r088760e rc03d191  
    388388}
    389389
     390void
     391fvec_mul (fvec_t *o, smpl_t val)
     392{
     393  uint_t j;
     394  for (j = 0; j < o->length; j++) {
     395    o->data[j] *= val;
     396  }
     397}
     398
    390399void fvec_adapt_thres(fvec_t * vec, fvec_t * tmp,
    391400    uint_t post, uint_t pre) {
  • src/mathutils.h

    r088760e rc03d191  
    193193*/
    194194void fvec_add (fvec_t * v, smpl_t c);
     195
     196/** multiply each elements of a vector by a scalar
     197
     198  \param v vector to add constant to
     199  \param s constant to scale v with
     200
     201*/
     202void fvec_mul (fvec_t * v, smpl_t s);
    195203
    196204/** remove the minimum value of the vector to each elements
  • src/musicutils.h

    r088760e rc03d191  
    8787smpl_t aubio_freqtobin (smpl_t freq, smpl_t samplerate, smpl_t fftsize);
    8888
     89/** convert frequency (Hz) to mel
     90
     91  \param freq input frequency, in Hz
     92
     93  \return output mel
     94
     95  Converts a scalar from the frequency domain to the mel scale using Slaney
     96  Auditory Toolbox's implementation:
     97
     98  If \f$ f < 1000 \f$, \f$ m = 3 f / 200 \f$.
     99
     100  If \f$ f >= 1000 \f$, \f$ m = 1000 + 27 \frac{{ln}(f) - ln(1000))}
     101  {{ln}(6400) - ln(1000)}
     102  \f$
     103
     104  See also
     105  --------
     106
     107  aubio_meltohz(), aubio_hztomel_htk().
     108
     109*/
     110smpl_t aubio_hztomel (smpl_t freq);
     111
     112/** convert mel to frequency (Hz)
     113
     114  \param mel input mel
     115
     116  \return output frequency, in Hz
     117
     118  Converts a scalar from the mel scale to the frequency domain using Slaney
     119  Auditory Toolbox's implementation:
     120
     121  If \f$ f < 1000 \f$, \f$ f = 200 m/3 \f$.
     122
     123  If \f$ f \geq 1000 \f$, \f$ f = 1000 + \left(\frac{6400}{1000}\right)
     124  ^{\frac{m - 1000}{27}} \f$
     125
     126  See also
     127  --------
     128
     129  aubio_hztomel(), aubio_meltohz_htk().
     130
     131  References
     132  ----------
     133
     134  Malcolm Slaney, *Auditory Toolbox Version 2, Technical Report #1998-010*
     135  https://engineering.purdue.edu/~malcolm/interval/1998-010/
     136
     137*/
     138smpl_t aubio_meltohz (smpl_t mel);
     139
     140/** convert frequency (Hz) to mel
     141
     142  \param freq input frequency, in Hz
     143
     144  \return output mel
     145
     146  Converts a scalar from the frequency domain to the mel scale, using the
     147  equation defined by O'Shaughnessy, as implemented in the HTK speech
     148  recognition toolkit:
     149
     150  \f$ m = 1127 + ln(1 + \frac{f}{700}) \f$
     151
     152  See also
     153  --------
     154
     155  aubio_meltohz_htk(), aubio_hztomel().
     156
     157  References
     158  ----------
     159
     160  Douglas O'Shaughnessy (1987). *Speech communication: human and machine*.
     161  Addison-Wesley. p. 150. ISBN 978-0-201-16520-3.
     162
     163  HTK Speech Recognition Toolkit: http://htk.eng.cam.ac.uk/
     164
     165 */
     166smpl_t aubio_hztomel_htk (smpl_t freq);
     167
     168/** convert mel to frequency (Hz)
     169
     170  \param mel input mel
     171
     172  \return output frequency, in Hz
     173
     174  Converts a scalar from the mel scale to the frequency domain, using the
     175  equation defined by O'Shaughnessy, as implemented in the HTK speech
     176  recognition toolkit:
     177
     178  \f$ f = 700 * {e}^\left(\frac{f}{1127} - 1\right) \f$
     179
     180  See also
     181  --------
     182
     183  aubio_hztomel_htk(), aubio_meltohz().
     184
     185*/
     186smpl_t aubio_meltohz_htk (smpl_t mel);
     187
    89188/** convert frequency (Hz) to midi value (0-128) */
    90189smpl_t aubio_freqtomidi (smpl_t freq);
  • src/spectral/fft.c

    r088760e rc03d191  
    9090#define aubio_vDSP_vsadd               vDSP_vsadd
    9191#define aubio_vDSP_vsmul               vDSP_vsmul
    92 #define aubio_vDSP_create_fftsetup     vDSP_create_fftsetup
    93 #define aubio_vDSP_destroy_fftsetup    vDSP_destroy_fftsetup
    9492#define aubio_DSPComplex               DSPComplex
    9593#define aubio_DSPSplitComplex          DSPSplitComplex
    96 #define aubio_FFTSetup                 FFTSetup
     94#define aubio_vDSP_DFT_Setup           vDSP_DFT_Setup
     95#define aubio_vDSP_DFT_zrop_CreateSetup vDSP_DFT_zrop_CreateSetup
     96#define aubio_vDSP_DFT_Execute         vDSP_DFT_Execute
     97#define aubio_vDSP_DFT_DestroySetup    vDSP_DFT_DestroySetup
    9798#define aubio_vvsqrt                   vvsqrtf
    9899#else
     
    104105#define aubio_vDSP_vsadd               vDSP_vsaddD
    105106#define aubio_vDSP_vsmul               vDSP_vsmulD
    106 #define aubio_vDSP_create_fftsetup     vDSP_create_fftsetupD
    107 #define aubio_vDSP_destroy_fftsetup    vDSP_destroy_fftsetupD
    108107#define aubio_DSPComplex               DSPDoubleComplex
    109108#define aubio_DSPSplitComplex          DSPDoubleSplitComplex
    110 #define aubio_FFTSetup                 FFTSetupD
     109#define aubio_vDSP_DFT_Setup           vDSP_DFT_SetupD
     110#define aubio_vDSP_DFT_zrop_CreateSetup vDSP_DFT_zrop_CreateSetupD
     111#define aubio_vDSP_DFT_Execute         vDSP_DFT_ExecuteD
     112#define aubio_vDSP_DFT_DestroySetup    vDSP_DFT_DestroySetupD
    111113#define aubio_vvsqrt                   vvsqrt
    112114#endif /* HAVE_AUBIO_DOUBLE */
     
    153155
    154156#elif defined HAVE_ACCELERATE  // using ACCELERATE
    155   int log2fftsize;
    156   aubio_FFTSetup fftSetup;
     157  aubio_vDSP_DFT_Setup fftSetupFwd;
     158  aubio_vDSP_DFT_Setup fftSetupBwd;
    157159  aubio_DSPSplitComplex spec;
    158160  smpl_t *in, *out;
     
    211213
    212214#elif defined HAVE_ACCELERATE  // using ACCELERATE
     215  {
     216    uint_t radix = winsize;
     217    uint_t order = 0;
     218    while ((radix / 2) * 2 == radix) {
     219      radix /= 2;
     220      order++;
     221    }
     222    if (order < 4 || (radix != 1 && radix != 3 && radix != 5 && radix != 15)) {
     223      AUBIO_ERR("fft: vDSP/Accelerate supports FFT with sizes = "
     224          "f * 2 ** n, where n > 4 and f in [1, 3, 5, 15], but requested %d. "
     225          "Use the closest power of two, or try recompiling aubio with "
     226          "--enable-fftw3.\n", winsize);
     227      goto beach;
     228    }
     229  }
    213230  s->winsize = winsize;
    214231  s->fft_size = winsize;
    215232  s->compspec = new_fvec(winsize);
    216   s->log2fftsize = aubio_power_of_two_order(s->fft_size);
    217233  s->in = AUBIO_ARRAY(smpl_t, s->fft_size);
    218234  s->out = AUBIO_ARRAY(smpl_t, s->fft_size);
    219235  s->spec.realp = AUBIO_ARRAY(smpl_t, s->fft_size/2);
    220236  s->spec.imagp = AUBIO_ARRAY(smpl_t, s->fft_size/2);
    221   s->fftSetup = aubio_vDSP_create_fftsetup(s->log2fftsize, FFT_RADIX2);
     237  s->fftSetupFwd = aubio_vDSP_DFT_zrop_CreateSetup(NULL,
     238      s->fft_size, vDSP_DFT_FORWARD);
     239  s->fftSetupBwd = aubio_vDSP_DFT_zrop_CreateSetup(s->fftSetupFwd,
     240      s->fft_size, vDSP_DFT_INVERSE);
    222241
    223242#elif defined HAVE_INTEL_IPP  // using Intel IPP
     
    293312  AUBIO_FREE(s->spec.realp);
    294313  AUBIO_FREE(s->spec.imagp);
    295   aubio_vDSP_destroy_fftsetup(s->fftSetup);
     314  aubio_vDSP_DFT_DestroySetup(s->fftSetupBwd);
     315  aubio_vDSP_DFT_DestroySetup(s->fftSetupFwd);
    296316
    297317#elif defined HAVE_INTEL_IPP  // using Intel IPP
     
    351371  aubio_vDSP_ctoz((aubio_DSPComplex*)s->in, 2, &s->spec, 1, s->fft_size/2);
    352372  // compute the FFT
    353   aubio_vDSP_fft_zrip(s->fftSetup, &s->spec, 1, s->log2fftsize, FFT_FORWARD);
     373  aubio_vDSP_DFT_Execute(s->fftSetupFwd, s->spec.realp, s->spec.imagp,
     374      s->spec.realp, s->spec.imagp);
    354375  // convert from vDSP complex split to [ r0, r1, ..., rN, iN-1, .., i2, i1]
    355376  compspec->data[0] = s->spec.realp[0];
     
    419440  aubio_vDSP_ctoz((aubio_DSPComplex*)s->out, 2, &s->spec, 1, s->fft_size/2);
    420441  // compute the FFT
    421   aubio_vDSP_fft_zrip(s->fftSetup, &s->spec, 1, s->log2fftsize, FFT_INVERSE);
     442  aubio_vDSP_DFT_Execute(s->fftSetupBwd, s->spec.realp, s->spec.imagp,
     443      s->spec.realp, s->spec.imagp);
    422444  // convert result to real output
    423445  aubio_vDSP_ztoc(&s->spec, 1, (aubio_DSPComplex*)output->data, 2, s->fft_size/2);
     
    494516  }
    495517#endif
    496   if (compspec->data[compspec->length/2] < 0) {
    497     spectrum->phas[spectrum->length - 1] = PI;
     518#ifdef HAVE_FFTW3
     519  // for even length only, make sure last element is 0 or PI
     520  if (2 * (compspec->length / 2) == compspec->length) {
     521#endif
     522    if (compspec->data[compspec->length/2] < 0) {
     523      spectrum->phas[spectrum->length - 1] = PI;
     524    } else {
     525      spectrum->phas[spectrum->length - 1] = 0.;
     526    }
     527#ifdef HAVE_FFTW3
    498528  } else {
    499     spectrum->phas[spectrum->length - 1] = 0.;
    500   }
     529    i = spectrum->length - 1;
     530    spectrum->phas[i] = ATAN2(compspec->data[compspec->length-i],
     531        compspec->data[i]);
     532  }
     533#endif
    501534}
    502535
     
    508541        + SQR(compspec->data[compspec->length - i]) );
    509542  }
    510   spectrum->norm[spectrum->length-1] =
    511     ABS(compspec->data[compspec->length/2]);
     543#ifdef HAVE_FFTW3
     544  // for even length, make sure last element is > 0
     545  if (2 * (compspec->length / 2) == compspec->length) {
     546#endif
     547    spectrum->norm[spectrum->length-1] =
     548      ABS(compspec->data[compspec->length/2]);
     549#ifdef HAVE_FFTW3
     550  } else {
     551    i = spectrum->length - 1;
     552    spectrum->norm[i] = SQRT(SQR(compspec->data[i])
     553        + SQR(compspec->data[compspec->length - i]) );
     554  }
     555#endif
    512556}
    513557
  • src/spectral/filterbank.c

    r088760e rc03d191  
    2424#include "fmat.h"
    2525#include "cvec.h"
     26#include "vecutils.h"
    2627#include "spectral/filterbank.h"
    2728#include "mathutils.h"
     
    3334  uint_t n_filters;
    3435  fmat_t *filters;
     36  smpl_t norm;
     37  smpl_t power;
    3538};
    3639
     
    4548  /* allocate filter tables, a matrix of length win_s and of height n_filters */
    4649  fb->filters = new_fmat (n_filters, win_s / 2 + 1);
     50
     51  fb->norm = 1;
     52
     53  fb->power = 1;
    4754
    4855  return fb;
     
    6875  tmp.data = in->norm;
    6976
     77  if (f->power != 1.) fvec_pow(&tmp, f->power);
     78
    7079  fmat_vecmul(f->filters, &tmp, out);
    7180
     
    8594  return 0;
    8695}
     96
     97uint_t
     98aubio_filterbank_set_norm (aubio_filterbank_t *f, smpl_t norm)
     99{
     100  if (norm != 0 && norm != 1) return AUBIO_FAIL;
     101  f->norm = norm;
     102  return AUBIO_OK;
     103}
     104
     105smpl_t
     106aubio_filterbank_get_norm (aubio_filterbank_t *f)
     107{
     108  return f->norm;
     109}
     110
     111uint_t
     112aubio_filterbank_set_power (aubio_filterbank_t *f, smpl_t power)
     113{
     114  f->power = power;
     115  return AUBIO_OK;
     116}
     117
     118smpl_t
     119aubio_filterbank_get_power (aubio_filterbank_t *f)
     120{
     121  return f->norm;
     122}
  • src/spectral/filterbank.h

    r088760e rc03d191  
    8484uint_t aubio_filterbank_set_coeffs (aubio_filterbank_t * f, const fmat_t * filters);
    8585
     86/** set norm parameter
     87
     88  \param f filterbank object, as returned by new_aubio_filterbank()
     89  \param norm `1` to norm the filters, `0` otherwise.
     90
     91  If set to `0`, the filters will not be normalized. If set to `1`,
     92  each filter will be normalized to one. Defaults to `1`.
     93
     94  This function should be called *before* setting the filters with one of
     95  aubio_filterbank_set_triangle_bands(), aubio_filterbank_set_mel_coeffs(),
     96  aubio_filterbank_set_mel_coeffs_htk(), or
     97  aubio_filterbank_set_mel_coeffs_slaney().
     98
     99 */
     100uint_t aubio_filterbank_set_norm (aubio_filterbank_t *f, smpl_t norm);
     101
     102/** get norm parameter
     103
     104  \param f filterbank object, as returned by new_aubio_filterbank()
     105  \returns `1` if norm is set, `0` otherwise. Defaults to `1`.
     106
     107 */
     108smpl_t aubio_filterbank_get_norm (aubio_filterbank_t *f);
     109
     110/** set power parameter
     111
     112  \param f filterbank object, as returned by new_aubio_filterbank()
     113  \param power Raise norm of the input spectrum norm to this power before
     114  computing filterbank.  Defaults to `1`.
     115
     116 */
     117uint_t aubio_filterbank_set_power (aubio_filterbank_t *f, smpl_t power);
     118
     119/** get power parameter
     120
     121  \param f filterbank object, as returned by new_aubio_filterbank()
     122  \return current power parameter. Defaults to `1`.
     123
     124 */
     125smpl_t aubio_filterbank_get_power (aubio_filterbank_t *f);
     126
    86127#ifdef __cplusplus
    87128}
  • src/spectral/filterbank_mel.c

    r088760e rc03d191  
    5555  }
    5656
    57   if (freqs->data[freqs->length - 1] > samplerate / 2) {
    58     AUBIO_WRN ("Nyquist frequency is %fHz, but highest frequency band ends at \
    59 %fHz\n", samplerate / 2, freqs->data[freqs->length - 1]);
     57  for (fn = 0; fn < freqs->length; fn++) {
     58    if (freqs->data[fn] < 0) {
     59      AUBIO_ERR("filterbank_mel: freqs must contain only positive values.\n");
     60      return AUBIO_FAIL;
     61    } else if (freqs->data[fn] > samplerate / 2) {
     62      AUBIO_WRN("filterbank_mel: freqs should contain only "
     63          "values < samplerate / 2.\n");
     64    } else if (fn > 0 && freqs->data[fn] < freqs->data[fn-1]) {
     65      AUBIO_ERR("filterbank_mel: freqs should be a list of frequencies "
     66          "sorted from low to high, but freq[%d] < freq[%d-1]\n", fn, fn);
     67      return AUBIO_FAIL;
     68    } else if (fn > 0 && freqs->data[fn] == freqs->data[fn-1]) {
     69      AUBIO_WRN("filterbank_mel: set_triangle_bands received a list "
     70          "with twice the frequency %f\n", freqs->data[fn]);
     71    }
    6072  }
    6173
     
    7991
    8092  /* compute triangle heights so that each triangle has unit area */
    81   for (fn = 0; fn < n_filters; fn++) {
    82     triangle_heights->data[fn] =
    83         2. / (upper_freqs->data[fn] - lower_freqs->data[fn]);
     93  if (aubio_filterbank_get_norm(fb)) {
     94    for (fn = 0; fn < n_filters; fn++) {
     95      triangle_heights->data[fn] =
     96          2. / (upper_freqs->data[fn] - lower_freqs->data[fn]);
     97    }
     98  } else {
     99    fvec_ones (triangle_heights);
    84100  }
    85101
     
    92108  /* zeroing of all filters */
    93109  fmat_zeros (filters);
    94 
    95   if (fft_freqs->data[1] >= lower_freqs->data[0]) {
    96     /* - 1 to make sure we don't miss the smallest power of two */
    97     uint_t min_win_s =
    98         (uint_t) FLOOR (samplerate / lower_freqs->data[0]) - 1;
    99     AUBIO_WRN ("Lowest frequency bin (%.2fHz) is higher than lowest frequency \
    100 band (%.2f-%.2fHz). Consider increasing the window size from %d to %d.\n",
    101         fft_freqs->data[1], lower_freqs->data[0],
    102         upper_freqs->data[0], (win_s - 1) * 2,
    103         aubio_next_power_of_two (min_win_s));
    104   }
    105110
    106111  /* building each filter table */
     
    117122
    118123    /* compute positive slope step size */
    119     riseInc =
    120         triangle_heights->data[fn] /
    121         (center_freqs->data[fn] - lower_freqs->data[fn]);
     124    riseInc = triangle_heights->data[fn]
     125      / (center_freqs->data[fn] - lower_freqs->data[fn]);
    122126
    123127    /* compute coefficients in positive slope */
     
    133137
    134138    /* compute negative slope step size */
    135     downInc =
    136         triangle_heights->data[fn] /
    137         (upper_freqs->data[fn] - center_freqs->data[fn]);
     139    downInc = triangle_heights->data[fn]
     140      / (upper_freqs->data[fn] - center_freqs->data[fn]);
    138141
    139142    /* compute coefficents in negative slope */
     
    161164  del_fvec (fft_freqs);
    162165
    163   return 0;
     166  return AUBIO_OK;
    164167}
    165168
     
    168171    smpl_t samplerate)
    169172{
    170   uint_t retval;
    171 
    172173  /* Malcolm Slaney parameters */
    173   smpl_t lowestFrequency = 133.3333;
    174   smpl_t linearSpacing = 66.66666666;
    175   smpl_t logSpacing = 1.0711703;
    176 
    177   uint_t linearFilters = 13;
    178   uint_t logFilters = 27;
    179   uint_t n_filters = linearFilters + logFilters;
    180 
    181   uint_t fn;                    /* filter counter */
    182 
     174  const smpl_t lowestFrequency = 133.3333;
     175  const smpl_t linearSpacing = 66.66666666;
     176  const smpl_t logSpacing = 1.0711703;
     177
     178  const uint_t linearFilters = 13;
     179  const uint_t logFilters = 27;
     180  const uint_t n_filters = linearFilters + logFilters;
     181
     182  uint_t fn, retval;
    183183  smpl_t lastlinearCF;
    184184
    185185  /* buffers to compute filter frequencies */
    186   fvec_t *freqs = new_fvec (n_filters + 2);
     186  fvec_t *freqs;
     187
     188  if (samplerate <= 0) {
     189    AUBIO_ERR("filterbank: set_mel_coeffs_slaney samplerate should be > 0\n");
     190    return AUBIO_FAIL;
     191  }
     192
     193  freqs = new_fvec (n_filters + 2);
    187194
    188195  /* first step: fill all the linear filter frequencies */
     
    206213  return retval;
    207214}
     215
     216static uint_t aubio_filterbank_check_freqs (aubio_filterbank_t *fb UNUSED,
     217    smpl_t samplerate, smpl_t *freq_min, smpl_t *freq_max)
     218{
     219  if (samplerate <= 0) {
     220    AUBIO_ERR("filterbank: set_mel_coeffs samplerate should be > 0\n");
     221    return AUBIO_FAIL;
     222  }
     223  if (*freq_max < 0) {
     224    AUBIO_ERR("filterbank: set_mel_coeffs freq_max should be > 0\n");
     225    return AUBIO_FAIL;
     226  } else if (*freq_max == 0) {
     227    *freq_max = samplerate / 2.;
     228  }
     229  if (*freq_min < 0) {
     230    AUBIO_ERR("filterbank: set_mel_coeffs freq_min should be > 0\n");
     231    return AUBIO_FAIL;
     232  }
     233  return AUBIO_OK;
     234}
     235
     236uint_t
     237aubio_filterbank_set_mel_coeffs (aubio_filterbank_t * fb, smpl_t samplerate,
     238    smpl_t freq_min, smpl_t freq_max)
     239{
     240  uint_t m, retval;
     241  smpl_t start = freq_min, end = freq_max, step;
     242  fvec_t *freqs;
     243  fmat_t *coeffs = aubio_filterbank_get_coeffs(fb);
     244  uint_t n_bands = coeffs->height;
     245
     246  if (aubio_filterbank_check_freqs(fb, samplerate, &start, &end)) {
     247    return AUBIO_FAIL;
     248  }
     249
     250  start = aubio_hztomel(start);
     251  end = aubio_hztomel(end);
     252
     253  freqs = new_fvec(n_bands + 2);
     254  step = (end - start) / (n_bands + 1);
     255
     256  for (m = 0; m < n_bands + 2; m++)
     257  {
     258    freqs->data[m] = MIN(aubio_meltohz(start + step * m), samplerate/2.);
     259  }
     260
     261  retval = aubio_filterbank_set_triangle_bands (fb, freqs, samplerate);
     262
     263  /* destroy vector used to store frequency limits */
     264  del_fvec (freqs);
     265  return retval;
     266}
     267
     268uint_t
     269aubio_filterbank_set_mel_coeffs_htk (aubio_filterbank_t * fb, smpl_t samplerate,
     270    smpl_t freq_min, smpl_t freq_max)
     271{
     272  uint_t m, retval;
     273  smpl_t start = freq_min, end = freq_max, step;
     274  fvec_t *freqs;
     275  fmat_t *coeffs = aubio_filterbank_get_coeffs(fb);
     276  uint_t n_bands = coeffs->height;
     277
     278  if (aubio_filterbank_check_freqs(fb, samplerate, &start, &end)) {
     279    return AUBIO_FAIL;
     280  }
     281
     282  start = aubio_hztomel_htk(start);
     283  end = aubio_hztomel_htk(end);
     284
     285  freqs = new_fvec (n_bands + 2);
     286  step = (end - start) / (n_bands + 1);
     287
     288  for (m = 0; m < n_bands + 2; m++)
     289  {
     290    freqs->data[m] = MIN(aubio_meltohz_htk(start + step * m), samplerate/2.);
     291  }
     292
     293  retval = aubio_filterbank_set_triangle_bands (fb, freqs, samplerate);
     294
     295  /* destroy vector used to store frequency limits */
     296  del_fvec (freqs);
     297  return retval;
     298}
  • src/spectral/filterbank_mel.h

    r088760e rc03d191  
    5656
    5757  \param fb filterbank object
    58   \param samplerate audio sampling rate
     58  \param samplerate audio sampling rate, in Hz
    5959
    60   The filter coefficients are built according to Malcolm Slaney's Auditory
    61   Toolbox, available online at the following address (see file mfcc.m):
     60  The filter coefficients are built to match exactly Malcolm Slaney's Auditory
     61  Toolbox implementation (see file mfcc.m). The number of filters should be 40.
    6262
     63  References
     64  ----------
     65
     66  Malcolm Slaney, *Auditory Toolbox Version 2, Technical Report #1998-010*
    6367  https://engineering.purdue.edu/~malcolm/interval/1998-010/
    6468
     
    6771    smpl_t samplerate);
    6872
     73/** Mel filterbank initialization
     74
     75  \param fb filterbank object
     76  \param samplerate audio sampling rate
     77  \param fmin start frequency, in Hz
     78  \param fmax end frequency, in Hz
     79
     80  The filterbank will be initialized with bands linearly spaced in the mel
     81  scale, from `fmin` to `fmax`.
     82
     83  References
     84  ----------
     85
     86  Malcolm Slaney, *Auditory Toolbox Version 2, Technical Report #1998-010*
     87  https://engineering.purdue.edu/~malcolm/interval/1998-010/
     88
     89*/
     90uint_t aubio_filterbank_set_mel_coeffs(aubio_filterbank_t * fb,
     91    smpl_t samplerate, smpl_t fmin, smpl_t fmax);
     92
     93/** Mel filterbank initialization
     94
     95  \param fb filterbank object
     96  \param samplerate audio sampling rate
     97  \param fmin start frequency, in Hz
     98  \param fmax end frequency, in Hz
     99
     100  The bank of filters will be initalized to to cover linearly spaced bands in
     101  the Htk mel scale, from `fmin` to `fmax`.
     102
     103  References
     104  ----------
     105
     106  Douglas O'Shaughnessy (1987). *Speech communication: human and machine*.
     107  Addison-Wesley. p. 150. ISBN 978-0-201-16520-3.
     108
     109  HTK Speech Recognition Toolkit: http://htk.eng.cam.ac.uk/
     110
     111*/
     112uint_t aubio_filterbank_set_mel_coeffs_htk(aubio_filterbank_t * fb,
     113    smpl_t samplerate, smpl_t fmin, smpl_t fmax);
     114
    69115#ifdef __cplusplus
    70116}
  • src/spectral/mfcc.c

    r088760e rc03d191  
    5252  fvec_t *output;
    5353#endif
     54  smpl_t scale;
    5455};
    5556
     
    7576  /* filterbank allocation */
    7677  mfcc->fb = new_aubio_filterbank (n_filters, mfcc->win_s);
    77   aubio_filterbank_set_mel_coeffs_slaney (mfcc->fb, samplerate);
     78  if (n_filters == 40)
     79    aubio_filterbank_set_mel_coeffs_slaney (mfcc->fb, samplerate);
     80  else
     81    aubio_filterbank_set_mel_coeffs(mfcc->fb, samplerate,
     82        0, samplerate/2.);
    7883
    7984  /* allocating buffers */
     
    97102  mfcc->output = new_fvec (n_filters);
    98103#endif
     104
     105  mfcc->scale = 1.;
    99106
    100107  return mfcc;
     
    128135  fvec_t tmp;
    129136#endif
     137
    130138  /* compute filterbank */
    131139  aubio_filterbank_do (mf->fb, in, mf->in_dct);
     
    134142  fvec_log10 (mf->in_dct);
    135143
    136   /* raise power */
    137   //fvec_pow (mf->in_dct, 3.);
     144  if (mf->scale != 1) fvec_mul (mf->in_dct, mf->scale);
    138145
    139146  /* compute mfccs */
     
    151158  return;
    152159}
     160
     161uint_t aubio_mfcc_set_power (aubio_mfcc_t *mf, smpl_t power)
     162{
     163  return aubio_filterbank_set_power(mf->fb, power);
     164}
     165
     166uint_t aubio_mfcc_get_power (aubio_mfcc_t *mf)
     167{
     168  return aubio_filterbank_get_power(mf->fb);
     169}
     170
     171uint_t aubio_mfcc_set_scale (aubio_mfcc_t *mf, smpl_t scale)
     172{
     173  mf->scale = scale;
     174  return AUBIO_OK;
     175}
     176
     177uint_t aubio_mfcc_get_scale (aubio_mfcc_t *mf)
     178{
     179  return mf->scale;
     180}
     181
     182uint_t aubio_mfcc_set_mel_coeffs (aubio_mfcc_t *mf, smpl_t freq_min,
     183    smpl_t freq_max)
     184{
     185  return aubio_filterbank_set_mel_coeffs(mf->fb, mf->samplerate,
     186      freq_min, freq_max);
     187}
     188
     189uint_t aubio_mfcc_set_mel_coeffs_htk (aubio_mfcc_t *mf, smpl_t freq_min,
     190    smpl_t freq_max)
     191{
     192  return aubio_filterbank_set_mel_coeffs_htk(mf->fb, mf->samplerate,
     193      freq_min, freq_max);
     194}
     195
     196uint_t aubio_mfcc_set_mel_coeffs_slaney (aubio_mfcc_t *mf)
     197{
     198  return aubio_filterbank_set_mel_coeffs_slaney (mf->fb, mf->samplerate);
     199}
  • src/spectral/mfcc.h

    r088760e rc03d191  
    7474void aubio_mfcc_do (aubio_mfcc_t * mf, const cvec_t * in, fvec_t * out);
    7575
     76/** set power parameter
     77
     78  \param mf mfcc object, as returned by new_aubio_mfcc()
     79  \param power Raise norm of the input spectrum norm to this power before
     80  computing filterbank.  Defaults to `1`.
     81
     82  See aubio_filterbank_set_power().
     83
     84 */
     85uint_t aubio_mfcc_set_power (aubio_mfcc_t *mf, smpl_t power);
     86
     87/** get power parameter
     88
     89  \param mf mfcc object, as returned by new_aubio_mfcc()
     90  \return current power parameter. Defaults to `1`.
     91
     92  See aubio_filterbank_get_power().
     93
     94 */
     95uint_t aubio_mfcc_get_power (aubio_mfcc_t *mf);
     96
     97/** set scaling parameter
     98
     99  \param mf mfcc object, as returned by new_aubio_mfcc()
     100  \param scale Scaling value to apply.
     101
     102  Scales the output of the filterbank after taking its logarithm and before
     103  computing the DCT. Defaults to `1`.
     104
     105*/
     106uint_t aubio_mfcc_set_scale (aubio_mfcc_t *mf, smpl_t scale);
     107
     108/** get scaling parameter
     109
     110  \param mf mfcc object, as returned by new_aubio_mfcc()
     111  \return current scaling parameter. Defaults to `1`.
     112
     113 */
     114uint_t aubio_mfcc_get_scale (aubio_mfcc_t *mf);
     115
     116/** Mel filterbank initialization
     117
     118  \param mf mfcc object
     119  \param fmin start frequency, in Hz
     120  \param fmax end frequency, in Hz
     121
     122  The filterbank will be initialized with bands linearly spaced in the mel
     123  scale, from `fmin` to `fmax`.
     124
     125  See also
     126  --------
     127
     128  aubio_filterbank_set_mel_coeffs()
     129
     130*/
     131uint_t aubio_mfcc_set_mel_coeffs (aubio_mfcc_t *mf,
     132        smpl_t fmin, smpl_t fmax);
     133
     134/** Mel filterbank initialization
     135
     136  \param mf mfcc object
     137  \param fmin start frequency, in Hz
     138  \param fmax end frequency, in Hz
     139
     140  The bank of filters will be initalized to to cover linearly spaced bands in
     141  the Htk mel scale, from `fmin` to `fmax`.
     142
     143  See also
     144  --------
     145
     146  aubio_filterbank_set_mel_coeffs_htk()
     147
     148*/
     149uint_t aubio_mfcc_set_mel_coeffs_htk (aubio_mfcc_t *mf,
     150        smpl_t fmin, smpl_t fmax);
     151
     152/** Mel filterbank initialization (Auditory Toolbox's parameters)
     153
     154  \param mf mfcc object
     155  \param samplerate audio sampling rate, in Hz
     156
     157  The filter coefficients are built to match exactly Malcolm Slaney's Auditory
     158  Toolbox implementation. The number of filters should be 40.
     159
     160  This is the default filterbank when `mf` was created with `n_filters = 40`.
     161
     162  See also
     163  --------
     164
     165  aubio_filterbank_set_mel_coeffs_slaney()
     166
     167*/
     168uint_t aubio_mfcc_set_mel_coeffs_slaney (aubio_mfcc_t *mf);
     169
    76170#ifdef __cplusplus
    77171}
  • tests/src/spectral/test-filterbank.c

    r088760e rc03d191  
    1111  // create filterbank object
    1212  aubio_filterbank_t *o = new_aubio_filterbank (n_filters, win_s);
     13
     14  smpl_t power = aubio_filterbank_get_power(o);
     15  smpl_t norm = aubio_filterbank_get_norm(o);
     16  if (aubio_filterbank_set_power(o, power)) {
     17    return 1;
     18  }
     19  if (aubio_filterbank_set_norm(o, norm)) {
     20    return 1;
     21  }
    1322
    1423  // apply filterbank ten times
  • tests/src/temporal/test-filter.c

    r088760e rc03d191  
    99
    1010  aubio_filter_t *o = new_aubio_filter_c_weighting (44100);
     11
     12  if (new_aubio_filter(0))
     13    return 1;
     14
     15  if (aubio_filter_get_samplerate(o) != 44100)
     16    return 1;
     17
     18  if (aubio_filter_set_c_weighting (o, -1) == 0)
     19    return 1;
     20
     21  if (aubio_filter_set_c_weighting (0, 32000) == 0)
     22    return 1;
     23
    1124  in->data[impulse_at] = 0.5;
    1225  fvec_print (in);
     
    1629
    1730  o = new_aubio_filter_a_weighting (32000);
     31
     32  if (aubio_filter_set_a_weighting (o, -1) == 0)
     33    return 1;
     34  if (aubio_filter_set_a_weighting (0, 32000) == 0)
     35    return 1;
     36
    1837  in->data[impulse_at] = 0.5;
    1938  fvec_print (in);
  • wscript

    r088760e rc03d191  
    4343            choices = ('debug', 'release'),
    4444            dest = 'build_type',
    45             help = 'whether to compile with (--build-type=release) or without (--build-type=debug) '\
    46               ' compiler opimizations [default: release]')
     45            help = 'whether to compile with (--build-type=release)' \
     46                    ' or without (--build-type=debug)' \
     47                    ' compiler opimizations [default: release]')
    4748    add_option_enable_disable(ctx, 'fftw3f', default = False,
    4849            help_str = 'compile with fftw3f instead of ooura (recommended)',
     
    110111
    111112    ctx.add_option('--with-target-platform', type='string',
    112             help='set target platform for cross-compilation', dest='target_platform')
     113            help='set target platform for cross-compilation',
     114            dest='target_platform')
    113115
    114116    ctx.load('compiler_c')
     
    206208            ctx.msg('Checking for AudioToolbox.framework', 'yes')
    207209        else:
    208             ctx.msg('Checking for AudioToolbox.framework', 'no (disabled)', color = 'YELLOW')
     210            ctx.msg('Checking for AudioToolbox.framework', 'no (disabled)',
     211                    color = 'YELLOW')
    209212        if (ctx.options.enable_accelerate != False):
    210213            ctx.define('HAVE_ACCELERATE', 1)
     
    212215            ctx.msg('Checking for Accelerate framework', 'yes')
    213216        else:
    214             ctx.msg('Checking for Accelerate framework', 'no (disabled)', color = 'YELLOW')
     217            ctx.msg('Checking for Accelerate framework', 'no (disabled)',
     218                    color = 'YELLOW')
    215219
    216220    if target_platform in [ 'ios', 'iosimulator' ]:
     
    266270        # tell emscripten functions we want to expose
    267271        from python.lib.gen_external import get_c_declarations, \
    268                 get_cpp_objects_from_c_declarations, get_all_func_names_from_lib, \
     272                get_cpp_objects_from_c_declarations, \
     273                get_all_func_names_from_lib, \
    269274                generate_lib_from_c_declarations
    270         c_decls = get_c_declarations(usedouble=False)  # emscripten can't use double
     275        # emscripten can't use double
     276        c_decls = get_c_declarations(usedouble=False)
    271277        objects = list(get_cpp_objects_from_c_declarations(c_decls))
    272278        # ensure that aubio structs are exported
     
    275281        exported_funcnames = get_all_func_names_from_lib(lib)
    276282        c_mangled_names = ['_' + s for s in exported_funcnames]
    277         ctx.env.LINKFLAGS_cshlib += ['-s', 'EXPORTED_FUNCTIONS=%s' % c_mangled_names]
     283        ctx.env.LINKFLAGS_cshlib += ['-s',
     284                'EXPORTED_FUNCTIONS=%s' % c_mangled_names]
    278285
    279286    # check support for C99 __VA_ARGS__ macros
     
    305312    # check for Intel IPP
    306313    if (ctx.options.enable_intelipp != False):
    307         has_ipp_headers = ctx.check(header_name=['ippcore.h', 'ippvm.h', 'ipps.h'],
    308                 mandatory = False)
     314        has_ipp_headers = ctx.check(header_name=['ippcore.h', 'ippvm.h',
     315            'ipps.h'], mandatory = False)
    309316        has_ipp_libs = ctx.check(lib=['ippcore', 'ippvm', 'ipps'],
    310317                uselib_store='INTEL_IPP', mandatory = False)
     
    313320            ctx.define('HAVE_INTEL_IPP', 1)
    314321            if ctx.env.CC_NAME == 'msvc':
    315                 # force linking multi-threaded static IPP libraries on Windows with msvc
     322                # force linking multi-threaded static IPP libraries on Windows
     323                # with msvc
    316324                ctx.define('_IPP_SEQUENTIAL_STATIC', 1)
    317325        else:
     
    362370    if (ctx.options.enable_double):
    363371        if (ctx.options.enable_samplerate):
    364             ctx.fatal("Could not compile aubio in double precision mode with libsamplerate")
     372            ctx.fatal("Could not compile aubio in double precision mode' \
     373                    ' with libsamplerate")
    365374        else:
    366375            ctx.options.enable_samplerate = False
    367             ctx.msg('Checking if using samplerate', 'no (disabled in double precision mode)',
    368                     color = 'YELLOW')
     376            ctx.msg('Checking if using samplerate',
     377                    'no (disabled in double precision mode)', color = 'YELLOW')
    369378    if (ctx.options.enable_samplerate != False):
    370379        ctx.check_cfg(package = 'samplerate',
     
    409418        elif 'HAVE_AVUTIL' not in ctx.env:
    410419            ctx.msg(msg_check, 'not found (missing avutil)', color = 'YELLOW')
    411         elif 'HAVE_SWRESAMPLE' not in ctx.env and 'HAVE_AVRESAMPLE' not in ctx.env:
     420        elif 'HAVE_SWRESAMPLE' not in ctx.env \
     421                and 'HAVE_AVRESAMPLE' not in ctx.env:
    412422            resample_missing = 'not found (avresample or swresample required)'
    413423            ctx.msg(msg_check, resample_missing, color = 'YELLOW')
     
    422432    if (ctx.options.enable_wavread != False):
    423433        ctx.define('HAVE_WAVREAD', 1)
    424     ctx.msg('Checking if using source_wavread', ctx.options.enable_wavread and 'yes' or 'no')
     434    ctx.msg('Checking if using source_wavread',
     435            ctx.options.enable_wavread and 'yes' or 'no')
    425436    if (ctx.options.enable_wavwrite!= False):
    426437        ctx.define('HAVE_WAVWRITE', 1)
    427     ctx.msg('Checking if using sink_wavwrite', ctx.options.enable_wavwrite and 'yes' or 'no')
     438    ctx.msg('Checking if using sink_wavwrite',
     439            ctx.options.enable_wavwrite and 'yes' or 'no')
    428440
    429441    # use BLAS/ATLAS
     
    543555
    544556def sphinx(bld):
    545     # build documentation from source files using sphinx-build
    546     # note: build in ../doc/_build/html, otherwise waf wont install unsigned files
     557    # build documentation from source files using sphinx-build note: build in
     558    # ../doc/_build/html, otherwise waf wont install unsigned files
    547559    if bld.env['SPHINX']:
    548560        bld.env.VERSION = VERSION
    549561        bld( name = 'sphinx',
    550                 rule = '${SPHINX} -b html -D release=${VERSION} -D version=${VERSION} -a -q `dirname ${SRC}` `dirname ${TGT}`',
     562                rule = '${SPHINX} -b html -D release=${VERSION}' \
     563                        ' -D version=${VERSION} -a -q' \
     564                        ' `dirname ${SRC}` `dirname ${TGT}`',
    551565                source = 'doc/conf.py',
    552566                target = '../doc/_build/html/index.html')
     
    578592    from waflib import Logs
    579593    if bld.options.target_platform in ['ios', 'iosimulator']:
    580         msg ='building for %s, contact the author for a commercial license' % bld.options.target_platform
     594        msg ='building for %s, contact the author for a commercial license' \
     595                % bld.options.target_platform
    581596        Logs.pprint('RED', msg)
    582597        msg ='   Paul Brossier <piem@aubio.org>'
     
    584599
    585600def dist(ctx):
    586     ctx.excl  = ' **/.waf* **/*~ **/*.pyc **/*.swp **/*.swo **/*.swn **/.lock-w* **/.git*'
     601    ctx.excl  = ' **/.waf*'
     602    ctx.excl += ' **/.git*'
     603    ctx.excl += ' **/*~ **/*.pyc **/*.swp **/*.swo **/*.swn **/.lock-w*'
    587604    ctx.excl += ' **/build/*'
    588605    ctx.excl += ' doc/_build'
     
    592609    ctx.excl += ' **/python/lib/aubio/_aubio.so'
    593610    ctx.excl += ' **.egg-info'
     611    ctx.excl += ' **/.eggs'
     612    ctx.excl += ' **/.pytest_cache'
     613    ctx.excl += ' **/.cache'
    594614    ctx.excl += ' **/**.zip **/**.tar.bz2'
    595615    ctx.excl += ' **.tar.bz2'
Note: See TracChangeset for help on using the changeset viewer.