Changeset 088760e

.appveyor.yml

-                      r45c2c5c
+                      r088760e
 environment:
+  global:
+      CUSTOM64PATH: C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin
   matrix:
     # pre-installed python version, see:
     # http://www.appveyor.com/docs/installed-software#python
     - PYTHONDIR: "C:\\Python27"
       PYTHON_VERSION: "2.7.x"
       PYTHON_ARCH: "32"
+    - PYTHONDIR: C:\Python27
+      PYTHON_VERSION: 2.7.x
+      PYTHON_ARCH: 32
     - PYTHONDIR: "C:\\Python27-x64"
       PYTHON_VERSION: "2.7.x"
       PYTHON_ARCH: "64"
+    - PYTHONDIR: C:\Python27-x64
+      PYTHON_VERSION: 2.7.x
+      PYTHON_ARCH: 64
     - PYTHONDIR: "C:\\Python34"
       PYTHON_VERSION: "3.4.x"
       PYTHON_ARCH: "32"
+    - PYTHONDIR: C:\Python35
+      PYTHON_VERSION: 3.5.x
+      PYTHON_ARCH: 32
     - PYTHONDIR: "C:\\Python34-x64"
       PYTHON_VERSION: "3.4.x"
       PYTHON_ARCH: "64"
+    - PYTHONDIR: C:\Python35-x64
+      PYTHON_VERSION: 3.5.x
+      PYTHON_ARCH: 64
     - PYTHONDIR: "C:\\Python35"
       PYTHON_VERSION: "3.5.x"
       PYTHON_ARCH: "32"
+    - PYTHONDIR: C:\Python36
+      PYTHON_VERSION: 3.6.x
+      PYTHON_ARCH: 32
+    - PYTHONDIR: "C:\\Python35-x64"
+      PYTHON_VERSION: "3.5.x"
+      PYTHON_ARCH: "64"
+      # add path required to run preprocessor step
+      PATH_EXTRAS: "c:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\bin"
+    - PYTHONDIR: C:\Python36-x64
+      PYTHON_VERSION: 3.6.x
+      PYTHON_ARCH: 64
+    - PYTHONDIR: C:\Python37
+      PYTHON_VERSION: 3.7.x
+      PYTHON_ARCH: 32
+    - PYTHONDIR: C:\Python37-x64
+      PYTHON_VERSION: 3.7.x
+      PYTHON_ARCH: 64
 install:
 …
   - ps: "ls \"C:/Program Files/Microsoft SDKs/Windows\""
+  - "SET PATH=%PYTHONDIR%;%PYTHONDIR%\\Scripts;%PATH%"
+  - if [%PYTHON_ARCH%]==[64] SET PATH=%CUSTOM64PATH%;%PATH%
   # Check that we have the expected version and architecture for Python
   - "%PYTHONDIR%\\python.exe --version"
   - "%PYTHONDIR%\\python.exe -c \"import struct; print(struct.calcsize('P') * 8)\""
+  - "python --version"
+  - "python -c \"import struct; print(struct.calcsize('P') * 8)\""
   - "%PYTHONDIR%\\python.exe -m pip install --disable-pip-version-check --user --upgrade pip"
   - "%PYTHONDIR%\\python.exe -m pip install --upgrade setuptools"
+  - "python -m pip install --disable-pip-version-check --user --upgrade pip"
+  - "python -m pip install --upgrade setuptools"
   # We need wheel installed to build wheels
   - "%PYTHONDIR%\\python.exe -m pip install wheel"
+  - "python -m pip install wheel"
   - "SET PATH=%PATH_EXTRAS%;%PYTHONDIR%;%PYTHONDIR%\\Scripts;%PATH%"
+  - "pip install -r requirements.txt"
 before_build:
 …
 build_script:
+  # also build libaubio with waf
+  - python waf configure build install --verbose --msvc_version="msvc 14.0"
+  # clean before building python package
+  - python waf distclean
   # build python module without using libaubio
+  - "%PYTHONDIR%\\python.exe -m pip install -r requirements.txt"
+  - "python setup.py build"
+  - "%PYTHONDIR%\\python.exe -m pip install ."
+  - pip wheel -v -v -v --wheel-dir=dist .
+  # build, upload and install wheel (inspired by numpy's appveyor)
+  - ps: |
+      pip wheel -v -v -v --wheel-dir=dist .
+      ls dist -r | Foreach-Object {
+          Push-AppveyorArtifact $_.FullName
+          pip install $_.FullName
+      }
+test_script:
   - "python python\\demos\\demo_create_test_sounds.py"
   - "nose2 --verbose"
-  # clean up
-  - "python waf distclean"
-  # build libaubio
-  - python waf configure build --verbose --msvc_version="msvc 14.0"

.gitignore

r45c2c5c	r088760e
44	44	aubio-*.zip
45	45	dist/*.tar.gz
	46	dist/*.whl
46	47
47	48	# test sounds

ChangeLog

-                      r45c2c5c
+                      r088760e
+-09-22 Paul Brossier <piem@aubio.org>
+        [ Overview ]
+        * VERSION: bump to 0.4.7
+        * src/spectral/dct.h: add dct type II object with optimised versions
+        * src/io/, src/notes/, src/pitch: prevent crashes on corrupted files
+        * examples/: fix jack midi output, improve messages when jack disabled
+        * python/: add dct support, minor bug fixes tests and demos
+        * wscript: improve support for BLAS/ATLAS
+        [ Library fixes ]
+        * src/pitch/pitchyinfft.c: fix out of bound read when samplerate > 50kHz
+        thanks to @fCorleone (closes #189, CVE-2018-14523, debian #904906)
+        * src/notes/notes.c: bail out if pitch creation failed (see #188)
+        * src/io/source_wavread.c:
+         - also exit if samplerate is negative (closes #188, CVE-2018-14522,
+         debian #904907)
+         - add some input validation (closes #148 and #158, CVE-2017-17054,
+         debian #883355)
+        * src/io/source_avcodec.c:
+         - give up if resampling context failed opening (see #137, closes #187,
+         CVE-2018-14521, debian #904908)
+         - give up reading file if number of channel changes during stream (closes
+         #137, CVE-2017-17554, debian #884237)
+         - make sure libavutil > 52 before checking avFrame->channels (see #137)
+         - fix build with ffmpeg 4.0, thanks to @jcowgill (closes #168, #173)
+         - avoid deprecated call for ffmpeg >= 4.0
+        * src/onset/onset.c: add dummy default parameters for wphase (closes #150)
+        [ Tools ]
+        * examples/parse_args.h: hide jack options if not available, improve error
+        message (closes #182)
+        * examples/utils.h: process_block returns void
+        * examples/utils.c: fix examples failing to send more than one JACK midi
+        event per frame, thanks to @cyclopsian (closes #201)
+        [ New features ]
+        * src/spectral/dct.h: add dct type II object with implementation factory
+        * src/spectral/dct_plain.c: add plain dct implementation
+        * src/spectral/dct_ooura.c: add ooura implementation
+        * src/spectral/dct_fftw.c: add fftw implementation
+        * src/spectral/dct_ipp.c: add ipp version
+        * src/spectral/dct_accelerate.c: add vdsp/accelerate dct
+        * tests/src/spectral/test-dct.c: check reconstruction works
+        * src/spectral/mfcc.c: use new dct to compute mfcc
+        [ Library internals ]
+        * src/aubio_priv.h: avoid hard-coded undefs, split BLAS and ATLAS support,
+        add vdsp scalar add and multiply
+        [ Build system ]
+        * wscript:
+         - add options to disable examples and tests
+         - detect includes for openblas/libblas/atlas
+        * scripts/get_waf.sh: bump to 2.0.11, verify signature if gpg available
+        * python/lib/gen_external.py: pass '-x c' to emcc only
+        [ Python ]
+        * python/lib/gen_code.py: add support for rdo methods
+        * python/tests/test_dct.py: add tests for new dct
+        * python/demos/demo_pitch_sinusoid.py: use // to yield an integer, fixing
+        demo on py3, thanks to @ancorcruz (closes #176)
+        * python/ext/py-musicutils.*: add shift(fvec) and ishift(fvec)
+        * python/tests/test_fvec_shift.py: add tests for shift() and ishift()
+        * python/lib/aubio/cmd.py: fix typo in comment
+        [ Documentation ]
+        * README.md, doc/statuslinks.rst: use latest for commits-since
+        * examples/parse_args.h: add yinfast to pitch algorithms
+        * doc/requirements.rst: add some blas documentation
+        * doc/requirements.rst: split media/optimisation libraries
+        * doc/develop.rst: fixed spelling error, thanks to Jon Williams (closes #161)
+        * doc/aubio{pitch,notes}.txt: add yinfast to list of pitch methods
+        [ Continuous integration ]
+        * .travis.yml: remove xcode8.2 builds, group osx, add alias pip=pip2
+        * .appveyor.yml: upgrade pip first, always use python -m pip
 -10-02 Paul Brossier <piem@aubio.org>

VERSION

r45c2c5c	r088760e
1	1	AUBIO_MAJOR_VERSION=0
2	2	AUBIO_MINOR_VERSION=4
3		AUBIO_PATCH_VERSION=7
	3	AUBIO_PATCH_VERSION=8
4	4	AUBIO_VERSION_STATUS='~alpha'
5	5	LIBAUBIO_LT_CUR=5

doc/about.rst

r45c2c5c	r088760e
60	60	-------
61	61
62		aubio is a `free <http://www.debian.org/intro/free>`_ and `open source
	62	aubio is a `free <https://www.debian.org/intro/free>`_ and `open source
63	63	<http://www.opensource.org/docs/definition.php>`_ software; you can
64	64	redistribute it and/or modify it under the terms of the `GNU

doc/aubio.txt

-                      r45c2c5c
+                      r088760e
 NOTES
+  The "note" command accepts all common options and no additional options.
+  The following additional options can be used with the "notes" subcommand.
+  -s <value>, --silence <value>  silence threshold, in dB (default: -70)
+  -d <value>, --release-drop <value>  release drop level, in dB. If the level
+  drops more than this amount since the last note started, the note will be
+  turned off (default: 10).
 MFCC

doc/aubiomfcc.txt

r45c2c5c	r088760e
52	52	url:
53	53
54		http~~://cobweb.ecn~~.purdue.edu/~malcolm/interval/1998-010/ (see file mfcc.m)
	54	https://engineering.purdue.edu/~malcolm/interval/1998-010/ (see file mfcc.m)
55	55
56	56	SEE ALSO

doc/aubionotes.txt

-                      r45c2c5c
+                      r088760e
   aubionotes [[-i] source]
              [-r rate] [-B win] [-H hop]
              [-O method] [-t thres]
+             [-O method] [-t thres] [-d drop]
              [-p method] [-u unit] [-l thres]
              [-T time-format]
 …
   loudest ones. A value of -90.0 would select all onsets. Defaults to -90.0.
+  -d, --release-drop  Set the release drop threshold, in dB. If the level drops
+  more than this amount since the last note started, the note will be turned
+  off. Defaults to 10.
   -T, --timeformat format  Set time format (samples, ms, seconds). Defaults to
   seconds.
 …
 PITCH METHODS
+  Available methods: default, schmitt, fcomb, mcomb, specacf, yin, yinfft.
+  Available methods: default, schmitt, fcomb, mcomb, specacf, yin, yinfft,
+  yinfast.
   See aubiopitch(1) for details about these methods.

doc/aubiopitch.txt

-                      r45c2c5c
+                      r088760e
   University of London, London, UK, 2006.
+  yinfast  YIN algorithm (accelerated)
+  An optimised implementation of the YIN algorithm, yielding results identical
+  to the original YIN algorithm, while reducing its computational cost from
+  O(n^2) to O(n log(n)).
 SEE ALSO

doc/conf.py

-                      r45c2c5c
+                      r088760e
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
+extensions = ['sphinx.ext.viewcode', 'sphinx.ext.autodoc']
+extensions = ['sphinx.ext.viewcode', 'sphinx.ext.autodoc',
+        'sphinx.ext.napoleon', 'sphinx.ext.intersphinx']
+autodoc_member_order = 'groupwise'
+intersphinx_mapping = {
+        'numpy': ('https://docs.scipy.org/doc/numpy/', None),
+        }
 # Add any paths that contain templates here, relative to this directory.
 …
 # General information about the project.
 project = u'aubio'
 copyright = u'2016, Paul Brossier'
+copyright = u'2018, Paul Brossier'
 # The version info for the project you're documenting, acts as replacement for

doc/debian_packages.rst

r45c2c5c	r088760e
10	10	``git-buildpackage`` to build from the git repository. For instance:
11	11
12		.. code-block:: ~~bash~~
	12	.. code-block:: console
13	13
14	14	$ git clone git://anonscm.debian.org/collab-maint/aubio.git

doc/index.rst

r45c2c5c	r088760e
71	71	installing
72	72	python_module
	73	python
73	74	cli
74	75	develop

doc/installing.rst

-                      r45c2c5c
+                      r088760e
     sudo ./waf install
 - :ref:`install python-aubio from source <python>`::
+- :ref:`install python-aubio from source <python-install>`::
     # from git
 …
     pip install -v .
 - :ref:`install python-aubio from a pre-compiled binary <python>`::
+- :ref:`install python-aubio from a pre-compiled binary <python-install>`::
       # conda [osx, linux, win]

doc/python_module.rst

-                      r45c2c5c
+                      r088760e
 .. _python:
+.. _python-install:
+Python module
 =============
+Installing aubio for Python
+===========================
 The aubio extension for Python is available for Python 2.7 and Python 3.
 …
 aubio can now be installed using ``pip``:
 .. code-block:: bash
+.. code-block:: console
     $ pip install aubio
 …
 From ``aubio`` source directory, run the following:
 .. code-block:: bash
+.. code-block:: console
     $ ./setup.py clean
 …
     $ sudo ./setup.py install
-Using aubio in python
----------------------
+Once you have python-aubio installed, you should be able to run ``python -c
+"import aubio; print(aubio.version)"``.
+.. _py-doubleprecision:
+A simple example
+................
+Double precision
+----------------
+Here is a :download:`simple script <../python/demos/demo_source_simple.py>`
+that reads all the samples from a media file:
+This module can be compiled in double-precision mode, in which case the
+default type for floating-point samples will be 64-bit. The default is
+single precision mode (32-bit, recommended).
+.. literalinclude:: ../python/demos/demo_source_simple.py
+   :language: python
+To build the aubio module with double precision, use the option
+`--enable-double` of the `build_ext` subcommand:
+Filtering an input sound file
+.............................
+.. code:: bash
+Here is a more complete example, :download:`demo_filter.py
+<../python/demos/demo_filter.py>`. This files executes the following:
+    $ ./setup.py clean
+    $ ./setup.py build_ext --enable-double
+    $ pip install -v .
+* read an input media file (``aubio.source``)
+**Note**: If linking against `libaubio`, make sure the library was also
+compiled in :ref:`doubleprecision` mode.
-* filter it using an `A-weighting <https://en.wikipedia.org/wiki/A-weighting>`_
-  filter (``aubio.digital_filter``)
+* write result to a new file (``aubio.sink``)
+Checking your installation
+--------------------------
+.. literalinclude:: ../python/demos/demo_filter.py
+   :language: python
+Once the python module is installed, its version can be checked with:
+More demos
+..........
+.. code-block:: console
+Check out the `python demos folder`_ for more examples.
+    $ python -c "import aubio; print(aubio.version, aubio.float_type)"
+The command line `aubio` is also installed:
+.. code-block:: console
+    $ aubio -h
 Python tests
 …
 ``python/tests/run_all_tests``.
-.. _python demos folder: https://github.com/aubio/aubio/blob/master/python/demos
 .. _demo_filter.py: https://github.com/aubio/aubio/blob/master/python/demos/demo_filter.py
 .. _python tests: https://github.com/aubio/aubio/blob/master/python/tests

doc/requirements.rst

-                      r45c2c5c
+                      r088760e
     If ``pkg-config`` is not found in ``PATH``, the configure step will
     succeed, but none of the external libraries will be used.
+Media libraries
+---------------
 libav
 …
 configure with ``--disable-samplerate``
+Optimisation libraries
+----------------------
 libfftw3
 ........
 …
 then fail if the required library is not found. To disable this option,
 configure with ``--disable-fftw3``
+blas
+....
+On macOs/iOS, `blas
+<https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms>`_ are made
+available through the Accelerate framework.
+On Linux, they can be enabled with ``--enable-blas``.  On Debian (etch),
+`atlas`_, `openblas`_, and `libblas`_ have been successfully tested.
+When enabled, ``waf`` will check for the current blas configuration by running
+``pkg-config --libs blas``. Depending of the library path returned by
+``pkg-config``, different headers will be searched for.
+.. note::
+    On Debian systems, `multiple versions of BLAS and LAPACK
+    <https://wiki.debian.org/DebianScience/LinearAlgebraLibraries>`_ can be
+    installed. To configure which libblas is being used:
+    .. code-block:: console
+      $ sudo update-alternatives --config libblas.so
+..
+  Expected pkg-config output for each alternative:
+    /usr/lib/atlas-base/atlas/libblas.so
+    -L/usr/lib/atlas-base/atlas -lblas
+    /usr/lib/openblas-base/libblas.so
+    -L/usr/lib/openblas-base -lblas
+    /usr/lib/libblas/libblas.so
+    -lblas
+atlas
+.....
+`ATLAS BLAS APIs <http://math-atlas.sourceforge.net/>`_ will be used the path
+returned by ``pkg-config --libs blas`` contains ``atlas``.
+..
+  ``<atlas/cblas.h>`` will be included.
+Example:
+.. code-block:: console
+  $ pkg-config --libs blas
+  -L/usr/lib/atlas-base/atlas -lblas
+  $ ./waf configure --enable-atlas
+  [...]
+  Checking for 'blas'                      : yes
+  Checking for header atlas/cblas.h        : yes
+openblas
+........
+`OpenBlas libraries <https://www.openblas.net/>`_ will be used when the output
+of ``pkg-config --libs blas`` contains 'openblas',
+..
+  ``<openblas/cblas.h>`` will be included.
+Example:
+.. code-block:: console
+  $ pkg-config --libs blas
+  -L/usr/lib/openblas-base -lblas
+  $ ./waf configure --enable-atlas
+  [...]
+  Checking for 'blas'                      : yes
+  Checking for header openblas/cblas.h     : yes
+libblas
+.......
+`Netlib's libblas (LAPACK) <https://www.netlib.org/lapack/>`_ will be used if
+no specific library path is specified by ``pkg-config``
+..
+  ``<cblas.h>`` will be included.
+Example:
+.. code-block:: console
+  $ pkg-config --libs blas
+  -lblas
+  $ ./waf configure --enable-atlas
+  [...]
+  Checking for 'blas'                      : yes
+  Checking for header cblas.h              : yes
 Platform notes
 …
                 uninstall clean distclean dist distcheck
+.. _doubleprecision:
 Double precision
 ................
 …
 To compile aubio in double precision mode, configure with ``--enable-double``.
+To compile aubio in single precision mode, use ``--disable-double`` (default).
+To compile aubio in single precision mode, use ``--disable-double`` (default,
+recommended).
 Disabling the tests

examples/aubionotes.c

-                      r45c2c5c
+                      r088760e
 #define PROG_HAS_PITCH 1
 #define PROG_HAS_ONSET 1
+#define PROG_HAS_NOTES 1
 #define PROG_HAS_SILENCE 1
 #define PROG_HAS_JACK 1
 …
+    }
+  }
+  if (release_drop != 10.) {
+    if (aubio_notes_set_release_drop (notes, release_drop) != 0) {
+      errmsg ("failed setting notes release drop to %.2f\n",
+          release_drop);
+    }
+  }
   examples_common_process((aubio_process_func_t)process_block, process_print);

examples/parse_args.h

-                      r45c2c5c
+                      r088760e
 // more general stuff
 extern smpl_t silence_threshold;
+extern smpl_t release_drop;
 extern uint_t mix_input;
 // midi tap
 …
 extern int blocks;
 extern fvec_t *ibuf;
 extern fvec_t *obuf;
+extern fvec_t *input_buffer;
+extern fvec_t *output_buffer;
 const char *prog_name;
 …
 #ifdef PROG_HAS_PITCH
       "       -p      --pitch            select pitch detection algorithm\n"
       "                 <default|yinfft|yin|mcomb|fcomb|schmitt>; default=yinfft\n"
+      "                 <default|yinfft|yinfast|yin|mcomb|fcomb|schmitt>; default=yinfft\n"
       "       -u      --pitch-unit       select pitch output unit\n"
       "                 <default|freq|hertz|Hz|midi|cent|bin>; default=freq\n"
 …
       "                 a value in dB, for instance -70, or -100; default=-90\n"
 #endif /* PROG_HAS_SILENCE */
+#ifdef PROG_HAS_NOTES
+      "       -d      --release-drop     select release drop threshold\n"
+      "                 a positive value in dB; default=10\n"
+#endif
       "       -T      --time-format      select time values output format\n"
       "                 (samples, ms, seconds) default=seconds\n"
 …
     "s:"
 #endif /* PROG_HAS_SILENCE */
+#ifdef PROG_HAS_NOTES
+    "d:"
+#endif /* PROG_HAS_SILENCE */
 #ifdef PROG_HAS_OUTPUT
     "mf"
 …
     {"silence",               1, NULL, 's'},
 #endif /* PROG_HAS_SILENCE */
+#ifdef PROG_HAS_NOTES
+    {"release-drop",          1, NULL, 'd'},
+#endif /* PROG_HAS_NOTES */
     {"time-format",           1, NULL, 'T'},
 #ifdef PROG_HAS_OUTPUT
 …
   };
 #endif /* HAVE_GETOPT_H */
   prog_name = argv[0];
+  // better safe than sorry
   if (argc < 1) {
     usage (stderr, 1);
     return -1;
+  }
+  }
+  prog_name = argv[0];
 #ifdef HAVE_GETOPT_H
   do {
 …
       case 's':                /* silence threshold */
         silence_threshold = (smpl_t) atof (optarg);
+        break;
+      case 'd':                /* release-drop threshold */
+        release_drop = (smpl_t) atof (optarg);
         break;
       case 'm':                /* mix_input flag */

examples/utils.c

-                      r45c2c5c
+                      r088760e
 // more general stuff
 smpl_t silence_threshold = -90.;
+smpl_t release_drop = 10.;
 uint_t mix_input = 0;
 …
 aubio_source_t *this_source = NULL;
 aubio_sink_t *this_sink = NULL;
 fvec_t *ibuf;
 fvec_t *obuf;
+fvec_t *input_buffer;
+fvec_t *output_buffer;
 smpl_t miditap_note = 69.;
 …
 #if HAVE_JACK
+#define MAX_MIDI_EVENTS 128
+#define MAX_MIDI_EVENT_SIZE 3
 aubio_jack_t *jack_setup;
 jack_midi_event_t ev;
+jack_midi_data_t midi_data[MAX_MIDI_EVENTS * MAX_MIDI_EVENT_SIZE];
+size_t midi_event_count = 0;
 #endif /* HAVE_JACK */
 …
 #endif /* HAVE_JACK */
+  }
   ibuf = new_fvec (hop_size);
   obuf = new_fvec (hop_size);
+  input_buffer = new_fvec (hop_size);
+  output_buffer = new_fvec (hop_size);
+}
 …
 void examples_common_del (void)
+{
+#ifdef HAVE_JACK
+  if (ev.buffer) free(ev.buffer);
+#endif
+  del_fvec (ibuf);
+  del_fvec (obuf);
+  del_fvec (input_buffer);
+  del_fvec (output_buffer);
   aubio_cleanup ();
   fflush(stderr);
 …
 #ifdef HAVE_JACK
+    ev.size = 3;
+    ev.buffer = malloc (3 * sizeof (jack_midi_data_t));
+    ev.size = MAX_MIDI_EVENT_SIZE;
     ev.time = 0; // send it now
     debug ("Jack activation ...\n");
 …
     do {
       aubio_source_do (this_source, ibuf, &read);
       process_func (ibuf, obuf);
+      aubio_source_do (this_source, input_buffer, &read);
+      process_func (input_buffer, output_buffer);
       // print to console if verbose or no output given
       if (verbose || sink_uri == NULL) {
 …
+      }
       if (this_sink) {
         aubio_sink_do (this_sink, obuf, hop_size);
+        aubio_sink_do (this_sink, output_buffer, hop_size);
+      }
       blocks++;
 …
 #ifdef HAVE_JACK
   if (usejack) {
+    ev.buffer = midi_data + midi_event_count++ * MAX_MIDI_EVENT_SIZE;
+    if (midi_event_count >= MAX_MIDI_EVENTS) {
+      midi_event_count = 0;
+    }
     ev.buffer[2] = velo;
     ev.buffer[1] = pitch;

python/demos/demo_bpm_extract.py

-                      r45c2c5c
+                      r088760e
             pass
         else:
             print("unknown mode {:s}".format(params.mode))
+            raise ValueError("unknown mode {:s}".format(params.mode))
     # manual settings
     if 'samplerate' in params:
 …
     parser.add_argument('-m', '--mode',
             help="mode [default|fast|super-fast]",
             dest="mode")
+            dest="mode", default='default')
     parser.add_argument('sources',
             nargs='*',
+            nargs='+',
             help="input_files")
     args = parser.parse_args()

python/demos/demo_filter.py

-                      r45c2c5c
+                      r088760e
 #! /usr/bin/env python
+import sys
+import os.path
+import aubio
+def apply_filter(path):
+    from aubio import source, sink, digital_filter
+    from os.path import basename, splitext
+def apply_filter(path, target):
     # open input file, get its samplerate
     s = source(path)
+    s = aubio.source(path)
     samplerate = s.samplerate
     # create an A-weighting filter
     f = digital_filter(7)
+    f = aubio.digital_filter(7)
     f.set_a_weighting(samplerate)
-    # alternatively, apply another filter
     # create output file
     o = sink("filtered_" + splitext(basename(path))[0] + ".wav", samplerate)
+    o = aubio.sink(target, samplerate)
     total_frames = 0
     while True:
+        # read from source
         samples, read = s()
+        # filter samples
         filtered_samples = f(samples)
+        # write to sink
         o(filtered_samples, read)
+        # count frames read
         total_frames += read
+        # end of file reached
         if read < s.hop_size: break
+    # print some info
     duration = total_frames / float(samplerate)
+    print ("read {:s}".format(s.uri))
+    print ("applied A-weighting filtered ({:d} Hz)".format(samplerate))
+    print ("wrote {:s} ({:.2f} s)".format(o.uri, duration))
+    input_str = "input: {:s} ({:.2f} s, {:d} Hz)"
+    output_str = "output: {:s}, A-weighting filtered ({:d} frames total)"
+    print (input_str.format(s.uri, duration, samplerate))
+    print (output_str.format(o.uri, total_frames))
 if __name__ == '__main__':
+    import sys
+    for f in sys.argv[1:]:
+        apply_filter(f)
+    usage = "{:s} <input_file> [output_file]".format(sys.argv[0])
+    if not 1 < len(sys.argv) < 4:
+        print (usage)
+        sys.exit(1)
+    if len(sys.argv) < 3:
+        input_path = sys.argv[1]
+        basename = os.path.splitext(os.path.basename(input_path))[0] + ".wav"
+        output_path = "filtered_" + basename
+    else:
+        input_path, output_path = sys.argv[1:]
+    # run function
+    apply_filter(input_path, output_path)

python/demos/demo_source_simple.py

-                      r45c2c5c
+                      r088760e
 #! /usr/bin/env python
+import sys, aubio
+import sys
+import aubio
 samplerate = 0  # use original source samplerate
+samplerate = 0 # use original source samplerate
 hop_size = 256 # number of frames to read in one block
 s = aubio.source(sys.argv[1], samplerate, hop_size)
+src = aubio.source(sys.argv[1], samplerate, hop_size)
 total_frames = 0
 while True: # reading loop
     samples, read = s()
     total_frames += read
+while True:
+    samples, read = src()     # read hop_size new samples from source
+    total_frames += read      # increment total number of frames
     if read < hop_size: break # end of file reached
 fmt_string = "read {:d} frames at {:d}Hz from {:s}"
+print (fmt_string.format(total_frames, s.samplerate, sys.argv[1]))
+print (fmt_string.format(total_frames, src.samplerate, src.uri))

python/ext/aubiomodule.c

-                      r45c2c5c
+                      r088760e
 static char Py_alpha_norm_doc[] = ""
+"alpha_norm(fvec, integer) -> float\n"
+"\n"
+"Compute alpha normalisation factor on vector, given alpha\n"
+"alpha_norm(vec, alpha)\n"
+"\n"
+"Compute `alpha` normalisation factor of vector `vec`.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"vec : fvec\n"
+"   input vector\n"
+"alpha : float\n"
+"   norm factor\n"
+"\n"
+"Returns\n"
+"-------\n"
+"float\n"
+"   p-norm of the input vector, where `p=alpha`\n"
 "\n"
 "Example\n"
 "-------\n"
 "\n"
+">>> b = alpha_norm(a, 9)";
+">>> a = aubio.fvec(np.arange(10)); alpha = 2\n"
+">>> aubio.alpha_norm(a, alpha), (sum(a**alpha)/len(a))**(1./alpha)\n"
+"(5.338539123535156, 5.338539126015656)\n"
+"\n"
+"Note\n"
+"----\n"
+"Computed as:\n"
+"\n"
+".. math::\n"
+"  l_{\\alpha} = \n"
+"       \\|\\frac{\\sum_{n=0}^{N-1}{{x_n}^{\\alpha}}}{N}\\|^{1/\\alpha}\n"
+"";
 static char Py_bintomidi_doc[] = ""
+"bintomidi(float, samplerate = integer, fftsize = integer) -> float\n"
+"\n"
+"Convert bin (float) to midi (float), given the sampling rate and the FFT size\n"
+"bintomidi(fftbin, samplerate, fftsize)\n"
+"\n"
+"Convert FFT bin to frequency in midi note, given the sampling rate\n"
+"and the size of the FFT.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"fftbin : float\n"
+"   input frequency bin\n"
+"samplerate : float\n"
+"   sampling rate of the signal\n"
+"fftsize : float\n"
+"   size of the FFT\n"
+"\n"
+"Returns\n"
+"-------\n"
+"float\n"
+"   Frequency converted to midi note.\n"
 "\n"
 "Example\n"
 "-------\n"
 "\n"
+">>> midi = bintomidi(float, samplerate = 44100, fftsize = 1024)";
+">>> aubio.bintomidi(10, 44100, 1024)\n"
+"68.62871551513672\n"
+"";
 static char Py_miditobin_doc[] = ""
+"miditobin(float, samplerate = integer, fftsize = integer) -> float\n"
+"\n"
+"Convert midi (float) to bin (float), given the sampling rate and the FFT size\n"
+"miditobin(midi, samplerate, fftsize)\n"
+"\n"
+"Convert frequency in midi note to FFT bin, given the sampling rate\n"
+"and the size of the FFT.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"midi : float\n"
+"   input frequency, in midi note\n"
+"samplerate : float\n"
+"   sampling rate of the signal\n"
+"fftsize : float\n"
+"   size of the FFT\n"
+"\n"
+"Returns\n"
+"-------\n"
+"float\n"
+"   Frequency converted to FFT bin.\n"
+"\n"
+"Examples\n"
+"--------\n"
+"\n"
+">>> aubio.miditobin(69, 44100, 1024)\n"
+"10.216779708862305\n"
+">>> aubio.miditobin(75.08, 32000, 512)\n"
+"10.002175331115723\n"
+"";
+static char Py_bintofreq_doc[] = ""
+"bintofreq(fftbin, samplerate, fftsize)\n"
+"\n"
+"Convert FFT bin to frequency in Hz, given the sampling rate\n"
+"and the size of the FFT.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"fftbin : float\n"
+"   input frequency bin\n"
+"samplerate : float\n"
+"   sampling rate of the signal\n"
+"fftsize : float\n"
+"   size of the FFT\n"
+"\n"
+"Returns\n"
+"-------\n"
+"float\n"
+"   Frequency converted to Hz.\n"
 "\n"
 "Example\n"
 "-------\n"
 "\n"
+">>> bin = miditobin(midi, samplerate = 44100, fftsize = 1024)";
+static char Py_bintofreq_doc[] = ""
+"bintofreq(float, samplerate = integer, fftsize = integer) -> float\n"
+"\n"
+"Convert bin number (float) in frequency (Hz), given the sampling rate and the FFT size\n"
+">>> aubio.bintofreq(10, 44100, 1024)\n"
+"430.6640625\n"
+"";
+static char Py_freqtobin_doc[] = ""
+"freqtobin(freq, samplerate, fftsize)\n"
+"\n"
+"Convert frequency in Hz to FFT bin, given the sampling rate\n"
+"and the size of the FFT.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"midi : float\n"
+"   input frequency, in midi note\n"
+"samplerate : float\n"
+"   sampling rate of the signal\n"
+"fftsize : float\n"
+"   size of the FFT\n"
+"\n"
+"Returns\n"
+"-------\n"
+"float\n"
+"   Frequency converted to FFT bin.\n"
+"\n"
+"Examples\n"
+"--------\n"
+"\n"
+">>> aubio.freqtobin(440, 44100, 1024)\n"
+"10.216779708862305\n"
+"";
+static char Py_zero_crossing_rate_doc[] = ""
+"zero_crossing_rate(vec)\n"
+"\n"
+"Compute zero-crossing rate of `vec`.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"vec : fvec\n"
+"   input vector\n"
+"\n"
+"Returns\n"
+"-------\n"
+"float\n"
+"   Zero-crossing rate.\n"
 "\n"
 "Example\n"
 "-------\n"
 "\n"
+">>> freq = bintofreq(bin, samplerate = 44100, fftsize = 1024)";
+static char Py_freqtobin_doc[] = ""
+"freqtobin(float, samplerate = integer, fftsize = integer) -> float\n"
+"\n"
+"Convert frequency (Hz) in bin number (float), given the sampling rate and the FFT size\n"
+">>> a = np.linspace(-1., 1., 1000, dtype=aubio.float_type)\n"
+">>> aubio.zero_crossing_rate(a), 1/1000\n"
+"(0.0010000000474974513, 0.001)\n"
+"";
+static char Py_min_removal_doc[] = ""
+"min_removal(vec)\n"
+"\n"
+"Remove the minimum value of a vector to each of its element.\n"
+"\n"
+"Modifies the input vector in-place and returns a reference to it.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"vec : fvec\n"
+"   input vector\n"
+"\n"
+"Returns\n"
+"-------\n"
+"fvec\n"
+"   modified input vector\n"
 "\n"
 "Example\n"
 "-------\n"
 "\n"
+">>> bin = freqtobin(freq, samplerate = 44100, fftsize = 1024)";
+static char Py_zero_crossing_rate_doc[] = ""
+"zero_crossing_rate(fvec) -> float\n"
+"\n"
+"Compute Zero crossing rate of a vector\n"
+"\n"
+"Example\n"
+"-------\n"
+"\n"
+">>> z = zero_crossing_rate(a)";
+static char Py_min_removal_doc[] = ""
+"min_removal(fvec) -> float\n"
+"\n"
+"Remove the minimum value of a vector, in-place modification\n"
+"\n"
+"Example\n"
+"-------\n"
+"\n"
+">>> min_removal(a)";
+">>> aubio.min_removal(aubio.fvec(np.arange(1,4)))\n"
+"array([0., 1., 2.], dtype=" AUBIO_NPY_SMPL_STR ")\n"
+"";
 extern void add_ufuncs ( PyObject *m );
 …
   smpl_t output;
+  if (!PyArg_ParseTuple (args, "|" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR , &input, &samplerate, &fftsize)) {
+  if (!PyArg_ParseTuple (args,
+        "" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR,
+        &input, &samplerate, &fftsize)) {
     return NULL;
+  }
 …
   smpl_t output;
+  if (!PyArg_ParseTuple (args, "|" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR , &input, &samplerate, &fftsize)) {
+  if (!PyArg_ParseTuple (args,
+        "" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR,
+        &input, &samplerate, &fftsize)) {
     return NULL;
+  }
 …
   smpl_t output;
+  if (!PyArg_ParseTuple (args, "|" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR, &input, &samplerate, &fftsize)) {
+  if (!PyArg_ParseTuple (args,
+        "" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR,
+        &input, &samplerate, &fftsize)) {
     return NULL;
+  }
 …
   smpl_t output;
+  if (!PyArg_ParseTuple (args, "|" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR, &input, &samplerate, &fftsize)) {
+  if (!PyArg_ParseTuple (args,
+        "" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR,
+        &input, &samplerate, &fftsize)) {
     return NULL;
+  }

python/ext/py-cvec.c

-                      r45c2c5c
+                      r088760e
 } Py_cvec;
+static char Py_cvec_doc[] = "cvec object";
+static char Py_cvec_doc[] = ""
+"cvec(size)\n"
+"\n"
+"A container holding spectral data.\n"
+"\n"
+"Create one `cvec` to store the spectral information of a window\n"
+"of `size` points. The data will be stored  in two vectors,\n"
+":attr:`phas` and :attr:`norm`, each of shape (:attr:`length`,),\n"
+"with `length = size // 2 + 1`.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"size: int\n"
+"   Size of spectrum to create.\n"
+"\n"
+"Examples\n"
+"--------\n"
+">>> c = aubio.cvec(1024)\n"
+">>> c\n"
+"aubio cvec of 513 elements\n"
+">>> c.length\n"
+"513\n"
+">>> c.norm.dtype, c.phas.dtype\n"
+"(dtype('float32'), dtype('float32'))\n"
+">>> c.norm.shape, c.phas.shape\n"
+"((513,), (513,))\n"
+"\n"
+"See Also\n"
+"--------\n"
+"fvec, fft, pvoc\n"
+"";
 …
   // TODO remove READONLY flag and define getter/setter
   {"length", T_INT, offsetof (Py_cvec, length), READONLY,
       "length attribute"},
+      "int: Length of `norm` and `phas` vectors."},
   {NULL}                        /* Sentinel */
 };
 …
 static PyGetSetDef Py_cvec_getseters[] = {
   {"norm", (getter)Py_cvec_get_norm, (setter)Py_cvec_set_norm,
       "Numpy vector of shape (length,) containing the magnitude",
+  {"norm", (getter)Py_cvec_get_norm, (setter)Py_cvec_set_norm,
+      "numpy.ndarray: Vector of shape `(length,)` containing the magnitude.",
       NULL},
   {"phas", (getter)Py_cvec_get_phas, (setter)Py_cvec_set_phas,
       "Numpy vector of shape (length,) containing the phase",
+  {"phas", (getter)Py_cvec_get_phas, (setter)Py_cvec_set_phas,
+      "numpy.ndarray: Vector of shape `(length,)` containing the phase.",
       NULL},
   {NULL} /* sentinel */

python/ext/py-filterbank.c

-                      r45c2c5c
+                      r088760e
   if (self->vec.length != self->win_s / 2 + 1) {
     PyErr_Format(PyExc_ValueError,
                  "input cvec has length %d, but fft expects length %d",
+                 "input cvec has length %d, but filterbank expects length %d",
                  self->vec.length, self->win_s / 2 + 1);
     return NULL;
 …
   if (err > 0) {
     PyErr_SetString (PyExc_ValueError,
         "error when setting filter to A-weighting");
+        "error when running set_triangle_bands");
     return NULL;
+  }
 …
   if (err > 0) {
     PyErr_SetString (PyExc_ValueError,
         "error when setting filter to A-weighting");
+        "error when running set_mel_coeffs_slaney");
     return NULL;
+  }

python/ext/py-musicutils.h

-                      r45c2c5c
+                      r088760e
 static char Py_aubio_window_doc[] = ""
+"window(string, integer) -> fvec\n"
+"\n"
+"Create a window\n"
+"\n"
+"Example\n"
+"-------\n"
+"\n"
+">>> window('hanningz', 1024)\n"
+"window(window_type, size)\n"
+"\n"
+"Create a window of length `size`. `window_type` should be one\n"
+"of the following:\n"
+"\n"
+"- `default` (same as `hanningz`).\n"
+"- `ones`\n"
+"- `rectangle`\n"
+"- `hamming`\n"
+"- `hanning`\n"
+"- `hanningz` [1]_\n"
+"- `blackman`\n"
+"- `blackman_harris`\n"
+"- `gaussian`\n"
+"- `welch`\n"
+"- `parzen`\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"window_type : str\n"
+"   Type of window.\n"
+"size : int\n"
+"   Length of window.\n"
+"\n"
+"Returns\n"
+"-------\n"
+"fvec\n"
+"   Array of shape `(length,)` containing the new window.\n"
+"\n"
+"See Also\n"
+"--------\n"
+"pvoc, fft\n"
+"\n"
+"Examples\n"
+"--------\n"
+"Compute a zero-phase Hann window on `1024` points:\n"
+"\n"
+">>> aubio.window('hanningz', 1024)\n"
 "array([  0.00000000e+00,   9.41753387e-06,   3.76403332e-05, ...,\n"
+"         8.46982002e-05,   3.76403332e-05,   9.41753387e-06], dtype=float32)";
+"         8.46982002e-05,   3.76403332e-05,   9.41753387e-06], dtype=float32)\n"
+"\n"
+"Plot different window types with `matplotlib <https://matplotlib.org/>`_:\n"
+"\n"
+">>> import matplotlib.pyplot as plt\n"
+">>> modes = ['default', 'ones', 'rectangle', 'hamming', 'hanning',\n"
+"...          'hanningz', 'blackman', 'blackman_harris', 'gaussian',\n"
+"...          'welch', 'parzen']; n = 2048\n"
+">>> for m in modes: plt.plot(aubio.window(m, n), label=m)\n"
+"...\n"
+">>> plt.legend(); plt.show()\n"
+"\n"
+"Note\n"
+"----\n"
+"The following examples contain the equivalent source code to compute\n"
+"each type of window with `NumPy <https://numpy.org>`_:\n"
+"\n"
+">>> n = 1024; x = np.arange(n, dtype=aubio.float_type)\n"
+">>> ones = np.ones(n).astype(aubio.float_type)\n"
+">>> rectangle = 0.5 * ones\n"
+">>> hanning = 0.5 - 0.5 * np.cos(2 * np.pi * x / n)\n"
+">>> hanningz = 0.5 * (1 - np.cos(2 * np.pi * x / n))\n"
+">>> hamming = 0.54 - 0.46 * np.cos(2.*np.pi * x / (n - 1))\n"
+">>> blackman = 0.42 \\\n"
+"...          - 0.50 * np.cos(2 * np.pi * x / (n - 1)) \\\n"
+"...          + 0.08 * np.cos(4 * np.pi * x / (n - 1))\n"
+">>> blackman_harris = 0.35875 \\\n"
+"...       - 0.48829 * np.cos(2 * np.pi * x / (n - 1)) \\\n"
+"...       + 0.14128 * np.cos(4 * np.pi * x / (n - 1)) \\\n"
+"...       + 0.01168 * np.cos(6 * np.pi * x / (n - 1))\n"
+">>> gaussian = np.exp( - 0.5 * ((x - 0.5 * (n - 1)) \\\n"
+"...                            / (0.25 * (n - 1)) )**2 )\n"
+">>> welch = 1 - ((2 * x - n) / (n + 1))**2\n"
+">>> parzen = 1 - np.abs((2 * x - n) / (n + 1))\n"
+">>> default = hanningz\n"
+"References\n"
+"----------\n"
+#if 0
+"`Window function <https://en.wikipedia.org/wiki/Window_function>`_ on\n"
+"Wikipedia.\n"
+"\n"
+#endif
+".. [1] Amalia de Götzen, Nicolas Bernardini, and Daniel Arfib. Traditional\n"
+"   (?) implementations of a phase vocoder: the tricks of the trade.\n"
+"   In *Proceedings of the International Conference on Digital Audio\n"
+"   Effects* (DAFx-00), pages 37–44, University of Verona, Italy, 2000.\n"
+"   (`online version <"
+"https://www.cs.princeton.edu/courses/archive/spr09/cos325/Bernardini.pdf"
+">`_).\n"
+"";
 PyObject * Py_aubio_window(PyObject *self, PyObject *args);
 static char Py_aubio_level_lin_doc[] = ""
+"level_lin(fvec) -> fvec\n"
+"\n"
+"Compute sound level on a linear scale.\n"
+"\n"
+"This gives the average of the square amplitudes.\n"
+"\n"
+"Example\n"
+"-------\n"
+"\n"
+">>> level_Lin(numpy.ones(1024))\n"
+"1.0";
+"level_lin(x)\n"
+"\n"
+"Compute sound pressure level of `x`, on a linear scale.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"x : fvec\n"
+"   input vector\n"
+"\n"
+"Returns\n"
+"-------\n"
+"float\n"
+"   Linear level of `x`.\n"
+"\n"
+"Example\n"
+"-------\n"
+"\n"
+">>> aubio.level_lin(aubio.fvec(numpy.ones(1024)))\n"
+"1.0\n"
+"\n"
+"Note\n"
+"----\n"
+"Computed as the average of the squared amplitudes:\n"
+"\n"
+".. math:: L = \\frac {\\sum_{n=0}^{N-1} {x_n}^2} {N}\n"
+"\n"
+"See Also\n"
+"--------\n"
+"db_spl, silence_detection, level_detection\n"
+"";
 PyObject * Py_aubio_level_lin(PyObject *self, PyObject *args);
 static char Py_aubio_db_spl_doc[] = ""
+"Compute sound pressure level (SPL) in dB\n"
+"\n"
+"This quantity is often wrongly called 'loudness'.\n"
+"\n"
+"This gives ten times the log10 of the average of the square amplitudes.\n"
+"\n"
+"Example\n"
+"-------\n"
+"\n"
+">>> db_spl(numpy.ones(1024))\n"
+"1.0";
+"db_spl(x)\n"
+"\n"
+"Compute Sound Pressure Level (SPL) of `x`, in dB.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"x : fvec\n"
+"   input vector\n"
+"\n"
+"Returns\n"
+"-------\n"
+"float\n"
+"   Level of `x`, in dB SPL.\n"
+"\n"
+"Example\n"
+"-------\n"
+"\n"
+">>> aubio.db_spl(aubio.fvec(np.ones(1024)))\n"
+"1.0\n"
+">>> aubio.db_spl(0.7*aubio.fvec(np.ones(32)))\n"
+"-3.098040819168091\n"
+"\n"
+"Note\n"
+"----\n"
+"Computed as `log10` of :py:func:`level_lin`:\n"
+"\n"
+".. math::\n"
+"\n"
+"   {SPL}_{dB} = log10{\\frac {\\sum_{n=0}^{N-1}{x_n}^2} {N}}\n"
+"\n"
+"This quantity is often incorrectly called 'loudness'.\n"
+"\n"
+"See Also\n"
+"--------\n"
+"level_lin, silence_detection, level_detection\n"
+"";
 PyObject * Py_aubio_db_spl(PyObject *self, PyObject *args);
 static char Py_aubio_silence_detection_doc[] = ""
+"Check if buffer level in dB SPL is under a given threshold\n"
+"\n"
+"Return 0 if level is under the given threshold, 1 otherwise.\n"
+"\n"
+"Example\n"
+"-------\n"
+"\n"
+">>> import numpy\n"""
+">>> silence_detection(numpy.ones(1024, dtype=\"float32\"), -80)\n"
+"0";
+"silence_detection(vec, level)\n"
+"\n"
+"Check if level of `vec`, in dB SPL, is under a given threshold.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"vec : fvec\n"
+"   input vector\n"
+"level : float\n"
+"   level threshold, in dB SPL\n"
+"\n"
+"Returns\n"
+"-------\n"
+"int\n"
+"   `1` if level of `vec`, in dB SPL, is under `level`,\n"
+"   `0` otherwise.\n"
+"\n"
+"Examples\n"
+"--------\n"
+"\n"
+">>> aubio.silence_detection(aubio.fvec(32), -100.)\n"
+"1\n"
+">>> aubio.silence_detection(aubio.fvec(np.ones(32)), 0.)\n"
+"0\n"
+"\n"
+"See Also\n"
+"--------\n"
+"level_detection, db_spl, level_lin\n"
+"";
 PyObject * Py_aubio_silence_detection(PyObject *self, PyObject *args);
 static char Py_aubio_level_detection_doc[] = ""
+"Get buffer level in dB SPL if over a given threshold, 1. otherwise.\n"
+"\n"
+"Example\n"
+"-------\n"
+"\n"
+">>> import numpy\n"""
+">>> level_detection(0.7*numpy.ones(1024, dtype=\"float32\"), -80)\n"
+"0";
+"level_detection(vec, level)\n"
+"\n"
+"Check if `vec` is above threshold `level`, in dB SPL.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"vec : fvec\n"
+"   input vector\n"
+"level : float\n"
+"   level threshold, in dB SPL\n"
+"\n"
+"Returns\n"
+"-------\n"
+"float\n"
+"   `1.0` if level of `vec` in dB SPL is under `level`,\n"
+"   `db_spl(vec)` otherwise.\n"
+"\n"
+"Example\n"
+"-------\n"
+"\n"
+">>> aubio.level_detection(0.7*aubio.fvec(np.ones(1024)), -3.)\n"
+"1.0\n"
+">>> aubio.level_detection(0.7*aubio.fvec(np.ones(1024)), -4.)\n"
+"-3.0980708599090576\n"
+"\n"
+"See Also\n"
+"--------\n"
+"silence_detection, db_spl, level_lin\n"
+"";
 PyObject * Py_aubio_level_detection(PyObject *self, PyObject *args);
 static char Py_aubio_shift_doc[] = ""
+"Swap left and right partitions of a vector\n"
+"\n"
+"Returns the swapped vector. The input vector is also modified.\n"
+"shift(vec)\n"
+"\n"
+"Swap left and right partitions of a vector, in-place.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"vec : fvec\n"
+"   input vector to shift\n"
+"\n"
+"Returns\n"
+"-------\n"
+"fvec\n"
+"   The swapped vector.\n"
+"\n"
+"Notes\n"
+"-----\n"
+"The input vector is also modified.\n"
 "\n"
 "For a vector of length N, the partition is split at index N - N//2.\n"
 …
 "-------\n"
 "\n"
+">>> import numpy\n"
+">>> shift(numpy.arange(3, dtype=aubio.float_type))\n"
+"array([2., 0., 1.], dtype=" AUBIO_NPY_SMPL_STR ")";
+">>> aubio.shift(aubio.fvec(np.arange(3)))\n"
+"array([2., 0., 1.], dtype=" AUBIO_NPY_SMPL_STR ")\n"
+"\n"
+"See Also\n"
+"--------\n"
+"ishift\n"
+"";
 PyObject * Py_aubio_shift(PyObject *self, PyObject *args);
 static char Py_aubio_ishift_doc[] = ""
+"Swap right and left partitions of a vector\n"
+"\n"
+"Returns the swapped vector. The input vector is also modified.\n"
+"\n"
+"Unlike with shift(), the partition is split at index N//2.\n"
+"\n"
+"Example\n"
+"-------\n"
+"\n"
+">>> import numpy\n"
+">>> ishift(numpy.arange(3, dtype=aubio.float_type))\n"
+"array([1., 2., 0.], dtype=" AUBIO_NPY_SMPL_STR ")";
+"ishift(vec)\n"
+"\n"
+"Swap right and left partitions of a vector, in-place.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"vec : fvec\n"
+"   input vector to shift\n"
+"\n"
+"Returns\n"
+"-------\n"
+"fvec\n"
+"   The swapped vector.\n"
+"\n"
+"Notes\n"
+"-----\n"
+"The input vector is also modified.\n"
+"\n"
+"Unlike with :py:func:`shift`, the partition is split at index N//2.\n"
+"\n"
+"Example\n"
+"-------\n"
+"\n"
+">>> aubio.ishift(aubio.fvec(np.arange(3)))\n"
+"array([1., 2., 0.], dtype=" AUBIO_NPY_SMPL_STR ")\n"
+"\n"
+"See Also\n"
+"--------\n"
+"shift\n"
+"";
 PyObject * Py_aubio_ishift(PyObject *self, PyObject *args);

python/ext/py-phasevoc.c

-                      r45c2c5c
+                      r088760e
 #include "aubio-types.h"
+static char Py_pvoc_doc[] = "pvoc object";
+static char Py_pvoc_doc[] = ""
+"pvoc(win_s=512, hop_s=256)\n"
+"\n"
+"Phase vocoder.\n"
+"\n"
+"`pvoc` creates callable object implements a phase vocoder [1]_,\n"
+"using the tricks detailed in [2]_.\n"
+"\n"
+"The call function takes one input of type `fvec` and of size\n"
+"`hop_s`, and returns a `cvec` of length `win_s//2+1`.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"win_s : int\n"
+"  number of channels in the phase-vocoder.\n"
+"hop_s : int\n"
+"  number of samples expected between each call\n"
+"\n"
+"Examples\n"
+"--------\n"
+">>> x = aubio.fvec(256)\n"
+">>> pv = aubio.pvoc(512, 256)\n"
+">>> pv(x)\n"
+"aubio cvec of 257 elements\n"
+"\n"
+"Default values for hop_s and win_s are provided:\n"
+"\n"
+">>> pv = aubio.pvoc()\n"
+">>> pv.win_s, pv.hop_s\n"
+"512, 256\n"
+"\n"
+"A `cvec` can be resynthesised using `rdo()`:\n"
+"\n"
+">>> pv = aubio.pvoc(512, 256)\n"
+">>> y = aubio.cvec(512)\n"
+">>> x_reconstructed = pv.rdo(y)\n"
+">>> x_reconstructed.shape\n"
+"(256,)\n"
+"\n"
+"References\n"
+"----------\n"
+".. [1] James A. Moorer. The use of the phase vocoder in computer music\n"
+"   applications. `Journal of the Audio Engineering Society`,\n"
+"   26(1/2):42–45, 1978.\n"
+".. [2] Amalia de Götzen, Nicolas Bernardini, and Daniel Arfib. Traditional\n"
+"   (?) implementations of a phase vocoder: the tricks of the trade.\n"
+"   In `Proceedings of the International Conference on Digital Audio\n"
+"   Effects` (DAFx-00), pages 37–44, University of Verona, Italy, 2000.\n"
+"   (`online version <"
+"https://www.cs.princeton.edu/courses/archive/spr09/cos325/Bernardini.pdf"
+">`_).\n"
+"";
 typedef struct
 …
 static PyMemberDef Py_pvoc_members[] = {
   {"win_s", T_INT, offsetof (Py_pvoc, win_s), READONLY,
+    "size of the window"},
+    "int: Size of phase vocoder analysis windows, in samples.\n"
+    ""},
   {"hop_s", T_INT, offsetof (Py_pvoc, hop_s), READONLY,
+    "size of the hop"},
+    "int: Interval between two analysis, in samples.\n"
+    ""},
   { NULL } // sentinel
 };
 …
 static PyMethodDef Py_pvoc_methods[] = {
   {"rdo", (PyCFunction) Py_pvoc_rdo, METH_VARARGS,
+    "synthesis of spectral grain"},
+  {"set_window", (PyCFunction) Pyaubio_pvoc_set_window, METH_VARARGS, ""},
+    "rdo(fftgrain)\n"
+    "\n"
+    "Read a new spectral grain and resynthesise the next `hop_s`\n"
+    "output samples.\n"
+    "\n"
+    "Parameters\n"
+    "----------\n"
+    "fftgrain : cvec\n"
+    "    new input `cvec` to synthesize from, should be of size `win_s/2+1`\n"
+    "\n"
+    "Returns\n"
+    "-------\n"
+    "fvec\n"
+    "    re-synthesised output of shape `(hop_s,)`\n"
+    "\n"
+    "Example\n"
+    "-------\n"
+    ">>> pv = aubio.pvoc(2048, 512)\n"
+    ">>> out = pv.rdo(aubio.cvec(2048))\n"
+    ">>> out.shape\n"
+    "(512,)\n"
+    ""},
+  {"set_window", (PyCFunction) Pyaubio_pvoc_set_window, METH_VARARGS,
+    "set_window(window_type)\n"
+    "\n"
+    "Set window function\n"
+    "\n"
+    "Parameters\n"
+    "----------\n"
+    "window_type : str\n"
+    "    the window type to use for this phase vocoder\n"
+    "\n"
+    "Raises\n"
+    "------\n"
+    "ValueError\n"
+    "    If an unknown window type was given.\n"
+    "\n"
+    "See Also\n"
+    "--------\n"
+    "window : create a window.\n"
+    ""},
   {NULL}
 };

python/ext/py-sink.c

-                      r45c2c5c
+                      r088760e
 static char Py_sink_doc[] = ""
+"  __new__(path, samplerate = 44100, channels = 1)\n"
+"\n"
+"      Create a new sink, opening the given path for writing.\n"
+"\n"
+"      Examples\n"
+"      --------\n"
+"\n"
+"      Create a new sink at 44100Hz, mono:\n"
+"\n"
+"      >>> sink('/tmp/t.wav')\n"
+"\n"
+"      Create a new sink at 8000Hz, mono:\n"
+"\n"
+"      >>> sink('/tmp/t.wav', samplerate = 8000)\n"
+"\n"
+"      Create a new sink at 32000Hz, stereo:\n"
+"\n"
+"      >>> sink('/tmp/t.wav', samplerate = 32000, channels = 2)\n"
+"\n"
+"      Create a new sink at 32000Hz, 5 channels:\n"
+"\n"
+"      >>> sink('/tmp/t.wav', channels = 5, samplerate = 32000)\n"
+"\n"
+"  __call__(vec, write)\n"
+"      x(vec,write) <==> x.do(vec, write)\n"
+"\n"
+"      Write vector to sink.\n"
+"\n"
+"      See also\n"
+"      --------\n"
+"      aubio.sink.do\n"
+"sink(path, samplerate=44100, channels=1)\n"
+"\n"
+"Open `path` to write a WAV file.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"path : str\n"
+"   Pathname of the file to be opened for writing.\n"
+"samplerate : int\n"
+"   Sampling rate of the file, in Hz.\n"
+"channels : int\n"
+"   Number of channels to create the file with.\n"
+"\n"
+"Examples\n"
+"--------\n"
+"\n"
+"Create a new sink at 44100Hz, mono:\n"
+"\n"
+">>> snk = aubio.sink('out.wav')\n"
+"\n"
+"Create a new sink at 32000Hz, stereo, write 100 samples into it:\n"
+"\n"
+">>> snk = aubio.sink('out.wav', samplerate=16000, channels=3)\n"
+">>> snk(aubio.fvec(100), 100)\n"
+"\n"
+"Open a new sink at 48000Hz, stereo, write `1234` samples into it:\n"
+"\n"
+">>> with aubio.sink('out.wav', samplerate=48000, channels=2) as src:\n"
+"...     snk(aubio.fvec(1024), 1024)\n"
+"...     snk(aubio.fvec(210), 210)\n"
+"...\n"
+"\n"
+"See also\n"
+"--------\n"
+"source: read audio samples from a file.\n"
 "\n";
 static char Py_sink_do_doc[] = ""
+"x.do(vec, write) <==> x(vec, write)\n"
+"\n"
+"write monophonic vector to sink";
+"do(vec, write)\n"
+"\n"
+"Write a single channel vector to sink.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"vec : fvec\n"
+"   input vector `(n,)` where `n >= 0`.\n"
+"write : int\n"
+"   Number of samples to write.\n"
+"";
 static char Py_sink_do_multi_doc[] = ""
+"x.do_multi(mat, write)\n"
+"\n"
+"write polyphonic vector to sink";
+"do_multi(mat, write)\n"
+"\n"
+"Write a matrix containing vectors from multiple channels to sink.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"mat : numpy.ndarray\n"
+"   input matrix of shape `(channels, n)`, where `n >= 0`.\n"
+"write : int\n"
+"   Number of frames to write.\n"
+"";
 static char Py_sink_close_doc[] = ""
+"x.close()\n"
+"\n"
+"close this sink now";
+"close()\n"
+"\n"
+"Close this sink now.\n"
+"\n"
+"By default, the sink will be closed before being deleted.\n"
+"Explicitely closing a sink can be useful to control the number\n"
+"of files simultaneously opened.\n"
+"";
 static PyObject *
 …
 static PyMemberDef Py_sink_members[] = {
   {"uri", T_STRING, offsetof (Py_sink, uri), READONLY,
     "path at which the sink was created"},
+    "str (read-only): Path at which the sink was created."},
   {"samplerate", T_INT, offsetof (Py_sink, samplerate), READONLY,
     "samplerate at which the sink was created"},
+    "int (read-only): Samplerate at which the sink was created."},
   {"channels", T_INT, offsetof (Py_sink, channels), READONLY,
     "number of channels with which the sink was created"},
+    "int (read-only): Number of channels with which the sink was created."},
   { NULL } // sentinel
 };

python/ext/py-source.c

-                      r45c2c5c
+                      r088760e
 static char Py_source_doc[] = ""
+"   __new__(path, samplerate = 0, hop_size = 512, channels = 1)\n"
+"\n"
+"       Create a new source, opening the given path for reading.\n"
+"\n"
+"       Examples\n"
+"       --------\n"
+"\n"
+"       Create a new source, using the original samplerate, with hop_size = 512:\n"
+"\n"
+"       >>> source('/tmp/t.wav')\n"
+"\n"
+"       Create a new source, resampling the original to 8000Hz:\n"
+"\n"
+"       >>> source('/tmp/t.wav', samplerate = 8000)\n"
+"\n"
+"       Create a new source, resampling it at 32000Hz, hop_size = 32:\n"
+"\n"
+"       >>> source('/tmp/t.wav', samplerate = 32000, hop_size = 32)\n"
+"\n"
+"       Create a new source, using its original samplerate:\n"
+"\n"
+"       >>> source('/tmp/t.wav', samplerate = 0)\n"
+"\n"
+"   __call__()\n"
+"       vec, read = x() <==> vec, read = x.do()\n"
+"\n"
+"       Read vector from source.\n"
+"\n"
+"       See also\n"
+"       --------\n"
+"       aubio.source.do\n"
+"\n";
+"source(path, samplerate=0, hop_size=512, channels=0)\n"
+"\n"
+"Create a new source, opening the given pathname for reading.\n"
+"\n"
+"`source` open the file specified in `path` and creates a callable\n"
+"returning `hop_size` new audio samples at each invocation.\n"
+"\n"
+"If `samplerate=0` (default), the original sampling rate of `path`\n"
+"will be used. Otherwise, the output audio samples will be\n"
+"resampled at the desired sampling-rate.\n"
+"\n"
+"If `channels=0` (default), the original number of channels\n"
+"in `path` will be used. Otherwise, the output audio samples\n"
+"will be down-mixed or up-mixed to the desired number of\n"
+"channels.\n"
+"\n"
+"If `path` is a URL, a remote connection will be attempted to\n"
+"open the resource and stream data from it.\n"
+"\n"
+"The parameter `hop_size` determines how many samples should be\n"
+"read at each consecutive calls.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"path : str\n"
+"   pathname (or URL) of the file to be opened for reading\n"
+"samplerate : int, optional\n"
+"   sampling rate of the file\n"
+"hop_size : int, optional\n"
+"   number of samples to be read per iteration\n"
+"channels : int, optional\n"
+"   number of channels of the file\n"
+"\n"
+"Examples\n"
+"--------\n"
+"By default, when only `path` is given, the file will be opened\n"
+"with its original sampling rate and channel:\n"
+"\n"
+">>> src = aubio.source('stereo.wav')\n"
+">>> src.uri, src.samplerate, src.channels, src.duration\n"
+"('stereo.wav', 48000, 2, 86833)\n"
+"\n"
+"A typical loop to read all samples from a local file could\n"
+"look like this:\n"
+"\n"
+">>> src = aubio.source('stereo.wav')\n"
+">>> total_read = 0\n"
+">>> while True:\n"
+"...     samples, read = src()\n"
+"...     # do something with samples\n"
+"...     total_read += read\n"
+"...     if read < src.hop_size:\n"
+"...         break\n"
+"...\n"
+"\n"
+"In a more Pythonic way, it can also look like this:\n"
+"\n"
+">>> total_read = 0\n"
+">>> with aubio.source('stereo.wav') as src:\n"
+"...     for frames in src:\n"
+"...         total_read += samples.shape[-1]\n"
+"...\n"
+"\n"
+".. rubric:: Basic interface\n"
+"\n"
+"`source` is a **callable**; its :meth:`__call__` method\n"
+"returns a tuple containing:\n"
+"\n"
+"- a vector of shape `(hop_size,)`, filled with the `read` next\n"
+"  samples available, zero-padded if `read < hop_size`\n"
+"- `read`, an integer indicating the number of samples read\n"
+"\n"
+"To read the first `hop_size` samples from the source, simply call\n"
+"the instance itself, with no argument:\n"
+"\n"
+">>> src = aubio.source('song.ogg')\n"
+">>> samples, read = src()\n"
+">>> samples.shape, read, src.hop_size\n"
+"((512,), 512, 512)\n"
+"\n"
+"The first call returned the slice of samples `[0 : hop_size]`.\n"
+"The next call will return samples `[hop_size: 2*hop_size]`.\n"
+"\n"
+"After several invocations of :meth:`__call__`, when reaching the end\n"
+"of the opened stream, `read` might become less than `hop_size`:\n"
+"\n"
+">>> samples, read = src()\n"
+">>> samples.shape, read\n"
+"((512,), 354)\n"
+"\n"
+"The end of the vector `samples` is filled with zeros.\n"
+"\n"
+"After the end of the stream, `read` will be `0` since no more\n"
+"samples are available:\n"
+"\n"
+">>> samples, read = src()\n"
+">>> samples.shape, read\n"
+"((512,), 0)\n"
+"\n"
+"**Note**: when the source has more than one channels, they\n"
+"are be down-mixed to mono when invoking :meth:`__call__`.\n"
+"To read from each individual channel, see :meth:`__next__`.\n"
+"\n"
+".. rubric:: ``for`` statements\n"
+"\n"
+"The `source` objects are **iterables**. This allows using them\n"
+"directly in a ``for`` loop, which calls :meth:`__next__` until\n"
+"the end of the stream is reached:\n"
+"\n"
+">>> src = aubio.source('stereo.wav')\n"
+">>> for frames in src:\n"
+">>>     print (frames.shape)\n"
+"...\n"
+"(2, 512)\n"
+"(2, 512)\n"
+"(2, 230)\n"
+"\n"
+"**Note**: When `next(self)` is called on a source with multiple\n"
+"channels, an array of shape `(channels, read)` is returned,\n"
+"unlike with :meth:`__call__` which always returns the down-mixed\n"
+"channels.\n"
+"\n"
+"If the file is opened with a single channel, `next(self)` returns\n"
+"an array of shape `(read,)`:\n"
+"\n"
+">>> src = aubio.source('stereo.wav', channels=1)\n"
+">>> next(src).shape\n"
+"(512,)\n"
+"\n"
+".. rubric:: ``with`` statements\n"
+"\n"
+"The `source` objects are **context managers**, which allows using\n"
+"them in ``with`` statements:\n"
+"\n"
+">>> with aubio.source('audiotrack.wav') as source:\n"
+"...     n_frames=0\n"
+"...     for samples in source:\n"
+"...         n_frames += len(samples)\n"
+"...     print('read', n_frames, 'samples in', samples.shape[0], 'channels',\n"
+"...         'from file \"\%s\"' \% source.uri)\n"
+"...\n"
+"read 239334 samples in 2 channels from file \"audiotrack.wav\"\n"
+"\n"
+"The file will be closed before exiting the statement.\n"
+"\n"
+"See also the methods implementing the context manager,\n"
+":meth:`__enter__` and :meth:`__exit__`.\n"
+"\n"
+".. rubric:: Seeking and closing\n"
+"\n"
+"At any time, :meth:`seek` can be used to move to any position in\n"
+"the file. For instance, to rewind to the start of the stream:\n"
+"\n"
+">>> src.seek(0)\n"
+"\n"
+"The opened file will be automatically closed when the object falls\n"
+"out of scope and is scheduled for garbage collection.\n"
+"\n"
+"In some cases, it is useful to manually :meth:`close` a given source,\n"
+"for instance to limit the number of simultaneously opened files:\n"
+"\n"
+">>> src.close()\n"
+"\n"
+".. rubric:: Input formats\n"
+"\n"
+"Depending on how aubio was compiled, :class:`source` may or may not\n"
+"open certain **files format**. Below are some examples that assume\n"
+"support for compressed files and remote urls was compiled in:\n"
+"\n"
+"- open a local file using its original sampling rate and channels,\n"
+"  and with the default hop size:\n"
+"\n"
+">>> s = aubio.source('sample.wav')\n"
+">>> s.uri, s.samplerate, s.channels, s.hop_size\n"
+"('sample.wav', 44100, 2, 512)\n"
+"\n"
+"- open a local compressed audio file, resampling to 32000Hz if needed:\n"
+"\n"
+">>> s = aubio.source('song.mp3', samplerate=32000)\n"
+">>> s.uri, s.samplerate, s.channels, s.hop_size\n"
+"('song.mp3', 32000, 2, 512)\n"
+"\n"
+"- open a local video file, down-mixing and resampling it to 16kHz:\n"
+"\n"
+">>> s = aubio.source('movie.mp4', samplerate=16000, channels=1)\n"
+">>> s.uri, s.samplerate, s.channels, s.hop_size\n"
+"('movie.mp4', 16000, 1, 512)\n"
+"\n"
+"- open a remote resource, with hop_size = 1024:\n"
+"\n"
+">>> s = aubio.source('https://aubio.org/drum.ogg', hop_size=1024)\n"
+">>> s.uri, s.samplerate, s.channels, s.hop_size\n"
+"('https://aubio.org/drum.ogg', 48000, 2, 1024)\n"
+"\n"
+"See Also\n"
+"--------\n"
+"sink: write audio samples to a file.\n"
+"";
 static char Py_source_get_samplerate_doc[] = ""
+"x.get_samplerate() -> source samplerate\n"
+"\n"
+"Get samplerate of source.";
+"get_samplerate()\n"
+"\n"
+"Get sampling rate of source.\n"
+"\n"
+"Returns\n"
+"-------\n"
+"int\n"
+"    Sampling rate, in Hz.\n"
+"";
 static char Py_source_get_channels_doc[] = ""
+"x.get_channels() -> number of channels\n"
+"\n"
+"Get number of channels in source.";
+"get_channels()\n"
+"\n"
+"Get number of channels in source.\n"
+"\n"
+"Returns\n"
+"-------\n"
+"int\n"
+"    Number of channels.\n"
+"";
 static char Py_source_do_doc[] = ""
+"vec, read = x.do() <==> vec, read = x()\n"
+"\n"
+"Read monophonic vector from source.";
+"source.do()\n"
+"\n"
+"Read vector of audio samples.\n"
+"\n"
+"If the audio stream in the source has more than one channel,\n"
+"the channels will be down-mixed.\n"
+"\n"
+"Returns\n"
+"-------\n"
+"samples : numpy.ndarray, shape `(hop_size,)`, dtype aubio.float_type\n"
+"    `fvec` of size `hop_size` containing the new samples.\n"
+"read : int\n"
+"    Number of samples read from the source, equals to `hop_size`\n"
+"    before the end-of-file is reached, less when it is reached,\n"
+"    and `0` after.\n"
+"\n"
+"See Also\n"
+"--------\n"
+"do_multi\n"
+"\n"
+"Examples\n"
+"--------\n"
+">>> src = aubio.source('sample.wav', hop_size=1024)\n"
+">>> src.do()\n"
+"(array([-0.00123001, -0.00036685,  0.00097106, ..., -0.2031033 ,\n"
+"       -0.2025854 , -0.20221856], dtype=" AUBIO_NPY_SMPL_STR "), 1024)\n"
+"";
 static char Py_source_do_multi_doc[] = ""
+"mat, read = x.do_multi()\n"
+"\n"
+"Read polyphonic vector from source.";
+"do_multi()\n"
+"\n"
+"Read multiple channels of audio samples.\n"
+"\n"
+"If the source was opened with the same number of channels\n"
+"found in the stream, each channel will be read individually.\n"
+"\n"
+"If the source was opened with less channels than the number\n"
+"of channels in the stream, only the first channels will be read.\n"
+"\n"
+"If the source was opened with more channels than the number\n"
+"of channel in the original stream, the first channels will\n"
+"be duplicated on the additional output channel.\n"
+"\n"
+"Returns\n"
+"-------\n"
+"samples : np.ndarray([hop_size, channels], dtype=aubio.float_type)\n"
+"    NumPy array of shape `(hop_size, channels)` containing the new\n"
+"    audio samples.\n"
+"read : int\n"
+"    Number of samples read from the source, equals to `hop_size`\n"
+"    before the end-of-file is reached, less when it is reached,\n"
+"    and `0` after.\n"
+"\n"
+"See Also\n"
+"--------\n"
+"do\n"
+"\n"
+"Examples\n"
+"--------\n"
+">>> src = aubio.source('sample.wav')\n"
+">>> src.do_multi()\n"
+"(array([[ 0.00668335,  0.0067749 ,  0.00714111, ..., -0.05737305,\n"
+"        -0.05856323, -0.06018066],\n"
+"       [-0.00842285, -0.0072937 , -0.00576782, ..., -0.09405518,\n"
+"        -0.09558105, -0.09725952]], dtype=" AUBIO_NPY_SMPL_STR "), 512)\n"
+"";
 static char Py_source_close_doc[] = ""
+"x.close()\n"
+"\n"
+"Close this source now.";
+"close()\n"
+"\n"
+"Close this source now.\n"
+"\n"
+".. note:: Closing twice a source will **not** raise any exception.\n"
+"";
 static char Py_source_seek_doc[] = ""
+"x.seek(position)\n"
+"\n"
+"Seek to resampled frame position.";
+"seek(position)\n"
+"\n"
+"Seek to position in file.\n"
+"\n"
+"If the source was not opened with its original sampling-rate,\n"
+"`position` corresponds to the position in the re-sampled file.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"position : str\n"
+"   position to seek to, in samples\n"
+"";
 static PyObject *
 …
 static PyMemberDef Py_source_members[] = {
   {"uri", T_STRING, offsetof (Py_source, uri), READONLY,
     "path at which the source was created"},
+    "str (read-only): pathname or URL"},
   {"samplerate", T_INT, offsetof (Py_source, samplerate), READONLY,
     "samplerate at which the source is viewed"},
+    "int (read-only): sampling rate"},
   {"channels", T_INT, offsetof (Py_source, channels), READONLY,
     "number of channels found in the source"},
+    "int (read-only): number of channels"},
   {"hop_size", T_INT, offsetof (Py_source, hop_size), READONLY,
     "number of consecutive frames that will be read at each do or do_multi call"},
+    "int (read-only): number of samples read per iteration"},
   {"duration", T_INT, offsetof (Py_source, duration), READONLY,
+    "total number of frames in the source (estimated)"},
+    "int (read-only): total number of frames in the source\n"
+    "\n"
+    "Can be estimated, for instance if the opened stream is\n"
+    "a compressed media or a remote resource.\n"
+    "\n"
+    "Example\n"
+    "-------\n"
+    ">>> n = 0\n"
+    ">>> src = aubio.source('track1.mp3')\n"
+    ">>> for samples in src:\n"
+    "...     n += samples.shape[-1]\n"
+    "...\n"
+    ">>> n, src.duration\n"
+    "(9638784, 9616561)\n"
+    ""},
   { NULL } // sentinel
 };

python/ext/ufuncs.c

-                      r45c2c5c
+                      r088760e
 };
+static char Py_unwrap2pi_doc[] = "map angle to unit circle [-pi, pi[";
+// Note: these docstrings should *not* include the function signatures
+static char Py_unwrap2pi_doc[] = ""
+"\n"
+"Map angle to unit circle :math:`[-\\pi, \\pi[`.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"x : numpy.ndarray\n"
+"   input array\n"
+"\n"
+"Returns\n"
+"-------\n"
+"numpy.ndarray\n"
+"   values clamped to the unit circle :math:`[-\\pi, \\pi[`\n"
+"";
 static void* Py_unwrap2pi_data[] = {
 …
 };
+static char Py_freqtomidi_doc[] = "convert frequency to midi";
+static char Py_freqtomidi_doc[] = ""
+"\n"
+"Convert frequency `[0; 23000[` to midi `[0; 128[`.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"x : numpy.ndarray\n"
+"    Array of frequencies, in Hz.\n"
+"\n"
+"Returns\n"
+"-------\n"
+"numpy.ndarray\n"
+"    Converted frequencies, in midi note.\n"
+"";
 static void* Py_freqtomidi_data[] = {
 …
 };
+static char Py_miditofreq_doc[] = "convert midi to frequency";
+static char Py_miditofreq_doc[] = ""
+"\n"
+"Convert midi `[0; 128[` to frequency `[0, 23000]`.\n"
+"\n"
+"Parameters\n"
+"----------\n"
+"x : numpy.ndarray\n"
+"    Array of frequencies, in midi note.\n"
+"\n"
+"Returns\n"
+"-------\n"
+"numpy.ndarray\n"
+"    Converted frequencies, in Hz\n"
+"";
 static void* Py_miditofreq_data[] = {

python/lib/aubio/init.py

-                      r45c2c5c
+                      r088760e
 #! /usr/bin/env python
+# -*- coding: utf8 -*-
+"""
+aubio
+=====
+Provides a number of classes and functions for music and audio signal
+analysis.
+How to use the documentation
+----------------------------
+Documentation of the python module is available as docstrings provided
+within the code, and a reference guide available online from `the
+aubio homepage <https://aubio.org/documentation>`_.
+The docstrings examples are written assuming `aubio` and `numpy` have been
+imported with:
+>>> import aubio
+>>> import numpy as np
+"""
 import numpy
 …
 class fvec(numpy.ndarray):
+    """a numpy vector holding audio samples"""
+    """fvec(input_arg=1024)
+    A vector holding float samples.
+    def __new__(cls, input_arg=1024, **kwargs):
+    If `input_arg` is an `int`, a 1-dimensional vector of length `input_arg`
+    will be created and filled with zeros. Otherwise, if `input_arg` is an
+    `array_like` object, it will be converted to a 1-dimensional vector of
+    type :data:`float_type`.
+    Parameters
+    ----------
+    input_arg : `int` or `array_like`
+        Can be a positive integer, or any object that can be converted to
+        a numpy array with :func:`numpy.array`.
+    Examples
+    --------
+    >>> aubio.fvec(10)
+    array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)
+    >>> aubio.fvec([0,1,2])
+    array([0., 1., 2.], dtype=float32)
+    >>> a = np.arange(10); type(a), type(aubio.fvec(a))
+    (<class 'numpy.ndarray'>, <class 'numpy.ndarray'>)
+    >>> a.dtype, aubio.fvec(a).dtype
+    (dtype('int64'), dtype('float32'))
+    Notes
+    -----
+    In the Python world, `fvec` is simply a subclass of
+    :class:`numpy.ndarray`. In practice, any 1-dimensional `numpy.ndarray` of
+    `dtype` :data:`float_type` may be passed to methods accepting
+    `fvec` as parameter. For instance, `sink()` or `pvoc()`.
+    See Also
+    --------
+    cvec : a container holding spectral data
+    numpy.ndarray : parent class of :class:`fvec`
+    numpy.zeros : create a numpy array filled with zeros
+    numpy.array : create a numpy array from an existing object
+    """
+    def __new__(cls, input_arg=1024):
         if isinstance(input_arg, int):
             if input_arg == 0:
                 raise ValueError("vector length of 1 or more expected")
             return numpy.zeros(input_arg, dtype=float_type, **kwargs)
+            return numpy.zeros(input_arg, dtype=float_type, order='C')
         else:
+            return numpy.array(input_arg, dtype=float_type, **kwargs)
+            np_input = numpy.array(input_arg, dtype=float_type, order='C')
+            if len(np_input.shape) != 1:
+                raise ValueError("input_arg should have shape (n,)")
+            if np_input.shape[0] == 0:
+                raise ValueError("vector length of 1 or more expected")
+            return np_input

python/lib/aubio/cmd.py

-                      r45c2c5c
+                      r088760e
     subparser.add_input()
     subparser.add_buf_hop_size()
+    subparser.add_silence()
+    subparser.add_release_drop()
     subparser.add_time_format()
     subparser.add_verbose_help()
 …
 def parser_add_subcommand_cut(subparsers):
     # quiet subcommand
+    # cut subcommand
     subparser = subparsers.add_parser('cut',
             help='slice at timestamps')
 …
                 action="store", dest="silence", default=-70,
                 help="silence threshold")
+    def add_release_drop(self):
+        self.add_argument("-d", "--release-drop",
+                metavar = "<value>", type=float,
+                action="store", dest="release_drop", default=10,
+                help="release drop threshold")
     def add_minioi(self, default="12ms"):
 …
                 action = "store", dest = "cut_until_nslices", default = None,
                 help="how many extra slices should be added at the end of each slice")
+        self.add_argument("--create-first",
+                action = "store_true", dest = "create_first", default = False,
+                help="always include first slice")
 # some utilities
 …
         self.parse_options(args, self.valid_opts)
         self.notes = aubio.notes(**self.options)
+        if args.silence is not None:
+            self.notes.set_silence(args.silence)
+        if args.release_drop is not None:
+            self.notes.set_release_drop(args.release_drop)
         super(process_notes, self).__init__(args)
     def __call__(self, block):
 …
 def main():
     parser = aubio_parser()
+    args = parser.parse_args()
+    if sys.version_info[0] != 3:
+        # on py2, create a dummy ArgumentParser to workaround the
+        # optional subcommand issue. See https://bugs.python.org/issue9253
+        # This ensures that:
+        #  - version string is shown when only '-V' is passed
+        #  - help is printed if  '-V' is passed with any other argument
+        #  - any other argument get forwarded to the real parser
+        parser_root = argparse.ArgumentParser(add_help=False)
+        parser_root.add_argument('-V', '--version', help="show version",
+                action="store_true", dest="show_version")
+        args, extras = parser_root.parse_known_args()
+        if args.show_version == False: # no -V, forward to parser
+            args = parser.parse_args(extras, namespace=args)
+        elif len(extras) != 0: # -V with other arguments, print help
+            parser.print_help()
+            sys.exit(1)
+    else: # in py3, we can simply use parser directly
+        args = parser.parse_args()
     if 'show_version' in args and args.show_version:
         sys.stdout.write('aubio version ' + aubio.version + '\n')

python/lib/aubio/cut.py

-                      r45c2c5c
+                      r088760e
     s = source(source_uri, samplerate, hopsize)
     if samplerate == 0:
         samplerate = s.get_samplerate()
+        samplerate = s.samplerate
         options.samplerate = samplerate
 …
                 timestamps, timestamps_end = timestamps_end,
                 output_dir = options.output_directory,
+                samplerate = options.samplerate)
+                samplerate = options.samplerate,
+                create_first = options.create_first)
 def main():

python/lib/aubio/midiconv.py

-                      r45c2c5c
+                      r088760e
 """ utilities to convert midi note number to and from note names """
 __all__ = ['note2midi', 'midi2note', 'freq2note']
+__all__ = ['note2midi', 'midi2note', 'freq2note', 'note2freq']
 import sys
+from ._aubio import freqtomidi, miditofreq
 py3 = sys.version_info[0] == 3
 if py3:
 …
 def note2midi(note):
+    " convert note name to midi note number, e.g. [C-1, G9] -> [0, 127] "
+    """Convert note name to midi note number.
+    Input string `note` should be composed of one note root
+    and one octave, with optionally one modifier in between.
+    List of valid components:
+    - note roots: `C`, `D`, `E`, `F`, `G`, `A`, `B`,
+    - modifiers: `b`, `#`, as well as unicode characters
+      `𝄫`, `♭`, `♮`, `♯` and `𝄪`,
+    - octave numbers: `-1` -> `11`.
+    Parameters
+    ----------
+    note : str
+        note name
+    Returns
+    -------
+    int
+        corresponding midi note number
+    Examples
+    --------
+    >>> aubio.note2midi('C#4')
+    >>> aubio.note2midi('B♭5')
+    Raises
+    ------
+    TypeError
+        If `note` was not a string.
+    ValueError
+        If an error was found while converting `note`.
+    See Also
+    --------
+    midi2note, freqtomidi, miditofreq
+    """
     _valid_notenames = {'C': 0, 'D': 2, 'E': 4, 'F': 5, 'G': 7, 'A': 9, 'B': 11}
     _valid_modifiers = {
 …
     _valid_octaves = range(-1, 10)
     if not isinstance(note, str_instances):
+        raise TypeError("a string is required, got %s (%s)" % (note, str(type(note))))
+        msg = "a string is required, got {:s} ({:s})"
+        raise TypeError(msg.format(str(type(note)), repr(note)))
     if len(note) not in range(2, 5):
         raise ValueError("string of 2 to 4 characters expected, got %d (%s)" \
                          % (len(note), note))
+        msg = "string of 2 to 4 characters expected, got {:d} ({:s})"
+        raise ValueError(msg.format(len(note), note))
     notename, modifier, octave = [None]*3
 …
         raise ValueError("%s is not a valid octave" % octave)
+    midi = 12 + octave * 12 + _valid_notenames[notename] + _valid_modifiers[modifier]
+    midi = 12 + octave * 12 + _valid_notenames[notename] \
+            + _valid_modifiers[modifier]
     if midi > 127:
         raise ValueError("%s is outside of the range C-2 to G8" % note)
 …
 def midi2note(midi):
+    " convert midi note number to note name, e.g. [0, 127] -> [C-1, G9] "
+    """Convert midi note number to note name.
+    Parameters
+    ----------
+    midi : int [0, 128]
+        input midi note number
+    Returns
+    -------
+    str
+        note name
+    Examples
+    --------
+    >>> aubio.midi2note(70)
+    'A#4'
+    >>> aubio.midi2note(59)
+    'B3'
+    Raises
+    ------
+    TypeError
+        If `midi` was not an integer.
+    ValueError
+        If `midi` is out of the range `[0, 128]`.
+    See Also
+    --------
+    note2midi, miditofreq, freqtomidi
+    """
     if not isinstance(midi, int_instances):
         raise TypeError("an integer is required, got %s" % midi)
     if midi not in range(0, 128):
+        raise ValueError("an integer between 0 and 127 is excepted, got %d" % midi)
+    _valid_notenames = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
+        msg = "an integer between 0 and 127 is excepted, got {:d}"
+        raise ValueError(msg.format(midi))
+    _valid_notenames = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#',
+            'A', 'A#', 'B']
     return _valid_notenames[midi % 12] + str(int(midi / 12) - 1)
 def freq2note(freq):
+    " convert frequency in Hz to nearest note name, e.g. [0, 22050.] -> [C-1, G9] "
+    from aubio import freqtomidi
+    return midi2note(int(freqtomidi(freq)))
+    """Convert frequency in Hz to nearest note name.
+    Parameters
+    ----------
+    freq : float [0, 23000[
+        input frequency, in Hz
+    Returns
+    -------
+    str
+        name of the nearest note
+    Example
+    -------
+    >>> aubio.freq2note(440)
+    'A4'
+    >>> aubio.freq2note(220.1)
+    'A3'
+    """
+    nearest_note = int(freqtomidi(freq) + .5)
+    return midi2note(nearest_note)
+def note2freq(note):
+    """Convert note name to corresponding frequency, in Hz.
+    Parameters
+    ----------
+    note : str
+        input note name
+    Returns
+    -------
+    freq : float [0, 23000[
+        frequency, in Hz
+    Example
+    -------
+    >>> aubio.note2freq('A4')
+    >>> aubio.note2freq('A3')
+.1
+    """
+    midi = note2midi(note)
+    return miditofreq(midi)

python/lib/aubio/slicing.py

-                      r45c2c5c
+                      r088760e
 def slice_source_at_stamps(source_file, timestamps, timestamps_end=None,
+                           output_dir=None, samplerate=0, hopsize=256):
+    """ slice a sound file at given timestamps """
+                           output_dir=None, samplerate=0, hopsize=256,
+                           create_first=False):
+    """Slice a sound file at given timestamps.
+    This function reads `source_file` and creates slices, new smaller
+    files each starting at `t` in `timestamps`, a list of integer
+    corresponding to time locations in `source_file`, in samples.
+    If `timestamps_end` is unspecified, the slices will end at
+    `timestamps_end[n] = timestamps[n+1]-1`, or the end of file.
+    Otherwise, `timestamps_end` should be a list with the same length
+    as `timestamps` containing the locations of the end of each slice.
+    If `output_dir` is unspecified, the new slices will be written in
+    the current directory. If `output_dir` is a string, new slices
+    will be written in `output_dir`, after creating the directory if
+    required.
+    The default `samplerate` is 0, meaning the original sampling rate
+    of `source_file` will be used. When using a sampling rate
+    different to the one of the original files, `timestamps` and
+    `timestamps_end` should be expressed in the re-sampled signal.
+    The `hopsize` parameter simply tells :class:`source` to use this
+    hopsize and does not change the output slices.
+    If `create_first` is True and `timestamps` does not start with `0`, the
+    first slice from `0` to `timestamps[0] - 1` will be automatically added.
+    Parameters
+    ----------
+    source_file : str
+        path of the resource to slice
+    timestamps : :obj:`list` of :obj:`int`
+        time stamps at which to slice, in samples
+    timestamps_end : :obj:`list` of :obj:`int` (optional)
+        time stamps at which to end the slices
+    output_dir : str (optional)
+        output directory to write the slices to
+    samplerate : int (optional)
+        samplerate to read the file at
+    hopsize : int (optional)
+        number of samples read from source per iteration
+    create_first : bool (optional)
+        always create the slice at the start of the file
+    Examples
+    --------
+    Create two slices: the first slice starts at the beginning of the
+    input file `loop.wav` and lasts exactly one second, starting at
+    sample `0` and ending at sample `44099`; the second slice starts
+    at sample `44100` and lasts until the end of the input file:
+    >>> aubio.slice_source_at_stamps('loop.wav', [0, 44100])
+    Create one slice, from 1 second to 2 seconds:
+    >>> aubio.slice_source_at_stamps('loop.wav', [44100], [44100 * 2 - 1])
+    Notes
+    -----
+    Slices may be overlapping. If `timestamps_end` is `1` element
+    shorter than `timestamps`, the last slice will end at the end of
+    the file.
+    """
     if timestamps is None or len(timestamps) == 0:
         raise ValueError("no timestamps given")
     if timestamps[0] != 0:
+    if timestamps[0] != 0 and create_first:
         timestamps = [0] + timestamps
         if timestamps_end is not None:
 …
     if timestamps_end is not None:
+        if len(timestamps_end) != len(timestamps):
+        if len(timestamps_end) == len(timestamps) - 1:
+            timestamps_end = timestamps_end + [_max_timestamp]
+        elif len(timestamps_end) != len(timestamps):
             raise ValueError("len(timestamps_end) != len(timestamps)")
     else:
 …
         vec, read = _source.do_multi()
         # if the total number of frames read will exceed the next region start
         if len(regions) and total_frames + read >= regions[0][0]:
+        while len(regions) and total_frames + read >= regions[0][0]:
             #print "getting", regions[0], "at", total_frames
             # get next region
 …
                     # write remaining samples from current region
                     _sink.do_multi(vec[:, start:remaining], remaining - start)
                     #print "closing region", "remaining", remaining
+                    #print("closing region", "remaining", remaining)
                     # close this file
                     _sink.close()
 …
                 _sink.do_multi(vec[:, start:read], read - start)
         total_frames += read
+        # remove old slices
+        slices = list(filter(lambda s: s['end_stamp'] > total_frames,
+            slices))
         if read < hopsize:
             break

python/lib/gen_code.py

-                      r45c2c5c
+                      r088760e
   if (err > 0) {{
+    PyErr_SetString (PyExc_ValueError, "error running aubio_{shortname}_set_{param}");
+    if (PyErr_Occurred() == NULL) {{
+      PyErr_SetString (PyExc_ValueError, "error running aubio_{shortname}_set_{param}");
+    }} else {{
+      // change the RuntimeError into ValueError
+      PyObject *type, *value, *traceback;
+      PyErr_Fetch(&type, &value, &traceback);
+      PyErr_Restore(PyExc_ValueError, value, traceback);
+    }}
     return NULL;
   }}

python/lib/gen_external.py

-                      r45c2c5c
+                      r088760e
         cpp_cmd = os.environ.get('CC', 'cc').split()
         cpp_cmd += ['-E']
+    cpp_cmd += ['-x', 'c']  # force C language (emcc defaults to c++)
+    if 'emcc' in cpp_cmd:
+        cpp_cmd += ['-x', 'c'] # emcc defaults to c++, force C language
     return cpp_cmd
 …
     ''' return a dense and preprocessed  string of all c declarations implied by aubio.h
     '''
+    cpp_output = get_cpp_output(header=header, usedouble=usedouble)
+    return filter_cpp_output (cpp_output)
+def get_cpp_output(header=header, usedouble=False):
+    ''' find and run a C pre-processor on aubio.h '''
     cpp_cmd = get_preprocessor()
 …
     cpp_output = proc.stdout.read()
     err_output = proc.stderr.read()
+    if err_output:
+        print("Warning: preprocessor produced errors or warnings:\n%s" \
+                % err_output.decode('utf8'))
     if not cpp_output:
+        raise Exception("preprocessor output is empty:\n%s" % err_output)
+    elif err_output:
+        print("Warning: preprocessor produced warnings:\n%s" % err_output)
+        raise_msg = "preprocessor output is empty! Running command " \
+                + "\"%s\" failed" % " ".join(cpp_cmd)
+        if err_output:
+            raise_msg += " with stderr: \"%s\"" % err_output.decode('utf8')
+        else:
+            raise_msg += " with no stdout or stderr"
+        raise Exception(raise_msg)
     if not isinstance(cpp_output, list):
         cpp_output = [l.strip() for l in cpp_output.decode('utf8').split('\n')]
+    cpp_output = filter(lambda y: len(y) > 1, cpp_output)
+    return cpp_output
+def filter_cpp_output(cpp_raw_output):
+    ''' prepare cpp-output for parsing '''
+    cpp_output = filter(lambda y: len(y) > 1, cpp_raw_output)
     cpp_output = list(filter(lambda y: not y.startswith('#'), cpp_output))

python/tests/test_aubio_cmd.py

-                      r45c2c5c
+                      r088760e
     def test_samples2seconds(self):
+        self.assertEqual(aubio.cmd.samples2seconds(3200, 32000), "0.100000\t")
+        self.assertEqual(aubio.cmd.samples2seconds(3200, 32000),
+                "0.100000\t")
     def test_samples2milliseconds(self):
+        self.assertEqual(aubio.cmd.samples2milliseconds(3200, 32000), "100.000000\t")
+        self.assertEqual(aubio.cmd.samples2milliseconds(3200, 32000),
+                "100.000000\t")
     def test_samples2samples(self):
+        self.assertEqual(aubio.cmd.samples2samples(3200, 32000), "3200\t")
+        self.assertEqual(aubio.cmd.samples2samples(3200, 32000),
+                "3200\t")
 if __name__ == '__main__':

python/tests/test_fvec.py

-                      r45c2c5c
+                      r088760e
         self.assertRaises(IndexError, a.__getitem__, 3)
         self.assertRaises(IndexError, a.__getitem__, 2)
+    def test_wrong_dimensions(self):
+        a = np.array([[[1, 2], [3, 4]]], dtype=float_type)
+        self.assertRaises(ValueError, fvec, a)
+    def test_wrong_size(self):
+        a = np.ndarray([0,], dtype=float_type)
+        self.assertRaises(ValueError, fvec, a)
 class aubio_wrong_fvec_input(TestCase):

python/tests/test_note2midi.py

-                      r45c2c5c
+                      r088760e
 from __future__ import unicode_literals
 from aubio import note2midi, freq2note
+from aubio import note2midi, freq2note, note2freq, float_type
 from nose2.tools import params
 import unittest
 …
 class freq2note_simple_test(unittest.TestCase):
     def test_freq2note(self):
+    def test_freq2note_above(self):
         " make sure freq2note(441) == A4 "
         self.assertEqual("A4", freq2note(441))
+    def test_freq2note_under(self):
+        " make sure freq2note(439) == A4 "
+        self.assertEqual("A4", freq2note(439))
+class note2freq_simple_test(unittest.TestCase):
+    def test_note2freq(self):
+        " make sure note2freq('A3') == 220"
+        self.assertEqual(220, note2freq("A3"))
+    def test_note2freq_under(self):
+        " make sure note2freq(A4) == 440"
+        if float_type == 'float32':
+            self.assertEqual(440, note2freq("A4"))
+        else:
+            self.assertLess(abs(note2freq("A4")-440), 1.e-12)
 if __name__ == '__main__':

python/tests/test_notes.py

-                      r45c2c5c
+                      r088760e
 AUBIO_DEFAULT_NOTES_SILENCE = -70.
+AUBIO_DEFAULT_NOTES_RELEASE_DROP = 10.
 AUBIO_DEFAULT_NOTES_MINIOI_MS = 30.
 …
         self.o.set_silence(val)
         assert_equal (self.o.get_silence(), val)
+    def test_get_release_drop(self):
+        assert_equal (self.o.get_release_drop(), AUBIO_DEFAULT_NOTES_RELEASE_DROP)
+    def test_set_release_drop(self):
+        val = 50
+        self.o.set_release_drop(val)
+        assert_equal (self.o.get_release_drop(), val)
+    def test_set_release_drop_wrong(self):
+        val = -10
+        with self.assertRaises(ValueError):
+            self.o.set_release_drop(val)
 from .utils import list_all_sounds

python/tests/test_slicing.py

-                      r45c2c5c
+                      r088760e
     def test_slice_start_only_no_zero(self):
         regions_start = [i*1000 for i in range(1, n_slices)]
+        slice_source_at_stamps(self.source_file, regions_start, output_dir = self.output_dir)
+        slice_source_at_stamps(self.source_file, regions_start,
+                output_dir = self.output_dir, create_first=True)
     def test_slice_start_beyond_end(self):
         regions_start = [i*1000 for i in range(1, n_slices)]
         regions_start += [count_samples_in_file(self.source_file) + 1000]
+        slice_source_at_stamps(self.source_file, regions_start, output_dir = self.output_dir)
+        slice_source_at_stamps(self.source_file, regions_start,
+                output_dir = self.output_dir, create_first=True)
     def test_slice_start_every_blocksize(self):
         hopsize = 200
         regions_start = [i*hopsize for i in range(1, n_slices)]
+        regions_start = [i*hopsize for i in range(0, n_slices)]
         slice_source_at_stamps(self.source_file, regions_start, output_dir = self.output_dir,
                 hopsize = 200)
+    def test_slice_start_every_half_blocksize(self):
+        hopsize = 200
+        regions_start = [i*hopsize//2 for i in range(0, n_slices)]
+        slice_source_at_stamps(self.source_file, regions_start,
+                output_dir = self.output_dir, hopsize = 200)
     def tearDown(self):
 …
             "number of samples written different from number of original samples")
+    def test_slice_start_and_ends_with_missing_end(self):
+        regions_start = [i*1000 for i in range(n_slices)]
+        regions_ends = [r-1 for r in regions_start[1:]]
+        slice_source_at_stamps(self.source_file, regions_start, regions_ends,
+                output_dir = self.output_dir)
+        written_samples = count_samples_in_directory(self.output_dir)
+        original_samples = count_samples_in_file(self.source_file)
+        total_files = count_files_in_directory(self.output_dir)
+        assert_equal(n_slices, total_files,
+            "number of slices created different from expected")
+        assert_equal(written_samples, original_samples,
+            "number of samples written different from number of original samples")
     def tearDown(self):
         shutil.rmtree(self.output_dir)
 …
         regions_end = None
         slice_source_at_stamps (self.source_file, regions_start, regions_end,
                 output_dir = self.output_dir)
+                output_dir = self.output_dir, create_first=True)
         total_files = count_files_in_directory(self.output_dir)
         assert_equal(n_slices, total_files,

scripts/get_waf.sh

-                      r45c2c5c
+                      r088760e
 set -e
 set -x
+#set -x
 WAFVERSION=2.0.11
 WAFTARBALL=waf-$WAFVERSION.tar.bz2
 WAFURL=https://waf.io/$WAFTARBALL
+WAFUPSTREAMKEY=https://gitlab.com/ita1024/waf/raw/master/utils/pubkey.asc
 WAFBUILDDIR=`mktemp -d`
 …
 trap cleanup SIGINT SIGTERM
+function download () {
+  ( [[ -n `which wget` ]] && wget -qO $1 $2 ) || ( [[ -n `which curl` ]] && curl -so $1 $2 )
+}
+function checkwaf () {
+  download $WAFTARBALL.asc $WAFURL.asc
+  if [[ -z `which gpg` ]]
+  then
+    echo "Warning: gpg not found, not verifying signature for $WAFTARBALL"
+  else
+    download - $WAFUPSTREAMKEY | gpg --import
+    gpg --verify $WAFTARBALL.asc || exit 1
+  fi
+}
+function fetchwaf () {
+  download $WAFTARBALL $WAFURL
+  checkwaf
+}
 function buildwaf () {
-  pushd $WAFBUILDDIR
-  ( which wget > /dev/null && wget -qO $WAFTARBALL $WAFURL ) || ( which curl > /dev/null && curl $WAFURL > $WAFTARBALL )
   tar xf $WAFTARBALL
   pushd waf-$WAFVERSION
   NOCLIMB=1 python waf-light --tools=c_emscripten $*
   popd
-  popd
-  cp -prv $WAFBUILDDIR/waf-$WAFVERSION/waf $PWD
-  chmod +x waf
+}
+pushd $WAFBUILDDIR
+fetchwaf
 buildwaf
+popd
+cp -prv $WAFBUILDDIR/waf-$WAFVERSION/waf $PWD
+chmod +x waf
 cleanup

src/aubio_priv.h

-                      r45c2c5c
+                      r088760e
 #endif
 #ifdef HAVE_ACCELERATE
+#if defined(HAVE_ACCELERATE)
 #define HAVE_ATLAS 1
+#define HAVE_BLAS 1
 #include <Accelerate/Accelerate.h>
 #elif defined(HAVE_ATLAS_CBLAS_H)
+#elif defined(HAVE_BLAS)
+#if defined(HAVE_ATLAS_CBLAS_H)
 #define HAVE_ATLAS 1
 #include <atlas/cblas.h>
+#else
+#undef HAVE_ATLAS
+#elif defined(HAVE_OPENBLAS_CBLAS_H)
+#include <openblas/cblas.h>
+#elif defined(HAVE_CBLAS_H)
+#include <cblas.h>
+#endif
 #endif
 …
 #endif /* HAVE_ACCELERATE */
+#if defined(HAVE_BLAS)
+#ifndef HAVE_AUBIO_DOUBLE
 #ifdef HAVE_ATLAS
-#ifndef HAVE_AUBIO_DOUBLE
 #define aubio_catlas_set      catlas_sset
+#endif /* HAVE_ATLAS */
 #define aubio_cblas_copy      cblas_scopy
 #define aubio_cblas_swap      cblas_sswap
 #define aubio_cblas_dot       cblas_sdot
 #else /* HAVE_AUBIO_DOUBLE */
+#ifdef HAVE_ATLAS
 #define aubio_catlas_set      catlas_dset
+#endif /* HAVE_ATLAS */
 #define aubio_cblas_copy      cblas_dcopy
 #define aubio_cblas_swap      cblas_dswap
 #define aubio_cblas_dot       cblas_ddot
 #endif /* HAVE_AUBIO_DOUBLE */
 #endif /* HAVE_ATLAS */
+#endif /* HAVE_BLAS */
 #if defined HAVE_INTEL_IPP
 …
 #if !defined(HAVE_MEMCPY_HACKS) && !defined(HAVE_ACCELERATE) && !defined(HAVE_ATLAS) && !defined(HAVE_INTEL_IPP)
 #define HAVE_NOOPT 1
-#else
-#undef HAVE_NOOPT
 #endif

src/fmat.c

-                      r45c2c5c
+                      r088760e
   assert(s->length == scale->length);
 #endif
 #if !defined(HAVE_ACCELERATE) && !defined(HAVE_ATLAS)
+#if !defined(HAVE_ACCELERATE) && !defined(HAVE_BLAS)
   uint_t j;
   fvec_zeros(output);
 …
+    }
+  }
 #elif defined(HAVE_ATLAS)
+#elif defined(HAVE_BLAS)
   for (k = 0; k < s->height; k++) {
     output->data[k] = aubio_cblas_dot( s->length, scale->data, 1, s->data[k], 1);

src/fvec.c

r45c2c5c	r088760e
135	135	#if defined(HAVE_INTEL_IPP)
136	136	aubio_ippsCopy(s->data, t->data, (int)s->length);
137		#elif defined(HAVE_ATLAS)
	137	#elif defined(HAVE_BLAS)
138	138	aubio_cblas_copy(s->length, s->data, 1, t->data, 1);
139	139	#elif defined(HAVE_ACCELERATE)

src/io/source_avcodec.c

-                      r45c2c5c
+                      r088760e
 // determine whether we use libavformat from ffmpeg or from libav
 #define FFMPEG_LIBAVFORMAT (LIBAVFORMAT_VERSION_MICRO > 99 )
 // max_analyze_duration2 was used from ffmpeg libavformat 55.43.100 through 57.2.100
+// max_analyze_duration2 was used from ffmpeg libavformat 55.43.100 -> 57.2.100
 #define FFMPEG_LIBAVFORMAT_MAX_DUR2 FFMPEG_LIBAVFORMAT && ( \
       (LIBAVFORMAT_VERSION_MAJOR == 55 && LIBAVFORMAT_VERSION_MINOR >= 43) \
 …
 };
+// hack to create or re-create the context the first time _do or _do_multi is called
+void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s, uint_t multi);
+void aubio_source_avcodec_readframe(aubio_source_avcodec_t *s, uint_t * read_samples);
+// create or re-create the context when _do or _do_multi is called
+void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s,
+    uint_t multi);
+// actually read a frame
+void aubio_source_avcodec_readframe(aubio_source_avcodec_t *s,
+    uint_t * read_samples);
 uint_t aubio_source_avcodec_has_network_url(aubio_source_avcodec_t *s);
 …
+aubio_source_avcodec_t * new_aubio_source_avcodec(const char_t * path, uint_t samplerate, uint_t hop_size) {
+aubio_source_avcodec_t * new_aubio_source_avcodec(const char_t * path,
+    uint_t samplerate, uint_t hop_size) {
   aubio_source_avcodec_t * s = AUBIO_NEW(aubio_source_avcodec_t);
   AVFormatContext *avFormatCtx = s->avFormatCtx;
 …
+  }
   if ((sint_t)samplerate < 0) {
+    AUBIO_ERR("source_avcodec: Can not open %s with samplerate %d\n", path, samplerate);
+    AUBIO_ERR("source_avcodec: Can not open %s with samplerate %d\n",
+        path, samplerate);
     goto beach;
+  }
   if ((sint_t)hop_size <= 0) {
+    AUBIO_ERR("source_avcodec: Can not open %s with hop_size %d\n", path, hop_size);
+    AUBIO_ERR("source_avcodec: Can not open %s with hop_size %d\n",
+        path, hop_size);
     goto beach;
+  }
 …
     char errorstr[256];
     av_strerror (err, errorstr, sizeof(errorstr));
     AUBIO_ERR("source_avcodec: Could not find stream information " "for %s (%s)\n", s->path,
         errorstr);
+    AUBIO_ERR("source_avcodec: Could not find stream information "
+        "for %s (%s)\n", s->path, errorstr);
     goto beach;
+  }
 …
   avCodecCtx = avcodec_alloc_context3(codec);
   if (!avCodecCtx) {
+    AUBIO_ERR("source_avcodec: Failed to allocate the %s codec context for path %s\n",
+        av_get_media_type_string(AVMEDIA_TYPE_AUDIO), s->path);
+    AUBIO_ERR("source_avcodec: Failed to allocate the %s codec context "
+        "for path %s\n", av_get_media_type_string(AVMEDIA_TYPE_AUDIO),
+        s->path);
     goto beach;
+  }
 …
   /* Copy codec parameters from input stream to output codec context */
   if ((err = avcodec_parameters_to_context(avCodecCtx, codecpar)) < 0) {
+    AUBIO_ERR("source_avcodec: Failed to copy %s codec parameters to decoder context for %s\n",
+       av_get_media_type_string(AVMEDIA_TYPE_AUDIO), s->path);
+    AUBIO_ERR("source_avcodec: Failed to copy %s codec parameters to "
+        "decoder context for %s\n",
+        av_get_media_type_string(AVMEDIA_TYPE_AUDIO), s->path);
     goto beach;
+  }
 …
     char errorstr[256];
     av_strerror (err, errorstr, sizeof(errorstr));
+    AUBIO_ERR("source_avcodec: Could not load codec for %s (%s)\n", s->path, errorstr);
+    AUBIO_ERR("source_avcodec: Could not load codec for %s (%s)\n", s->path,
+        errorstr);
     goto beach;
+  }
 …
   /* allocate output for avr */
+  s->output = (smpl_t *)av_malloc(AUBIO_AVCODEC_MAX_BUFFER_SIZE * sizeof(smpl_t));
+  s->output = (smpl_t *)av_malloc(AUBIO_AVCODEC_MAX_BUFFER_SIZE
+      * sizeof(smpl_t));
   s->read_samples = 0;
 …
+}
+void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s, uint_t multi) {
+void aubio_source_avcodec_reset_resampler(aubio_source_avcodec_t * s,
+    uint_t multi)
+{
   // create or reset resampler to/from mono/multi-channel
   if ( (multi != s->multi) || (s->avr == NULL) ) {
 …
 #endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */
     av_opt_set_int(avr, "in_channel_layout",  input_layout,           0);
     av_opt_set_int(avr, "out_channel_layout", output_layout,          0);
     av_opt_set_int(avr, "in_sample_rate",     s->input_samplerate,    0);
     av_opt_set_int(avr, "out_sample_rate",    s->samplerate,          0);
+    av_opt_set_int(avr, "in_channel_layout",  input_layout,              0);
+    av_opt_set_int(avr, "out_channel_layout", output_layout,             0);
+    av_opt_set_int(avr, "in_sample_rate",     s->input_samplerate,       0);
+    av_opt_set_int(avr, "out_sample_rate",    s->samplerate,             0);
     av_opt_set_int(avr, "in_sample_fmt",      s->avCodecCtx->sample_fmt, 0);
 #if HAVE_AUBIO_DOUBLE
     av_opt_set_int(avr, "out_sample_fmt",     AV_SAMPLE_FMT_DBL,      0);
 #else
     av_opt_set_int(avr, "out_sample_fmt",     AV_SAMPLE_FMT_FLT,      0);
+    av_opt_set_int(avr, "out_sample_fmt",     AV_SAMPLE_FMT_DBL,         0);
+#else
+    av_opt_set_int(avr, "out_sample_fmt",     AV_SAMPLE_FMT_FLT,         0);
 #endif
     // TODO: use planar?
 …
       char errorstr[256];
       av_strerror (err, errorstr, sizeof(errorstr));
       AUBIO_ERR("source_avcodec: Could not open resampling context for %s (%s)\n",
           s->path, errorstr);
+      AUBIO_ERR("source_avcodec: Could not open resampling context"
+         " for %s (%s)\n", s->path, errorstr);
       return;
+    }
 …
+}
+void aubio_source_avcodec_readframe(aubio_source_avcodec_t *s, uint_t * read_samples) {
+void aubio_source_avcodec_readframe(aubio_source_avcodec_t *s,
+    uint_t * read_samples)
+{
   AVFormatContext *avFormatCtx = s->avFormatCtx;
   AVCodecContext *avCodecCtx = s->avCodecCtx;
 …
       char errorstr[256];
       av_strerror (err, errorstr, sizeof(errorstr));
+      AUBIO_ERR("source_avcodec: could not read frame in %s (%s)\n", s->path, errorstr);
+      AUBIO_ERR("source_avcodec: could not read frame in %s (%s)\n",
+          s->path, errorstr);
       s->eof = 1;
       goto beach;
 …
   if (ret < 0) {
     if (ret == AVERROR(EAGAIN)) {
+      //AUBIO_WRN("source_avcodec: output is not available right now - user must try to send new input\n");
+      //AUBIO_WRN("source_avcodec: output is not available right now - "
+      //    "user must try to send new input\n");
       goto beach;
     } else if (ret == AVERROR_EOF) {
+      AUBIO_WRN("source_avcodec: the decoder has been fully flushed, and there will be no more output frames\n");
+      AUBIO_WRN("source_avcodec: the decoder has been fully flushed, "
+          "and there will be no more output frames\n");
     } else {
       AUBIO_ERR("source_avcodec: decoding errors on %s\n", s->path);
 …
 #endif
   if (got_frame == 0) {
+    AUBIO_WRN("source_avcodec: did not get a frame when reading %s\n", s->path);
+    AUBIO_WRN("source_avcodec: did not get a frame when reading %s\n",
+        s->path);
     goto beach;
+  }
 …
   if (avFrame->channels != (sint_t)s->input_channels) {
     AUBIO_WRN ("source_avcodec: trying to read from %d channel(s),"
+        "but configured for %d; is '%s' corrupt?\n", avFrame->channels,
+        s->input_channels, s->path);
+    goto beach;
+  }
+        "but configured for %d; is '%s' corrupt?\n",
+        avFrame->channels, s->input_channels, s->path);
+    goto beach;
+  }
+#else
+#warning "avutil < 53 is deprecated, crashes might occur on corrupt files"
 #endif
 …
 #endif /* HAVE_AVRESAMPLE || HAVE_SWRESAMPLE */
   if (out_samples <= 0) {
+    AUBIO_WRN("source_avcodec: no sample found while converting frame (%s)\n", s->path);
+    AUBIO_WRN("source_avcodec: no sample found while converting frame (%s)\n",
+        s->path);
     goto beach;
+  }
 …
+}
+void aubio_source_avcodec_do(aubio_source_avcodec_t * s, fvec_t * read_data, uint_t * read){
+void aubio_source_avcodec_do(aubio_source_avcodec_t * s, fvec_t * read_data,
+    uint_t * read) {
   uint_t i;
   uint_t end = 0;
 …
+}
+void aubio_source_avcodec_do_multi(aubio_source_avcodec_t * s, fmat_t * read_data, uint_t * read){
+void aubio_source_avcodec_do_multi(aubio_source_avcodec_t * s,
+    fmat_t * read_data, uint_t * read) {
   uint_t i,j;
   uint_t end = 0;
 …
 uint_t aubio_source_avcodec_seek (aubio_source_avcodec_t * s, uint_t pos) {
+  int64_t resampled_pos = (uint_t)ROUND(pos * (s->input_samplerate * 1. / s->samplerate));
+  int64_t resampled_pos =
+    (uint_t)ROUND(pos * (s->input_samplerate * 1. / s->samplerate));
   int64_t min_ts = MAX(resampled_pos - 2000, 0);
   int64_t max_ts = MIN(resampled_pos + 2000, INT64_MAX);
 …
     ret = AUBIO_OK;
   } else {
+    AUBIO_ERR("source_avcodec: failed seeking in %s (file not opened?)", s->path);
+    AUBIO_ERR("source_avcodec: failed seeking in %s (file not opened?)",
+        s->path);
     return ret;
+  }
 …
       min_ts, resampled_pos, max_ts, seek_flags);
   if (ret < 0) {
+    AUBIO_ERR("source_avcodec: failed seeking to %d in file %s", pos, s->path);
+    AUBIO_ERR("source_avcodec: failed seeking to %d in file %s",
+        pos, s->path);
+  }
   // reset read status

src/mathutils.c

-                      r45c2c5c
+                      r088760e
   // if length is odd, middle element is moved to the end
   if (2 * half < s->length) start ++;
 #ifndef HAVE_ATLAS
+#ifndef HAVE_BLAS
   for (j = 0; j < half; j++) {
     ELEM_SWAP (s->data[j], s->data[j + start]);
 …
   // if length is odd, middle element is moved to the beginning
   if (2 * half < s->length) start ++;
 #ifndef HAVE_ATLAS
+#ifndef HAVE_BLAS
   for (j = 0; j < half; j++) {
     ELEM_SWAP (s->data[j], s->data[j + start]);
 …
+{
   smpl_t energy = 0.;
 #ifndef HAVE_ATLAS
+#ifndef HAVE_BLAS
   uint_t j;
   for (j = 0; j < f->length; j++) {
 …
   /* log(freq/A-2)/log(2) */
   midi = freq / 6.875;
   midi = LOG (midi) / 0.69314718055995;
+  midi = LOG (midi) / 0.6931471805599453;
   midi *= 12;
   midi -= 3;
 …
   if (midi > 140.) return 0.; // avoid infs
   freq = (midi + 3.) / 12.;
   freq = EXP (freq * 0.69314718055995);
+  freq = EXP (freq * 0.6931471805599453);
   freq *= 6.875;
   return freq;

src/notes/notes.c

-                      r45c2c5c
+                      r088760e
 /*
   Copyright (C) 2014 Paul Brossier <piem@aubio.org>
+  Copyright (C) 2014-2018 Paul Brossier <piem@aubio.org>
   This file is part of aubio.
 …
 #define AUBIO_DEFAULT_NOTES_SILENCE -70.
+#define AUBIO_DEFAULT_NOTES_RELEASE_DROP 10.
 // increase to 10. for .1  cent precision
 //      or to 100. for .01 cent precision
 …
   uint_t isready;
+  smpl_t last_onset_level;
+  smpl_t release_drop_level;
 };
 …
   aubio_notes_set_minioi_ms (o, AUBIO_DEFAULT_NOTES_MINIOI_MS);
+  o->last_onset_level = AUBIO_DEFAULT_NOTES_SILENCE;
+  o->release_drop_level = AUBIO_DEFAULT_NOTES_RELEASE_DROP;
   return o;
 …
+{
   return aubio_onset_get_minioi_ms(o->onset);
+}
+uint_t aubio_notes_set_release_drop(aubio_notes_t *o, smpl_t release_drop_level)
+{
+  uint_t err = AUBIO_OK;
+  if (release_drop_level <= 0.) {
+    AUBIO_ERR("notes: release_drop should be >= 0, got %f\n", release_drop_level);
+    err = AUBIO_FAIL;
+  } else {
+    o->release_drop_level = release_drop_level;
+  }
+  return err;
+}
+smpl_t aubio_notes_get_release_drop(const aubio_notes_t *o)
+{
+  return o->release_drop_level;
+}
 …
       //notes->data[0] = o->curnote;
       //notes->data[1] = 0.;
+      //AUBIO_WRN("notes: sending note-off at onset, not enough level\n");
       notes->data[2] = o->curnote;
     } else {
 …
         /* kill old note */
         //send_noteon(o->curnote,0, o->samplerate);
+        //AUBIO_WRN("notes: sending note-off at onset, new onset detected\n");
         notes->data[2] = o->curnote;
         /* get and send new one */
 …
         o->curnote = new_pitch;
+      }
+      o->last_onset_level = curlevel;
+    }
   } else {
+    if (o->median) {
+    if (curlevel < o->last_onset_level - o->release_drop_level)
+    {
+      // send note off
+      //AUBIO_WRN("notes: sending note-off, release detected\n");
+      notes->data[0] = 0;
+      notes->data[1] = 0;
+      notes->data[2] = o->curnote;
+      // reset last_onset_level to silence_threshold
+      o->last_onset_level = o->silence_threshold;
+      o->curnote = 0;
+    }
+    else if (o->median)
+    {
       if (o->isready > 0)
         o->isready++;
 …
         /* kill old note */
         //send_noteon(curnote,0);
+        notes->data[2] = o->curnote;
+        if (o->curnote != 0)
+        {
+          //AUBIO_WRN("notes: sending note-off, new note detected\n");
+          notes->data[2] = o->curnote;
+        }
         o->newnote = aubio_notes_get_latest_note(o);
         o->curnote = o->newnote;

src/notes/notes.h

-                      r45c2c5c
+                      r088760e
 uint_t aubio_notes_set_minioi_ms (aubio_notes_t *o, smpl_t minioi_ms);
+/** get notes object release drop level, in dB
+  \param o notes detection object as returned by new_aubio_notes()
+  \return current release drop level, in dB
+ */
+smpl_t aubio_notes_get_release_drop (const aubio_notes_t *o);
+/** set note release drop level, in dB
+  This function sets the release_drop_level parameter, in dB. When a new note
+  is found, the current level in dB is measured. If the measured level drops
+  under that initial level - release_drop_level, then a note-off will be
+  emitted.
+  Defaults to `10`, in dB.
+  \note This parameter was added in version `0.4.8`. Results obtained with
+  earlier versions can be reproduced by setting this value to `100`, so that
+  note-off will not be played until the next note.
+  \param o notes detection object as returned by new_aubio_notes()
+  \param release_drop new release drop level, in dB
+  \return 0 on success, non-zero otherwise
+*/
+uint_t aubio_notes_set_release_drop (aubio_notes_t *o, smpl_t release_drop);
 #ifdef __cplusplus
+}

src/spectral/filterbank_mel.h

-                      r45c2c5c
+                      r088760e
   The filter coefficients are built according to Malcolm Slaney's Auditory
+  Toolbox, available at http://engineering.purdue.edu/~malcolm/interval/1998-010/
+  (see file mfcc.m).
+  Toolbox, available online at the following address (see file mfcc.m):
+  https://engineering.purdue.edu/~malcolm/interval/1998-010/
 */

src/spectral/mfcc.c

-                      r45c2c5c
+                      r088760e
 #include "spectral/mfcc.h"
+#undef HAVE_SLOW_DCT
+#ifdef HAVE_NOOPT
+#define HAVE_SLOW_DCT 1
+#endif
 /** Internal structure for mfcc object */

src/spectral/mfcc.h

-                      r45c2c5c
+                      r088760e
   The implementation follows the specifications established by Malcolm Slaney
+  in its Auditory Toolbox, available online (see file mfcc.m).
+  in its Auditory Toolbox, available online at the following address (see
+  file mfcc.m):
   http://engineering.ecn.purdue.edu/~malcolm/interval/1998-010/
+  https://engineering.purdue.edu/~malcolm/interval/1998-010/
   \example spectral/test-mfcc.c

src/spectral/phasevoc.c

-                      r45c2c5c
+                      r088760e
     synthold[i] += synth[i + pv->hop_s] * pv->scale;
+}
+uint_t aubio_pvoc_get_win(aubio_pvoc_t* pv)
+{
+  return pv->win_s;
+}
+uint_t aubio_pvoc_get_hop(aubio_pvoc_t* pv)
+{
+  return pv->hop_s;
+}

src/spectral/phasevoc.h

r45c2c5c	r088760e
89	89	*/
90	90	uint_t aubio_pvoc_get_win(aubio_pvoc_t* pv);
	91
91	92	/** get hop size
92	93

src/synth/wavetable.c

r45c2c5c	r088760e
165	165	aubio_wavetable_set_amp (s, 0.);
166	166	//s->last_pos = 0;
167		return aubio_wavetable_set_playing (s, 1);
	167	return aubio_wavetable_set_playing (s, 0);
168	168	}
169	169

src/synth/wavetable.h

-                      r45c2c5c
+                      r088760e
 */
 aubio_wavetable_t * new_aubio_wavetable(uint_t samplerate, uint_t hop_size);
-/** load source in wavetable
-  \param o wavetable, created by new_aubio_wavetable()
-  \param uri the uri of the source to load
-  \return 0 if successful, non-zero otherwise
-*/
-uint_t aubio_wavetable_load( aubio_wavetable_t * o, const char_t * uri );
 /** process wavetable function

wscript

-                      r45c2c5c
+                      r088760e
             help_str = 'use CoreFoundation (darwin only) (auto)',
             help_disable_str = 'do not use CoreFoundation framework')
+    add_option_enable_disable(ctx, 'blas', default = False,
+            help_str = 'use BLAS acceleration library (no)',
+            help_disable_str = 'do not use BLAS library')
     add_option_enable_disable(ctx, 'atlas', default = False,
             help_str = 'use Atlas library (no)',
             help_disable_str = 'do not use Atlas library')
+            help_str = 'use ATLAS acceleration library (no)',
+            help_disable_str = 'do not use ATLAS library')
     add_option_enable_disable(ctx, 'wavread', default = True,
             help_str = 'compile with source_wavread (default)',
 …
             help_str = 'build documentation (auto)',
             help_disable_str = 'do not build documentation')
+    add_option_enable_disable(ctx, 'tests', default = True,
+            help_str = 'build tests (true)',
+            help_disable_str = 'do not build or run tests')
+    add_option_enable_disable(ctx, 'examples', default = True,
+            help_str = 'build examples (true)',
+            help_disable_str = 'do not build examples')
     ctx.add_option('--with-target-platform', type='string',
 …
         ctx.env.LINKFLAGS_cshlib += ['-s', 'EXPORTED_FUNCTIONS=%s' % c_mangled_names]
-    if (ctx.options.enable_atlas != True):
-        ctx.options.enable_atlas = False
     # check support for C99 __VA_ARGS__ macros
     check_c99_varargs = '''
 …
     ctx.msg('Checking if using sink_wavwrite', ctx.options.enable_wavwrite and 'yes' or 'no')
+    # use ATLAS
+    if (ctx.options.enable_atlas != False):
+        ctx.check(header_name = 'atlas/cblas.h', mandatory = ctx.options.enable_atlas)
+        #ctx.check(lib = 'lapack', uselib_store = 'LAPACK', mandatory = ctx.options.enable_atlas)
+        ctx.check(lib = 'cblas', uselib_store = 'BLAS', mandatory = ctx.options.enable_atlas)
+    # use BLAS/ATLAS
+    if (ctx.options.enable_blas != False):
+        ctx.check_cfg(package = 'blas',
+                args = '--cflags --libs',
+                uselib_store='BLAS', mandatory = ctx.options.enable_blas)
+        if 'LIB_BLAS' in ctx.env:
+            blas_header = None
+            if ctx.env['LIBPATH_BLAS']:
+                if 'atlas' in ctx.env['LIBPATH_BLAS'][0]:
+                    blas_header = 'atlas/cblas.h'
+                elif 'openblas' in ctx.env['LIBPATH_BLAS'][0]:
+                    blas_header = 'openblas/cblas.h'
+            else:
+                blas_header = 'cblas.h'
+            ctx.check(header_name = blas_header, mandatory =
+                    ctx.options.enable_atlas)
     # use memcpy hacks
 …
         if bld.env['DEST_OS']=='emscripten' and not bld.options.testcmd:
             bld.options.testcmd = 'node %s'
+        bld.recurse('examples')
+        bld.recurse('tests')
+        if bld.options.enable_examples:
+            bld.recurse('examples')
+        if bld.options.enable_tests:
+            bld.recurse('tests')
     # pkg-config template
 …
     ctx.excl += ' **/.landscape.yml'
     ctx.excl += ' **/.appveyor.yml'
+    ctx.excl += ' **/circlei.yml'
+    ctx.excl += ' **/.circleci/*'
+    ctx.excl += ' **/azure-pipelines.yml'
+    ctx.excl += ' **/.coveragerc'

Context Navigation

Legend:

Download in other formats: