sigrid/aubio

.appveyor.yml+1−1

@@ -75,4 +75,4 @@ build_script: · 74 unmodified lines
75		75
76	test_script:	76	test_script:
77	- "python python\\demos\\demo_create_test_sounds.py"	77	- "python python\\demos\\demo_create_test_sounds.py"
78	- "nose2 --verbose"	78	- "pytest --verbose"

.circleci/config.yml+8−8

@@ -19,16 +19,16 @@ install-wheel: &install-wheel · 18 unmodified lines
19	command: \|	19	command: \|
20	pip install --user dist/aubio*.whl	20	pip install --user dist/aubio*.whl
21		21
22	test-nose2: &test-nose2	22	test-pytest: &test-pytest
23	name: Test python wheel	23	name: Test python wheel
24	command: \|	24	command: \|
25	make create_test_sounds	25	make create_test_sounds
26	PATH=/home/circleci/.local/bin:$PATH nose2 -v	26	PATH=/home/circleci/.local/bin:$PATH pytest -v
27		27
28	test-nose2-nosounds: &test-nose2-nosounds	28	test-pytest-nosounds: &test-pytest-nosounds
29	name: Test python wheel	29	name: Test python wheel
30	command: \|	30	command: \|
31	PATH=/home/circleci/.local/bin:$PATH nose2 -v	31	PATH=/home/circleci/.local/bin:$PATH pytest -v
32		32
33	uninstall-wheel: &uninstall-wheel	33	uninstall-wheel: &uninstall-wheel
34	name: Uninstall python wheel	34	name: Uninstall python wheel
@@ -47,7 +47,7 @@ jobs: · 12 unmodified lines
47	- run: *pip-install	47	- run: *pip-install
48	- run: *build-wheel	48	- run: *build-wheel
49	- run: *install-wheel	49	- run: *install-wheel
50	- run: *test-nose2	50	- run: *test-pytest
51	- run: *uninstall-wheel	51	- run: *uninstall-wheel
52	- store_artifacts:	52	- store_artifacts:
53	path: dist/	53	path: dist/
@@ -61,7 +61,7 @@ jobs: · 7 unmodified lines
61	- run: *pip-install	61	- run: *pip-install
62	- run: *build-wheel	62	- run: *build-wheel
63	- run: *install-wheel	63	- run: *install-wheel
64	- run: *test-nose2	64	- run: *test-pytest
65	- run: *uninstall-wheel	65	- run: *uninstall-wheel
66	- store_artifacts:	66	- store_artifacts:
67	path: dist/	67	path: dist/
@@ -75,7 +75,7 @@ jobs: · 7 unmodified lines
75	- run: *pip-install	75	- run: *pip-install
76	- run: *build-wheel	76	- run: *build-wheel
77	- run: *install-wheel	77	- run: *install-wheel
78	- run: *test-nose2	78	- run: *test-pytest
79	- run: *uninstall-wheel	79	- run: *uninstall-wheel
80	- store_artifacts:	80	- store_artifacts:
81	path: dist/	81	path: dist/
@@ -88,7 +88,7 @@ jobs: · 6 unmodified lines
88	- run: *pip-install	88	- run: *pip-install
89	- run: *build-wheel	89	- run: *build-wheel
90	- run: *install-wheel	90	- run: *install-wheel
91	- run: *test-nose2-nosounds	91	- run: *test-pytest-nosounds
92	- run: *uninstall-wheel	92	- run: *uninstall-wheel
93	- store_artifacts:	93	- store_artifacts:
94	path: dist/	94	path: dist/

.travis.yml+1−0

@@ -87,6 +87,7 @@ install: · 86 unmodified lines
87	- travis_retry make getwaf expandwaf deps_python	87	- travis_retry make getwaf expandwaf deps_python
88	- which pip	88	- which pip
89	- pip --version	89	- pip --version
		90	- pip install coverage
90		91
91	script:	92	script:
92	- make create_test_sounds	93	- make create_test_sounds

MANIFEST.in+1−3

@@ -6,16 +6,14 @@ include waf · 5 unmodified lines
6	recursive-include waflib *.py	6	recursive-include waflib *.py
7	include Makefile wscript */wscript_build	7	include Makefile wscript */wscript_build
8	include aubio.pc.in	8	include aubio.pc.in
9	include nose2.cfg
10	include requirements.txt	9	include requirements.txt
11	include src/.c src/.h	10	include src/.c src/.h
12	include src//.c src//.h	11	include src//.c src//.h
13	include examples/.c examples/.h	12	include examples/.c examples/.h
14	include tests/.h tests//.c tests///.c	13	recursive-include tests .h .c *.py
15	include python/ext/*.h	14	include python/ext/*.h
16	recursive-include python *.py	15	recursive-include python *.py
17	include python/README.md	16	include python/README.md
18	include python/tests/run_all_tests
19	include python/tests/eval_pitch	17	include python/tests/eval_pitch
20	include python/tests/*.expected	18	include python/tests/*.expected
21	include doc/.txt doc/.rst doc/*.cfg doc/Makefile doc/make.bat doc/conf.py	19	include doc/.txt doc/.rst doc/*.cfg doc/Makefile doc/make.bat doc/conf.py

Makefile+4−6

 DATAROOTDIR?=$(PREFIX)/share
 MANDIR?=$(DATAROOTDIR)/man
-# default nose2 command
+# default python test command
-NOSE2?=nose2 -N 4 --verbose
+PYTEST?=pytest --verbose
 SOX=sox
 test_python: export PYTHONPATH=$(PYDESTDIR)/$(LIBDIR)
 test_python: local_dylib
 	# run test with installed package
-	# ./python/tests/run_all_tests --verbose
+	$(PYTEST)
-	# run with nose2, multiple processes
-	$(NOSE2)
 clean_python:
 	./setup.py clean
 	# build and test python
 	pip install -v -e .
 	# run tests, with python coverage
-	coverage run `which nose2`
+	coverage run `which pytest`
 	# capture coverage again
 	lcov $(LCOVOPTS) --capture --no-external --directory . \
 		--output-file build/coverage_python.info

doc/python_module.rst+8−7

@@ -89,14 +89,15 @@ The command line `aubio` is also installed: · 88 unmodified lines
89	Python tests	89	Python tests
90	------------	90	------------
91		91
92	A number of Python tests are provided in the `python tests`_. To run them,	92	A number of Python tests are provided in the `python/tests`_ folder. To run
93	install `nose2`_ and run the script ``python/tests/run_all_tests``:	93	them, install `pytest`_ and run it from the aubio source directory:
94		94
95	.. code-block:: console	95	.. code-block:: console
96		96
97	$ pip install nose2	97	$ pip install pytest
98	$ ./python/tests/run_all_tests	98	$ git clone https://git.aubio.org/aubio/aubio
		99	$ cd aubio
		100	$ pytest
99		101
100	.. _demo_filter.py: https://github.com/aubio/aubio/blob/master/python/demos/demo_filter.py	102	.. _python/tests: https://github.com/aubio/aubio/blob/master/python/tests
101	.. _python tests: https://github.com/aubio/aubio/blob/master/python/tests	103	.. _pytest: https://pytest.org
102	.. _nose2: https://github.com/nose-devs/nose2

nose2.cfg+0−6

@@ -1,6 +0,0 @@
1	[unittest]
2	start-dir = python/tests/
3	plugins = nose2.plugins.mp
4
5	[multiprocess]
6	always-on = false

python/README.md+1−1

@@ -27,7 +27,7 @@ Links · 26 unmodified lines
27	Demos	27	Demos
28	-----	28	-----
29		29
30	Some examples are available in the [`python/demos`][demos_dir] folder. Each	30	Some examples are available in the [`python/demos` folder][demos_dir]. Each
31	script is a command line program which accepts one ore more argument.	31	script is a command line program which accepts one ore more argument.
32		32
33	Notes: installing additional modules is required to run some of the demos.	33	Notes: installing additional modules is required to run some of the demos.

python/ext/aubiomodule.c+2−2

@@ -223,7 +223,7 @@ Py_alpha_norm (PyObject * self, PyObject * args) · 222 unmodified lines
223	}	223	}
224		224
225	// compute the function	225	// compute the function
226	result = Py_BuildValue (AUBIO_NPY_SMPL_CHR, fvec_alpha_norm (&vec, alpha));	226	result = PyFloat_FromDouble(fvec_alpha_norm (&vec, alpha));
227	if (result == NULL) {	227	if (result == NULL) {
228	return NULL;	228	return NULL;
229	}	229	}
@@ -319,7 +319,7 @@ Py_zero_crossing_rate (PyObject * self, PyObject * args) · 89 unmodified lines
319	}	319	}
320		320
321	// compute the function	321	// compute the function
322	result = Py_BuildValue (AUBIO_NPY_SMPL_CHR, aubio_zero_crossing_rate (&vec));	322	result = PyFloat_FromDouble(aubio_zero_crossing_rate (&vec));
323	if (result == NULL) {	323	if (result == NULL) {
324	return NULL;	324	return NULL;
325	}	325	}

python/ext/py-cvec.c+1−1

@@ -136,7 +136,7 @@ Py_cvec_repr (Py_cvec * self, PyObject * unused) · 135 unmodified lines
136	goto fail;	136	goto fail;
137	}	137	}
138		138
139	args = Py_BuildValue ("I", self->length);	139	args = PyLong_FromLong(self->length);
140	if (args == NULL) {	140	if (args == NULL) {
141	goto fail;	141	goto fail;
142	}	142	}

python/ext/py-musicutils.c+10−10

@@ -39,7 +39,7 @@ Py_aubio_level_lin(PyObject self, PyObject args) · 38 unmodified lines
39	return NULL;	39	return NULL;
40	}	40	}
41		41
42	level_lin = Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_level_lin(&vec));	42	level_lin = PyFloat_FromDouble(aubio_level_lin(&vec));
43	if (level_lin == NULL) {	43	if (level_lin == NULL) {
44	PyErr_SetString (PyExc_ValueError, "failed computing level_lin");	44	PyErr_SetString (PyExc_ValueError, "failed computing level_lin");
45	return NULL;	45	return NULL;
@@ -67,7 +67,7 @@ Py_aubio_db_spl(PyObject self, PyObject args) · 21 unmodified lines
67	return NULL;	67	return NULL;
68	}	68	}
69		69
70	db_spl = Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_db_spl(&vec));	70	db_spl = PyFloat_FromDouble(aubio_db_spl(&vec));
71	if (db_spl == NULL) {	71	if (db_spl == NULL) {
72	PyErr_SetString (PyExc_ValueError, "failed computing db_spl");	72	PyErr_SetString (PyExc_ValueError, "failed computing db_spl");
73	return NULL;	73	return NULL;
@@ -96,7 +96,7 @@ Py_aubio_silence_detection(PyObject self, PyObject args) · 22 unmodified lines
96	return NULL;	96	return NULL;
97	}	97	}
98		98
99	silence_detection = Py_BuildValue("I", aubio_silence_detection(&vec, threshold));	99	silence_detection = PyLong_FromLong(aubio_silence_detection(&vec, threshold));
100	if (silence_detection == NULL) {	100	if (silence_detection == NULL) {
101	PyErr_SetString (PyExc_ValueError, "failed computing silence_detection");	101	PyErr_SetString (PyExc_ValueError, "failed computing silence_detection");
102	return NULL;	102	return NULL;
@@ -125,7 +125,7 @@ Py_aubio_level_detection(PyObject self, PyObject args) · 22 unmodified lines
125	return NULL;	125	return NULL;
126	}	126	}
127		127
128	level_detection = Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_level_detection(&vec, threshold));	128	level_detection = PyFloat_FromDouble(aubio_level_detection(&vec, threshold));
129	if (level_detection == NULL) {	129	if (level_detection == NULL) {
130	PyErr_SetString (PyExc_ValueError, "failed computing level_detection");	130	PyErr_SetString (PyExc_ValueError, "failed computing level_detection");
131	return NULL;	131	return NULL;
@@ -194,9 +194,9 @@ Py_aubio_hztomel(PyObject self, PyObject args, PyObject *kwds) · 62 unmodified lines
194	return NULL;	194	return NULL;
195	}	195	}
196	if (htk != NULL && PyObject_IsTrue(htk) == 1)	196	if (htk != NULL && PyObject_IsTrue(htk) == 1)
197	return Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_hztomel_htk(v));	197	return PyFloat_FromDouble(aubio_hztomel_htk(v));
198	else	198	else
199	return Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_hztomel(v));	199	return PyFloat_FromDouble(aubio_hztomel(v));
200	}	200	}
201		201
202	PyObject*	202	PyObject*
@@ -211,9 +211,9 @@ Py_aubio_meltohz(PyObject self, PyObject args, PyObject *kwds) · 8 unmodified lines
211	return NULL;	211	return NULL;
212	}	212	}
213	if (htk != NULL && PyObject_IsTrue(htk) == 1)	213	if (htk != NULL && PyObject_IsTrue(htk) == 1)
214	return Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_meltohz_htk(v));	214	return PyFloat_FromDouble(aubio_meltohz_htk(v));
215	else	215	else
216	return Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_meltohz(v));	216	return PyFloat_FromDouble(aubio_meltohz(v));
217	}	217	}
218		218
219	PyObject*	219	PyObject*
@@ -223,7 +223,7 @@ Py_aubio_hztomel_htk(PyObject self, PyObject args) · 3 unmodified lines
223	if (!PyArg_ParseTuple(args, AUBIO_NPY_SMPL_CHR, &v)) {	223	if (!PyArg_ParseTuple(args, AUBIO_NPY_SMPL_CHR, &v)) {
224	return NULL;	224	return NULL;
225	}	225	}
226	return Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_hztomel_htk(v));	226	return PyFloat_FromDouble(aubio_hztomel_htk(v));
227	}	227	}
228		228
229	PyObject*	229	PyObject*
@@ -233,5 +233,5 @@ Py_aubio_meltohz_htk(PyObject self, PyObject args) · 3 unmodified lines
233	if (!PyArg_ParseTuple(args, AUBIO_NPY_SMPL_CHR, &v)) {	233	if (!PyArg_ParseTuple(args, AUBIO_NPY_SMPL_CHR, &v)) {
234	return NULL;	234	return NULL;
235	}	235	}
236	return Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_meltohz_htk(v));	236	return PyFloat_FromDouble(aubio_meltohz_htk(v));
237	}	237	}

python/tests/__init__.py+0−1

@@ -1 +0,0 @@
1

python/tests/_tools.py+41−0

@@ -0,0 +1,41 @@
	1	"""
	2	This file imports test methods from different testing modules, in this
	3	order:
	4
	5	- try importing 'pytest'
	6	- if it fails, fallback to 'numpy.testing'
	7
	8	Nose2 support was removed because of lacking assertWarns on py2.7.
	9
	10	"""
	11
	12	import sys
	13
	14	_has_pytest = False
	15
	16	# check if we have pytest
	17	try:
	18	import pytest
	19	parametrize = pytest.mark.parametrize
	20	assert_raises = pytest.raises
	21	assert_warns = pytest.warns
	22	skipTest = pytest.skip
	23	_has_pytest = True
	24	def run_module_suite():
	25	import sys, pytest
	26	pytest.main(sys.argv)
	27	except:
	28	pass
	29
	30	# otherwise fallback on numpy.testing
	31	if not _has_pytest:
	32	from numpy.testing import dec, assert_raises, assert_warns
	33	from numpy.testing import SkipTest
	34	parametrize = dec.parametrize
	35	def skipTest(msg):
	36	raise SkipTest(msg)
	37	from numpy.testing import run_module_suite
	38
	39	# always use numpy's assert_equal
	40	import numpy
	41	assert_equal = numpy.testing.assert_equal

python/tests/run_all_tests+0−5

@@ -1,5 +0,0 @@
1	#! /usr/bin/env python
2
3	if __name__ == '__main__':
4	import nose2.main
5	nose2.discover()

python/tests/test_aubio.py+1−2

 #! /usr/bin/env python
-from unittest import main
 from numpy.testing import TestCase
 class aubiomodule_test_case(TestCase):
         self.assertEqual('0', aubio.version[0])
 if __name__ == '__main__':
+    from unittest import main
     main()

python/tests/test_aubio_cmd.py+2−2

 #! /usr/bin/env python
-import aubio.cmd
-from nose2 import main
 from numpy.testing import TestCase
+import aubio.cmd
 class aubio_cmd(TestCase):
                 "3200\t")
 if __name__ == '__main__':
+    from unittest import main
     main()

python/tests/test_aubio_cut.py+1−1

 #! /usr/bin/env python
 import aubio.cut
-from nose2 import main
 from numpy.testing import TestCase
 class aubio_cut(TestCase):
         assert self.a_parser.parse_args(['-v']).verbose
 if __name__ == '__main__':
+    from unittest import main
     main()

python/tests/test_cvec.py+1−1

 #! /usr/bin/env python
-from unittest import main
 import numpy as np
 from numpy.testing import TestCase, assert_equal
 from aubio import cvec, fvec, float_type
             a.norm = np.zeros((512//2+1, 2), dtype = float_type)
 if __name__ == '__main__':
+    from unittest import main
     main()

python/tests/test_dct.py+4−0

@@ -66,3 +66,7 @@ class aubio_dct(TestCase): · 65 unmodified lines
66	aubio.dct(size)	66	aubio.dct(size)
67	except AssertionError:	67	except AssertionError:
68	self.skipTest('creating aubio.dct with size %d did not fail' % size)	68	self.skipTest('creating aubio.dct with size %d did not fail' % size)
		69
		70	if __name__ == '__main__':
		71	from unittest import main
		72	main()

python/tests/test_fft.py+1−1

 #! /usr/bin/env python
-from unittest import main
 from numpy.testing import TestCase
 from numpy.testing import assert_equal, assert_almost_equal
 import numpy as np
             fft(win_s)
 if __name__ == '__main__':
+    from unittest import main
     main()

python/tests/test_filter.py+2−2

 #! /usr/bin/env python
-from unittest import main
 from numpy.testing import TestCase, assert_equal, assert_almost_equal
 from aubio import fvec, digital_filter
-from .utils import array_from_text_file
+from utils import array_from_text_file
 class aubio_filter_test_case(TestCase):
             digital_filter(-1)
 if __name__ == '__main__':
+    from unittest import main
     main()

python/tests/test_filterbank.py+3−3

@@ -4,7 +4,7 @@ import numpy as np · 3 unmodified lines
4	from numpy.testing import TestCase, assert_equal, assert_almost_equal	4	from numpy.testing import TestCase, assert_equal, assert_almost_equal
5		5
6	from aubio import cvec, filterbank, float_type	6	from aubio import cvec, filterbank, float_type
7	from .utils import array_from_text_file	7	from utils import array_from_text_file
8		8
9	class aubio_filterbank_test_case(TestCase):	9	class aubio_filterbank_test_case(TestCase):
10		10
@@ -87,5 +87,5 @@ class aubio_filterbank_wrong_values(TestCase): · 76 unmodified lines
87	f(cvec(256))	87	f(cvec(256))
88		88
89	if __name__ == '__main__':	89	if __name__ == '__main__':
90	import nose2	90	from unittest import main
91	nose2.main()	91	main()

python/tests/test_filterbank_mel.py+14−15

 import numpy as np
 from numpy.testing import TestCase, assert_equal, assert_almost_equal
+from _tools import assert_warns
 from aubio import fvec, cvec, filterbank, float_type
-import warnings
-warnings.filterwarnings('ignore', category=UserWarning, append=True)
 class aubio_filterbank_mel_test_case(TestCase):
     def test_slaney(self):
         samplerate = 22050
         freq_list = [0, samplerate//4, samplerate // 2 + 1]
         f = filterbank(len(freq_list)-2, 1024)
-        # TODO add assert_warns
+        with assert_warns(UserWarning):
-        f.set_triangle_bands(fvec(freq_list), samplerate)
+            f.set_triangle_bands(fvec(freq_list), samplerate)
     def test_triangle_freqs_with_not_enough_filters(self):
         """make sure set_triangle_bands warns when not enough filters"""
         samplerate = 22050
         freq_list = [0, 100, 1000, 4000, 8000, 10000]
         f = filterbank(len(freq_list)-3, 1024)
-        # TODO add assert_warns
+        with assert_warns(UserWarning):
-        f.set_triangle_bands(fvec(freq_list), samplerate)
+            f.set_triangle_bands(fvec(freq_list), samplerate)
     def test_triangle_freqs_with_too_many_filters(self):
         """make sure set_triangle_bands warns when too many filters"""
         samplerate = 22050
         freq_list = [0, 100, 1000, 4000, 8000, 10000]
         f = filterbank(len(freq_list)-1, 1024)
-        # TODO add assert_warns
+        with assert_warns(UserWarning):
-        f.set_triangle_bands(fvec(freq_list), samplerate)
+            f.set_triangle_bands(fvec(freq_list), samplerate)
     def test_triangle_freqs_with_double_value(self):
         """make sure set_triangle_bands works with 2 duplicate freqs"""
         samplerate = 22050
         freq_list = [0, 100, 1000, 4000, 4000, 4000, 10000]
         f = filterbank(len(freq_list)-2, 1024)
-        # TODO add assert_warns
+        with assert_warns(UserWarning):
-        f.set_triangle_bands(fvec(freq_list), samplerate)
+            f.set_triangle_bands(fvec(freq_list), samplerate)
     def test_triangle_freqs_with_triple(self):
         """make sure set_triangle_bands works with 3 duplicate freqs"""
         samplerate = 22050
         freq_list = [0, 100, 1000, 4000, 4000, 4000, 10000]
         f = filterbank(len(freq_list)-2, 1024)
-        # TODO add assert_warns
+        with assert_warns(UserWarning):
-        f.set_triangle_bands(fvec(freq_list), samplerate)
+            f.set_triangle_bands(fvec(freq_list), samplerate)
     def test_triangle_freqs_without_norm(self):
         """make sure set_triangle_bands works without """
 if __name__ == '__main__':
-    import nose2
+    from unittest import main
-    nose2.main()
+    main()

python/tests/test_fvec.py+1−1

 #! /usr/bin/env python
-from unittest import main
 import numpy as np
 from numpy.testing import TestCase, assert_equal, assert_almost_equal
 from aubio import fvec, zero_crossing_rate, alpha_norm, min_removal
         del c
 if __name__ == '__main__':
+    from unittest import main
     main()

python/tests/test_fvec_shift.py+1−1

@@ -30,6 +30,6 @@ class aubio_shift_test_case(TestCase): · 29 unmodified lines
30	def test_can_shift_fvec_odd(self):	30	def test_can_shift_fvec_odd(self):
31	self.run_shift_ishift(7)	31	self.run_shift_ishift(7)
32		32
33	from unittest import main
34	if __name__ == '__main__':	33	if __name__ == '__main__':
		34	from unittest import main
35	main()	35	main()

python/tests/test_hztomel.py+11−8

 from unittest import main
 from numpy.testing import TestCase
 from numpy.testing import assert_equal, assert_almost_equal
+from _tools import assert_warns
 import numpy as np
 import aubio
             assert_almost_equal(meltohz(hztomel(f)) - f, 0, decimal=1)
     def test_meltohz_negative(self):
-        # TODO add assert_warns
+        with assert_warns(UserWarning):
-        assert_equal(meltohz(-1), 0)
+            assert_equal(meltohz(-1), 0)
     def test_hztomel_negative(self):
-        # TODO add assert_warns
+        with assert_warns(UserWarning):
-        assert_equal(hztomel(-1), 0)
+            assert_equal(hztomel(-1), 0)
 class aubio_hztomel_htk_test_case(TestCase):
         assert_almost_equal(hztomel(6300, htk=True), 2595., decimal=1)
     def test_meltohz_negative(self):
-        # TODO add assert_warns
+        with assert_warns(UserWarning):
-        assert_equal(meltohz(-1, htk=True), 0)
+            assert_equal(meltohz(-1, htk=True), 0)
         assert_almost_equal(meltohz(2000, htk=True), 3428.7, decimal=1)
         assert_almost_equal(meltohz(1000, htk=True), 1000., decimal=1)
     def test_hztomel_negative(self):
-        # TODO add assert_warns
+        with assert_warns(UserWarning):
-        assert_equal(hztomel(-1, htk=True), 0)
+            assert_equal(meltohz(-1, htk=True), 0)
+        with assert_warns(UserWarning):
+            assert_equal(hztomel(-1, htk=True), 0)
         assert_almost_equal(hztomel(1000, htk=True), 1000., decimal=1)
     def test_hztomel_htk(self):

python/tests/test_mathutils.py+1−1

 #! /usr/bin/env python
-from unittest import main
 from numpy.testing import TestCase, assert_equal
 from numpy import array, arange, isnan, isinf
 from aubio import bintomidi, miditobin, freqtobin, bintofreq, freqtomidi, miditofreq
         assert_equal ( array(b) < 0, False )
 if __name__ == '__main__':
+    from unittest import main
     main()

python/tests/test_mfcc.py+17−21

 #! /usr/bin/env python
-from nose2 import main
+from _tools import parametrize, assert_raises
-from nose2.tools import params
 from numpy import random, count_nonzero
 from numpy.testing import TestCase
 from aubio import mfcc, cvec, float_type
 new_params = ['buf_size', 'n_filters', 'n_coeffs', 'samplerate']
 new_deflts = [1024, 40, 13, 44100]
-class aubio_mfcc(TestCase):
+class Test_aubio_mfcc(object):
-    def setUp(self):
+    members_args = 'name'
-        self.o = mfcc()
-    def test_default_creation(self):
+    @parametrize(members_args, new_params)
-        pass
-    def test_delete(self):
-        del self.o
-    @params(*new_params)
     def test_read_only_member(self, name):
-        o = self.o
+        o = mfcc()
-        with self.assertRaises((TypeError, AttributeError)):
+        with assert_raises((TypeError, AttributeError)):
             setattr(o, name, 0)
-    @params(*zip(new_params, new_deflts))
+    @parametrize('name, expected', zip(new_params, new_deflts))
     def test_default_param(self, name, expected):
         """ test mfcc.{:s} = {:d} """.format(name, expected)
-        o = self.o
+        o = mfcc()
-        self.assertEqual( getattr(o, name), expected)
+        assert getattr(o, name) == expected
 class aubio_mfcc_wrong_params(TestCase):
         #print coeffs
-class aubio_mfcc_all_parameters(TestCase):
+class Test_aubio_mfcc_all_parameters(object):
-    @params(
+    run_values = [
             (2048, 40, 13, 44100),
             (1024, 40, 13, 44100),
             (512, 40, 13, 44100),
             #(1024, 30, 20, 44100),
             (1024, 40, 40, 44100),
             (1024, 40, 3, 44100),
-            )
+            ]
+    run_args = ['buf_size', 'n_filters', 'n_coeffs', 'samplerate']
+    @parametrize(run_args, run_values)
     def test_run_with_params(self, buf_size, n_filters, n_coeffs, samplerate):
         " check mfcc can run with reasonable parameters "
         o = mfcc(buf_size, n_filters, n_coeffs, samplerate)
         assert m.get_scale() == 1
 if __name__ == '__main__':
-    main()
+    from _tools import run_module_suite
+    run_module_suite()

python/tests/test_midi2note.py+11−12

 # -*- coding: utf-8 -*-
 from aubio import midi2note
-from nose2.tools import params
+from _tools import parametrize, assert_raises
-import unittest
 list_of_known_midis = (
         ( 0, 'C-1' ),
         ( 127, 'G9' ),
         )
-class midi2note_good_values(unittest.TestCase):
+class Test_midi2note_good_values(object):
-    @params(*list_of_known_midis)
+    @parametrize('midi, note', list_of_known_midis)
     def test_midi2note_known_values(self, midi, note):
         " known values are correctly converted "
-        self.assertEqual ( midi2note(midi), note )
+        assert midi2note(midi) == (note)
-class midi2note_wrong_values(unittest.TestCase):
+class Test_midi2note_wrong_values(object):
     def test_midi2note_negative_value(self):
         " fails when passed a negative value "
-        self.assertRaises(ValueError, midi2note, -2)
+        assert_raises(ValueError, midi2note, -2)
     def test_midi2note_large(self):
         " fails when passed a value greater than 127 "
-        self.assertRaises(ValueError, midi2note, 128)
+        assert_raises(ValueError, midi2note, 128)
     def test_midi2note_floating_value(self):
         " fails when passed a floating point "
-        self.assertRaises(TypeError, midi2note, 69.2)
+        assert_raises(TypeError, midi2note, 69.2)
     def test_midi2note_character_value(self):
         " fails when passed a value that can not be transformed to integer "
-        self.assertRaises(TypeError, midi2note, "a")
+        assert_raises(TypeError, midi2note, "a")
 if __name__ == '__main__':
-    import nose2
+    from _tools import run_module_suite
-    nose2.main()
+    run_module_suite()

python/tests/test_musicutils.py+2−2

 #! /usr/bin/env python
-from unittest import main
 import numpy as np
 from numpy.testing import TestCase
-from numpy.testing.utils import assert_equal, assert_almost_equal
+from numpy.testing import assert_equal, assert_almost_equal
 from aubio import window, level_lin, db_spl, silence_detection, level_detection
 from aubio import fvec, float_type
         assert level_detection(ones(1024, dtype = float_type), -70) == 0
 if __name__ == '__main__':
+    from unittest import main
     main()

python/tests/test_note2midi.py+24−19

 from __future__ import unicode_literals
 from aubio import note2midi, freq2note, note2freq, float_type
-from nose2.tools import params
+from numpy.testing import TestCase
-import unittest
+from _tools import parametrize, assert_raises, skipTest
 list_of_known_notes = (
         ( 'C-1', 0 ),
         ( '2' ),
         )
-class note2midi_good_values(unittest.TestCase):
+class Test_note2midi_good_values(object):
-    @params(*list_of_known_notes)
+    @parametrize('note, midi', list_of_known_notes)
     def test_note2midi_known_values(self, note, midi):
         " known values are correctly converted "
-        self.assertEqual ( note2midi(note), midi )
+        assert note2midi(note) == midi
-    @params(*list_of_known_notes_with_unicode_issues)
+    @parametrize('note, midi', list_of_known_notes_with_unicode_issues)
     def test_note2midi_known_values_with_unicode_issues(self, note, midi):
-        " known values are correctly converted, unless decoding is expected to fail"
+        " difficult values are correctly converted unless expected failure "
         try:
-            self.assertEqual ( note2midi(note), midi )
+            assert note2midi(note) == midi
         except UnicodeEncodeError as e:
+            # platforms with decoding failures include:
+            # - osx: python <= 2.7.10
+            # - win: python <= 2.7.12
             import sys
-            strfmt = "len(u'\\U0001D12A') != 1, excpected decoding failure | {:s} | {:s} {:s}"
+            strmsg = "len(u'\\U0001D12A') != 1, expected decoding failure"
-            strres = strfmt.format(e, sys.platform, sys.version)
+            strmsg += " | upgrade to Python 3 to fix"
-            # happens with: darwin 2.7.10, windows 2.7.12
+            strmsg += " | {:s} | {:s} {:s}"
             if len('\U0001D12A') != 1 and sys.version[0] == '2':
-                self.skipTest(strres + " | upgrade to Python 3 to fix")
+                skipTest(strmsg.format(repr(e), sys.platform, sys.version))
             else:
                 raise
-class note2midi_wrong_values(unittest.TestCase):
+class note2midi_wrong_values(TestCase):
     def test_note2midi_missing_octave(self):
         " fails when passed only one character"
         " fails when passed a note with a note name longer than expected"
         self.assertRaises(ValueError, note2midi, 'CB+-3')
-    @params(*list_of_unknown_notes)
+class Test_note2midi_unknown_values(object):
+    @parametrize('note', list_of_unknown_notes)
     def test_note2midi_unknown_values(self, note):
         " unknown values throw out an error "
-        self.assertRaises(ValueError, note2midi, note)
+        assert_raises(ValueError, note2midi, note)
-class freq2note_simple_test(unittest.TestCase):
+class freq2note_simple_test(TestCase):
     def test_freq2note_above(self):
         " make sure freq2note(441) == A4 "
         " make sure freq2note(439) == A4 "
         self.assertEqual("A4", freq2note(439))
-class note2freq_simple_test(unittest.TestCase):
+class note2freq_simple_test(TestCase):
     def test_note2freq(self):
         " make sure note2freq('A3') == 220"
             self.assertLess(abs(note2freq("A4")-440), 1.e-12)
 if __name__ == '__main__':
-    import nose2
+    from _tools import run_module_suite
-    nose2.main()
+    run_module_suite()

python/tests/test_notes.py+6−7

 #! /usr/bin/env python
-from unittest import main
 from numpy.testing import TestCase, assert_equal, assert_almost_equal
-from aubio import notes
+from aubio import notes, source
+import numpy as np
+from utils import list_all_sounds
+list_of_sounds = list_all_sounds('sounds')
 AUBIO_DEFAULT_NOTES_SILENCE = -70.
 AUBIO_DEFAULT_NOTES_RELEASE_DROP = 10.
         with self.assertRaises(ValueError):
             self.o.set_release_drop(val)
-from .utils import list_all_sounds
-list_of_sounds = list_all_sounds('sounds')
 class aubio_notes_sinewave(TestCase):
     def analyze_file(self, filepath, samplerate=0):
-        from aubio import source
-        import numpy as np
         win_s = 512 # fft size
         hop_s = 256 # hop size
                 assert_equal (results[0][1], [69, 123, -1])
 if __name__ == '__main__':
+    from unittest import main
     main()

python/tests/test_onset.py+1−1

@@ -1,6 +1,5 @@
1	#! /usr/bin/env python	1	#! /usr/bin/env python
2		2
3	from unittest import main
4	from numpy.testing import TestCase, assert_equal, assert_almost_equal	3	from numpy.testing import TestCase, assert_equal, assert_almost_equal
5	from aubio import onset, fvec	4	from aubio import onset, fvec
6		5
@@ -116,4 +115,5 @@ class aubio_onset_coverate(TestCase): · 109 unmodified lines
116		115
117		116
118	if __name__ == '__main__':	117	if __name__ == '__main__':
		118	from unittest import main
119	main()	119	main()

python/tests/test_phasevoc.py+13−8

 #! /usr/bin/env python
 from numpy.testing import TestCase, assert_equal, assert_array_less
+from _tools import parametrize
 from aubio import fvec, cvec, pvoc, float_type
-from nose2 import main
-from nose2.tools import params
 import numpy as np
 if float_type == 'float32':
 def create_noise(hop_s):
     return np.random.rand(hop_s).astype(float_type) * 2. - 1.
-class aubio_pvoc_test_case(TestCase):
+class Test_aubio_pvoc_test_case(object):
     """ pvoc object test case """
     def test_members_automatic_sizes_default(self):
             r = f.rdo(s)
             assert_equal ( t, 0.)
-    @params(
+    resynth_noise_args = "hop_s, ratio"
+    resynth_noise_values = [
             ( 256, 8),
             ( 256, 4),
             ( 256, 2),
             (8192, 8),
             (8192, 4),
             (8192, 2),
-            )
+            ]
+    @parametrize(resynth_noise_args, resynth_noise_values)
     def test_resynth_steps_noise(self, hop_s, ratio):
         """ check the resynthesis of a random signal is correct """
         sigin = create_noise(hop_s)
         self.reconstruction(sigin, hop_s, ratio)
-    @params(
+    resynth_sine_args = "samplerate, hop_s, ratio, freq"
+    resynth_sine_values = [
             (44100,  256, 8,   441),
             (44100,  256, 4,  1203),
             (44100,  256, 2,  3045),
             (22050,  256, 8,   445),
             (96000, 1024, 8, 47000),
             (96000, 1024, 8,    20),
-            )
+            ]
+    @parametrize(resynth_sine_args, resynth_sine_values)
     def test_resynth_steps_sine(self, samplerate, hop_s, ratio, freq):
         """ check the resynthesis of a sine is correct """
         sigin = create_sine(hop_s, freq, samplerate)
             self.skipTest('creating aubio.pvoc with size %d did not fail' % win_s)
 if __name__ == '__main__':
+    from unittest import main
     main()

python/tests/test_pitch.py+5−5

 #! /usr/bin/env python
-from unittest import TestCase, main
+from numpy.testing import TestCase, assert_equal
-from numpy.testing import assert_equal
 from numpy import sin, arange, mean, median, isnan, pi
 from aubio import fvec, pitch, freqtomidi, float_type
 for algo in pitch_algorithms:
     for mode in signal_modes:
-        test_method = create_test (algo, mode)
+        _test_method = create_test (algo, mode)
-        test_method.__name__ = 'test_pitch_%s_%d_%d_%dHz_sin_%.0f' % ( algo,
+        _test_method.__name__ = 'test_pitch_%s_%d_%d_%dHz_sin_%.0f' % ( algo,
                 mode[0], mode[1], mode[2], mode[3] )
-        setattr (aubio_pitch_Sinusoid, test_method.__name__, test_method)
+        setattr (aubio_pitch_Sinusoid, _test_method.__name__, _test_method)
 if __name__ == '__main__':
+    from unittest import main
     main()

python/tests/test_sink.py+16−22

@@ -1,13 +1,9 @@
1	#! /usr/bin/env python	1	#! /usr/bin/env python
2		2
3	from nose2 import main
4	from nose2.tools import params
5	from numpy.testing import TestCase	3	from numpy.testing import TestCase
6	from aubio import fvec, source, sink	4	from aubio import fvec, source, sink
7	from .utils import list_all_sounds, get_tmp_sink_path, del_tmp_sink_path	5	from utils import list_all_sounds, get_tmp_sink_path, del_tmp_sink_path
8		6	from _tools import parametrize, skipTest, assert_raises
9	import warnings
10	warnings.filterwarnings('ignore', category=UserWarning, append=True)
11		7
12	list_of_sounds = list_all_sounds('sounds')	8	list_of_sounds = list_all_sounds('sounds')
13	samplerates = [0, 44100, 8000, 32000]	9	samplerates = [0, 44100, 8000, 32000]
@@ -23,30 +19,26 @@ for soundfile in list_of_sounds: · 9 unmodified lines
23	for samplerate in samplerates:	19	for samplerate in samplerates:
24	all_params.append((hop_size, samplerate, soundfile))	20	all_params.append((hop_size, samplerate, soundfile))
25		21
26	class aubio_sink_test_case(TestCase):	22	class Test_aubio_sink(object):
27
28	def setUp(self):
29	if not len(list_of_sounds):
30	self.skipTest('add some sound files in \'python/tests/sounds\'')
31		23
32	def test_wrong_filename(self):	24	def test_wrong_filename(self):
33	with self.assertRaises(RuntimeError):	25	with assert_raises(RuntimeError):
34	sink('')	26	sink('')
35		27
36	def test_wrong_samplerate(self):	28	def test_wrong_samplerate(self):
37	with self.assertRaises(RuntimeError):	29	with assert_raises(RuntimeError):
38	sink(get_tmp_sink_path(), -1)	30	sink(get_tmp_sink_path(), -1)
39		31
40	def test_wrong_samplerate_too_large(self):	32	def test_wrong_samplerate_too_large(self):
41	with self.assertRaises(RuntimeError):	33	with assert_raises(RuntimeError):
42	sink(get_tmp_sink_path(), 1536001, 2)	34	sink(get_tmp_sink_path(), 1536001, 2)
43		35
44	def test_wrong_channels(self):	36	def test_wrong_channels(self):
45	with self.assertRaises(RuntimeError):	37	with assert_raises(RuntimeError):
46	sink(get_tmp_sink_path(), 44100, -1)	38	sink(get_tmp_sink_path(), 44100, -1)
47		39
48	def test_wrong_channels_too_large(self):	40	def test_wrong_channels_too_large(self):
49	with self.assertRaises(RuntimeError):	41	with assert_raises(RuntimeError):
50	sink(get_tmp_sink_path(), 44100, 202020)	42	sink(get_tmp_sink_path(), 44100, 202020)
51		43
52	def test_many_sinks(self):	44	def test_many_sinks(self):
@@ -66,13 +58,13 @@ class aubio_sink_test_case(TestCase): · 13 unmodified lines
66	g.close()	58	g.close()
67	shutil.rmtree(tmpdir)	59	shutil.rmtree(tmpdir)
68		60
69	@params(*all_params)	61	@parametrize('hop_size, samplerate, path', all_params)
70	def test_read_and_write(self, hop_size, samplerate, path):	62	def test_read_and_write(self, hop_size, samplerate, path):
71
72	try:	63	try:
73	f = source(path, samplerate, hop_size)	64	f = source(path, samplerate, hop_size)
74	except RuntimeError as e:	65	except RuntimeError as e:
75	self.skipTest('failed opening with hop_s = {:d}, samplerate = {:d} ({:s})'.format(hop_size, samplerate, str(e)))	66	err_msg = '{:s} (hop_s = {:d}, samplerate = {:d})'
		67	skipTest(err_msg.format(str(e), hop_size, samplerate))
76	if samplerate == 0: samplerate = f.samplerate	68	if samplerate == 0: samplerate = f.samplerate
77	sink_path = get_tmp_sink_path()	69	sink_path = get_tmp_sink_path()
78	g = sink(sink_path, samplerate)	70	g = sink(sink_path, samplerate)
@@ -84,12 +76,13 @@ class aubio_sink_test_case(TestCase): · 5 unmodified lines
84	if read < f.hop_size: break	76	if read < f.hop_size: break
85	del_tmp_sink_path(sink_path)	77	del_tmp_sink_path(sink_path)
86		78
87	@params(*all_params)	79	@parametrize('hop_size, samplerate, path', all_params)
88	def test_read_and_write_multi(self, hop_size, samplerate, path):	80	def test_read_and_write_multi(self, hop_size, samplerate, path):
89	try:	81	try:
90	f = source(path, samplerate, hop_size)	82	f = source(path, samplerate, hop_size)
91	except RuntimeError as e:	83	except RuntimeError as e:
92	self.skipTest('failed opening with hop_s = {:d}, samplerate = {:d} ({:s})'.format(hop_size, samplerate, str(e)))	84	err_msg = '{:s} (hop_s = {:d}, samplerate = {:d})'
		85	skipTest(err_msg.format(str(e), hop_size, samplerate))
93	if samplerate == 0: samplerate = f.samplerate	86	if samplerate == 0: samplerate = f.samplerate
94	sink_path = get_tmp_sink_path()	87	sink_path = get_tmp_sink_path()
95	g = sink(sink_path, samplerate, channels = f.channels)	88	g = sink(sink_path, samplerate, channels = f.channels)
@@ -125,4 +118,5 @@ class aubio_sink_test_case(TestCase): · 29 unmodified lines
125	g(vec, 128)	118	g(vec, 128)
126		119
127	if __name__ == '__main__':	120	if __name__ == '__main__':
128	main()	121	from _tools import run_module_suite
		122	run_module_suite()

python/tests/test_slicing.py+3−3

 #! /usr/bin/env python
-from unittest import main
 from numpy.testing import TestCase, assert_equal
 from aubio import slice_source_at_stamps
-from .utils import count_files_in_directory, get_default_test_sound
+from utils import count_files_in_directory, get_default_test_sound
-from .utils import count_samples_in_directory, count_samples_in_file
+from utils import count_samples_in_directory, count_samples_in_file
 import tempfile
 import shutil
         shutil.rmtree(self.output_dir)
 if __name__ == '__main__':
+    from unittest import main
     main()

python/tests/test_source.py+56−53

@@ -1,19 +1,17 @@
1	#! /usr/bin/env python	1	#! /usr/bin/env python
2		2
3	from nose2 import main	3
4	from nose2.tools import params
5	from numpy.testing import TestCase, assert_equal	4	from numpy.testing import TestCase, assert_equal
6	from aubio import source	5	from aubio import source
7	from .utils import list_all_sounds	6	from utils import list_all_sounds
8		7	import unittest
9	import warnings	8	from _tools import parametrize, assert_raises, assert_equal, skipTest
10	warnings.filterwarnings('ignore', category=UserWarning, append=True)
11		9
12	list_of_sounds = list_all_sounds('sounds')	10	list_of_sounds = list_all_sounds('sounds')
13	samplerates = [0, 44100, 8000, 32000]	11	samplerates = [0, 44100, 8000, 32000]
14	hop_sizes = [512, 1024, 64]	12	hop_sizes = [512, 1024, 64]
15		13
16	path = None	14	default_test_sound = len(list_of_sounds) and list_of_sounds[0] or None
17		15
18	all_params = []	16	all_params = []
19	for soundfile in list_of_sounds:	17	for soundfile in list_of_sounds:
@@ -21,24 +19,20 @@ for soundfile in list_of_sounds: · 1 unmodified line
21	for samplerate in samplerates:	19	for samplerate in samplerates:
22	all_params.append((hop_size, samplerate, soundfile))	20	all_params.append((hop_size, samplerate, soundfile))
23		21
		22	no_sounds_msg = "no test sounds, add some in 'python/tests/sounds/'!"
24		23
25	class aubio_source_test_case_base(TestCase):	24	_debug = False
26
27	def setUp(self):
28	if not len(list_of_sounds):
29	self.skipTest('add some sound files in \'python/tests/sounds\'')
30	self.default_test_sound = list_of_sounds[0]
31		25
32	class aubio_source_test_case(aubio_source_test_case_base):	26	class Test_aubio_source_test_case(object):
33		27
34	@params(*list_of_sounds)	28	@parametrize('filename', list_of_sounds)
35	def test_close_file(self, filename):	29	def test_close_file(self, filename):
36	samplerate = 0 # use native samplerate	30	samplerate = 0 # use native samplerate
37	hop_size = 256	31	hop_size = 256
38	f = source(filename, samplerate, hop_size)	32	f = source(filename, samplerate, hop_size)
39	f.close()	33	f.close()
40		34
41	@params(*list_of_sounds)	35	@parametrize('filename', list_of_sounds)
42	def test_close_file_twice(self, filename):	36	def test_close_file_twice(self, filename):
43	samplerate = 0 # use native samplerate	37	samplerate = 0 # use native samplerate
44	hop_size = 256	38	hop_size = 256
@@ -46,7 +40,7 @@ class aubio_source_test_case(aubio_source_test_case_base): · 1 unmodified line
46	f.close()	40	f.close()
47	f.close()	41	f.close()
48		42
49	class aubio_source_read_test_case(aubio_source_test_case_base):	43	class Test_aubio_source_read(object):
50		44
51	def read_from_source(self, f):	45	def read_from_source(self, f):
52	total_frames = 0	46	total_frames = 0
@@ -56,47 +50,51 @@ class aubio_source_read_test_case(aubio_source_test_case_base): · 3 unmodified lines
56	if read < f.hop_size:	50	if read < f.hop_size:
57	assert_equal(samples[read:], 0)	51	assert_equal(samples[read:], 0)
58	break	52	break
59	#result_str = "read {:.2f}s ({:d} frames in {:d} blocks at {:d}Hz) from {:s}"	53	if _debug:
60	#result_params = total_frames / float(f.samplerate), total_frames, total_frames//f.hop_size, f.samplerate, f.uri	54	result_str = "read {:.2f}s ({:d} frames"
61	#print (result_str.format(*result_params))	55	result_str += " in {:d} blocks at {:d}Hz) from {:s}"
		56	result_params = total_frames / float(f.samplerate), total_frames, \
		57	total_frames//f.hop_size, f.samplerate, f.uri
		58	print (result_str.format(*result_params))
62	return total_frames	59	return total_frames
63		60
64	@params(*all_params)	61	@parametrize('hop_size, samplerate, soundfile', all_params)
65	def test_samplerate_hopsize(self, hop_size, samplerate, soundfile):	62	def test_samplerate_hopsize(self, hop_size, samplerate, soundfile):
66	try:	63	try:
67	f = source(soundfile, samplerate, hop_size)	64	f = source(soundfile, samplerate, hop_size)
68	except RuntimeError as e:	65	except RuntimeError as e:
69	self.skipTest('failed opening with hop_s = {:d}, samplerate = {:d} ({:s})'.format(hop_size, samplerate, str(e)))	66	err_msg = 'failed opening with hop_s={:d}, samplerate={:d} ({:s})'
		67	skipTest(err_msg.format(hop_size, samplerate, str(e)))
70	assert f.samplerate != 0	68	assert f.samplerate != 0
71	read_frames = self.read_from_source(f)	69	read_frames = self.read_from_source(f)
72	if 'f_' in soundfile and samplerate == 0:	70	if 'f_' in soundfile and samplerate == 0:
73	import re	71	import re
74	f = re.compile('._$[0:9]f$_.*')	72	f = re.compile(r'._$[0:9]f$_.*')
75	match_f = re.findall('([0-9]*)f_', soundfile)	73	match_f = re.findall('([0-9]*)f_', soundfile)
76	if len(match_f) == 1:	74	if len(match_f) == 1:
77	expected_frames = int(match_f[0])	75	expected_frames = int(match_f[0])
78	self.assertEqual(expected_frames, read_frames)	76	assert_equal(expected_frames, read_frames)
79		77
80	@params(*list_of_sounds)	78	@parametrize('p', list_of_sounds)
81	def test_samplerate_none(self, p):	79	def test_samplerate_none(self, p):
82	f = source(p)	80	f = source(p)
83	assert f.samplerate != 0	81	assert f.samplerate != 0
84	self.read_from_source(f)	82	self.read_from_source(f)
85		83
86	@params(*list_of_sounds)	84	@parametrize('p', list_of_sounds)
87	def test_samplerate_0(self, p):	85	def test_samplerate_0(self, p):
88	f = source(p, 0)	86	f = source(p, 0)
89	assert f.samplerate != 0	87	assert f.samplerate != 0
90	self.read_from_source(f)	88	self.read_from_source(f)
91		89
92	@params(*list_of_sounds)	90	@parametrize('p', list_of_sounds)
93	def test_zero_hop_size(self, p):	91	def test_zero_hop_size(self, p):
94	f = source(p, 0, 0)	92	f = source(p, 0, 0)
95	assert f.samplerate != 0	93	assert f.samplerate != 0
96	assert f.hop_size != 0	94	assert f.hop_size != 0
97	self.read_from_source(f)	95	self.read_from_source(f)
98		96
99	@params(*list_of_sounds)	97	@parametrize('p', list_of_sounds)
100	def test_seek_to_half(self, p):	98	def test_seek_to_half(self, p):
101	from random import randint	99	from random import randint
102	f = source(p, 0, 0)	100	f = source(p, 0, 0)
@@ -108,7 +106,7 @@ class aubio_source_read_test_case(aubio_source_test_case_base): · 5 unmodified lines
108	b = self.read_from_source(f)	106	b = self.read_from_source(f)
109	assert a == b + c	107	assert a == b + c
110		108
111	@params(*list_of_sounds)	109	@parametrize('p', list_of_sounds)
112	def test_duration(self, p):	110	def test_duration(self, p):
113	total_frames = 0	111	total_frames = 0
114	f = source(p)	112	f = source(p)
@@ -117,43 +115,44 @@ class aubio_source_read_test_case(aubio_source_test_case_base): · 2 unmodified lines
117	_, read = f()	115	_, read = f()
118	total_frames += read	116	total_frames += read
119	if read < f.hop_size: break	117	if read < f.hop_size: break
120	self.assertEqual(duration, total_frames)	118	assert_equal (duration, total_frames)
121		119
122		120
123	class aubio_source_test_wrong_params(TestCase):	121	class Test_aubio_source_wrong_params(object):
124		122
125	def test_wrong_file(self):	123	def test_wrong_file(self):
126	with self.assertRaises(RuntimeError):	124	with assert_raises(RuntimeError):
127	source('path_to/unexisting file.mp3')	125	source('path_to/unexisting file.mp3')
128		126
129	class aubio_source_test_wrong_params_with_file(aubio_source_test_case_base):	127	@unittest.skipIf(default_test_sound is None, no_sounds_msg)
		128	class Test_aubio_source_wrong_params_with_file(TestCase):
130		129
131	def test_wrong_samplerate(self):	130	def test_wrong_samplerate(self):
132	with self.assertRaises(ValueError):	131	with assert_raises(ValueError):
133	source(self.default_test_sound, -1)	132	source(default_test_sound, -1)
134		133
135	def test_wrong_hop_size(self):	134	def test_wrong_hop_size(self):
136	with self.assertRaises(ValueError):	135	with assert_raises(ValueError):
137	source(self.default_test_sound, 0, -1)	136	source(default_test_sound, 0, -1)
138		137
139	def test_wrong_channels(self):	138	def test_wrong_channels(self):
140	with self.assertRaises(ValueError):	139	with assert_raises(ValueError):
141	source(self.default_test_sound, 0, 0, -1)	140	source(default_test_sound, 0, 0, -1)
142		141
143	def test_wrong_seek(self):	142	def test_wrong_seek(self):
144	f = source(self.default_test_sound)	143	f = source(default_test_sound)
145	with self.assertRaises(ValueError):	144	with assert_raises(ValueError):
146	f.seek(-1)	145	f.seek(-1)
147		146
148	def test_wrong_seek_too_large(self):	147	def test_wrong_seek_too_large(self):
149	f = source(self.default_test_sound)	148	f = source(default_test_sound)
150	try:	149	try:
151	with self.assertRaises(ValueError):	150	with assert_raises(ValueError):
152	f.seek(f.duration + f.samplerate * 10)	151	f.seek(f.duration + f.samplerate * 10)
153	except AssertionError:	152	except:
154	self.skipTest('seeking after end of stream failed raising ValueError')	153	skipTest('seeking after end of stream failed raising ValueError')
155		154
156	class aubio_source_readmulti_test_case(aubio_source_read_test_case):	155	class Test_aubio_source_readmulti(Test_aubio_source_read):
157		156
158	def read_from_source(self, f):	157	def read_from_source(self, f):
159	total_frames = 0	158	total_frames = 0
@@ -163,15 +162,18 @@ class aubio_source_readmulti_test_case(aubio_source_read_test_case): · 3 unmodified lines
163	if read < f.hop_size:	162	if read < f.hop_size:
164	assert_equal(samples[:,read:], 0)	163	assert_equal(samples[:,read:], 0)
165	break	164	break
166	#result_str = "read {:.2f}s ({:d} frames in {:d} channels and {:d} blocks at {:d}Hz) from {:s}"	165	if _debug:
167	#result_params = total_frames / float(f.samplerate), total_frames, f.channels, int(total_frames/f.hop_size), f.samplerate, f.uri	166	result_str = "read {:.2f}s ({:d} frames in {:d} channels"
168	#print (result_str.format(*result_params))	167	result_str += " and {:d} blocks at {:d}Hz) from {:s}"
		168	result_params = total_frames / float(f.samplerate), total_frames, \
		169	f.channels, int(total_frames/f.hop_size), \
		170	f.samplerate, f.uri
		171	print (result_str.format(*result_params))
169	return total_frames	172	return total_frames
170		173
171	class aubio_source_with(aubio_source_test_case_base):	174	class Test_aubio_source_with(object):
172		175
173	#@params(*list_of_sounds)	176	@parametrize('filename', list_of_sounds)
174	@params(*list_of_sounds)
175	def test_read_from_mono(self, filename):	177	def test_read_from_mono(self, filename):
176	total_frames = 0	178	total_frames = 0
177	hop_size = 2048	179	hop_size = 2048
@@ -185,4 +187,5 @@ class aubio_source_with(aubio_source_test_case_base): · 7 unmodified lines
185	assert_equal(total_frames, input_source.duration)	187	assert_equal(total_frames, input_source.duration)
186		188
187	if __name__ == '__main__':	189	if __name__ == '__main__':
188	main()	190	from _tools import run_module_suite
		191	run_module_suite()

python/tests/test_source_channels.py+1−1

@@ -8,7 +8,7 @@ import unittest · 7 unmodified lines
8	import aubio	8	import aubio
9	import numpy as np	9	import numpy as np
10	from numpy.testing import assert_equal	10	from numpy.testing import assert_equal
11	from .utils import get_tmp_sink_path	11	from utils import get_tmp_sink_path
12		12
13	class aubio_source_test_case(unittest.TestCase):	13	class aubio_source_test_case(unittest.TestCase):
14		14

python/tests/test_specdesc.py+1−1

 #! /usr/bin/env python
-from unittest import main
 from numpy.testing import TestCase, assert_equal, assert_almost_equal
 from numpy import random, arange, log, zeros
 from aubio import specdesc, cvec, float_type
             specdesc("unknown", 512)
 if __name__ == '__main__':
+    from unittest import main
     main()

python/tests/test_zero_crossing_rate.py+1−1

 #! /usr/bin/env python
-from unittest import main
 from numpy.testing import TestCase
 from aubio import fvec, zero_crossing_rate
         self.assertEqual(2./buf_size, zero_crossing_rate(self.vector))
 if __name__ == '__main__':
+    from unittest import main
     main()

python/tests/utils.py+6−12

 DEFAULT_SOUND = '22050Hz_5s_brownnoise.wav'
 def array_from_text_file(filename, dtype = 'float'):
-    filename = os.path.join(os.path.dirname(__file__), filename)
+    realpathname = os.path.join(os.path.dirname(__file__), filename)
-    with open(filename) as f:
+    return np.loadtxt(realpathname, dtype = dtype)
-        lines = f.readlines()
-    return np.array([line.split() for line in lines],
-            dtype = dtype)
 def list_all_sounds(rel_dir):
     datadir = os.path.join(os.path.dirname(__file__), rel_dir)
     try:
         os.unlink(path)
     except WindowsError as e:
-        print("deleting {:s} failed ({:s}), reopening".format(path, repr(e)))
+        # removing the temporary directory sometimes fails on windows
-        with open(path, 'wb') as f:
+        import warnings
-            f.close()
+        errmsg = "failed deleting temporary file {:s} ({:s})"
-        try:
+        warnings.warn(UserWarning(errmsg.format(path, repr(e))))
-            os.unlink(path)
-        except WindowsError as f:
-            print("deleting {:s} failed ({:s}), aborting".format(path, repr(e)))
 def array_from_yaml_file(filename):
     import yaml

requirements.txt+1−1

@@ -1,2 +1,2 @@
1	numpy	1	numpy
2	nose2	2	pytest

setup.py+0−4

             'aubiocut = aubio.cut:main',
         ],
     },
-    test_suite = 'nose2.collector.collector',
-    extras_require = {
-        'tests': ['numpy'],
-        },
     )

src/io/sink_apple_audio.c+34−8

@@ -31,9 +31,7 @@ · 30 unmodified lines
31	// ExtAudioFileRef, AudioStreamBasicDescription, AudioBufferList, ...	31	// ExtAudioFileRef, AudioStreamBasicDescription, AudioBufferList, ...
32	#include <AudioToolbox/AudioToolbox.h>	32	#include <AudioToolbox/AudioToolbox.h>
33		33
34	#define FLOAT_TO_SHORT(x) (short)(x * 32768)	34	extern int createAudioBufferList(AudioBufferList *bufferList, int channels, int segmentSize);
35
36	extern int createAubioBufferList(AudioBufferList *bufferList, int channels, int segmentSize);
37	extern void freeAudioBufferList(AudioBufferList *bufferList);	35	extern void freeAudioBufferList(AudioBufferList *bufferList);
38	extern CFURLRef createURLFromPath(const char * path);	36	extern CFURLRef createURLFromPath(const char * path);
39	char_t getPrintableOSStatusError(char_t str, OSStatus error);	37	char_t getPrintableOSStatusError(char_t str, OSStatus error);
@@ -76,6 +74,7 @@ aubio_sink_apple_audio_t * new_aubio_sink_apple_audio(const char_t * uri, uint_t · 36 unmodified lines
76	if ((sint_t)samplerate == 0) {	74	if ((sint_t)samplerate == 0) {
77	return s;	75	return s;
78	}	76	}
		77
79	// invalid samplerate given, abort	78	// invalid samplerate given, abort
80	if (aubio_io_validate_samplerate("sink_apple_audio", s->path, samplerate)) {	79	if (aubio_io_validate_samplerate("sink_apple_audio", s->path, samplerate)) {
81	goto beach;	80	goto beach;
@@ -150,6 +149,18 @@ uint_t aubio_sink_apple_audio_open(aubio_sink_apple_audio_t *s) { · 68 unmodified lines
150	AudioFileTypeID fileType = kAudioFileWAVEType;	149	AudioFileTypeID fileType = kAudioFileWAVEType;
151	CFURLRef fileURL = createURLFromPath(s->path);	150	CFURLRef fileURL = createURLFromPath(s->path);
152	bool overwrite = true;	151	bool overwrite = true;
		152
		153	// set the in-memory format
		154	AudioStreamBasicDescription inputFormat;
		155	memset(&inputFormat, 0, sizeof(AudioStreamBasicDescription));
		156	inputFormat.mFormatID = kAudioFormatLinearPCM;
		157	inputFormat.mSampleRate = (Float64)(s->samplerate);
		158	inputFormat.mFormatFlags = kAudioFormatFlagIsFloat \| kAudioFormatFlagIsPacked;
		159	inputFormat.mChannelsPerFrame = s->channels;
		160	inputFormat.mBitsPerChannel = sizeof(smpl_t) * 8;
		161	inputFormat.mFramesPerPacket = 1;
		162	inputFormat.mBytesPerFrame = inputFormat.mBitsPerChannel * inputFormat.mChannelsPerFrame / 8;
		163	inputFormat.mBytesPerPacket = inputFormat.mFramesPerPacket * inputFormat.mBytesPerFrame;
153	OSStatus err = noErr;	164	OSStatus err = noErr;
154	err = ExtAudioFileCreateWithURL(fileURL, fileType, &clientFormat, NULL,	165	err = ExtAudioFileCreateWithURL(fileURL, fileType, &clientFormat, NULL,
155	overwrite ? kAudioFileFlags_EraseFile : 0, &s->audioFile);	166	overwrite ? kAudioFileFlags_EraseFile : 0, &s->audioFile);
@@ -161,7 +172,18 @@ uint_t aubio_sink_apple_audio_open(aubio_sink_apple_audio_t *s) { · 5 unmodified lines
161	getPrintableOSStatusError(errorstr, err));	172	getPrintableOSStatusError(errorstr, err));
162	goto beach;	173	goto beach;
163	}	174	}
164	if (createAubioBufferList(&s->bufferList, s->channels, s->max_frames * s->channels)) {	175
		176	err = ExtAudioFileSetProperty(s->audioFile,
		177	kExtAudioFileProperty_ClientDataFormat,
		178	sizeof(AudioStreamBasicDescription), &inputFormat);
		179	if (err) {
		180	char_t errorstr[20];
		181	AUBIO_ERR("sink_apple_audio: error when trying to set output format on %s "
		182	"(%s)\n", s->path, getPrintableOSStatusError(errorstr, err));
		183	goto beach;
		184	}
		185
		186	if (createAudioBufferList(&s->bufferList, s->channels, s->max_frames * s->channels)) {
165	AUBIO_ERR("sink_apple_audio: error when creating buffer list for %s, "	187	AUBIO_ERR("sink_apple_audio: error when creating buffer list for %s, "
166	"out of memory? \n", s->path);	188	"out of memory? \n", s->path);
167	goto beach;	189	goto beach;
@@ -174,13 +196,13 @@ beach: · 6 unmodified lines
174		196
175	void aubio_sink_apple_audio_do(aubio_sink_apple_audio_t * s, fvec_t * write_data, uint_t write) {	197	void aubio_sink_apple_audio_do(aubio_sink_apple_audio_t * s, fvec_t * write_data, uint_t write) {
176	UInt32 c, v;	198	UInt32 c, v;
177	short data = (short)s->bufferList.mBuffers[0].mData;	199	smpl_t data = (smpl_t)s->bufferList.mBuffers[0].mData;
178	uint_t length = aubio_sink_validate_input_length("sink_apple_audio", s->path,	200	uint_t length = aubio_sink_validate_input_length("sink_apple_audio", s->path,
179	s->max_frames, write_data->length, write);	201	s->max_frames, write_data->length, write);
180		202
181	for (c = 0; c < s->channels; c++) {	203	for (c = 0; c < s->channels; c++) {
182	for (v = 0; v < length; v++) {	204	for (v = 0; v < length; v++) {
183	data[v * s->channels + c] = FLOAT_TO_SHORT(write_data->data[v]);	205	data[v * s->channels + c] = write_data->data[v];
184	}	206	}
185	}	207	}
186		208
@@ -189,7 +211,7 @@ void aubio_sink_apple_audio_do(aubio_sink_apple_audio_t * s, fvec_t * write_data · 2 unmodified lines
189		211
190	void aubio_sink_apple_audio_do_multi(aubio_sink_apple_audio_t * s, fmat_t * write_data, uint_t write) {	212	void aubio_sink_apple_audio_do_multi(aubio_sink_apple_audio_t * s, fmat_t * write_data, uint_t write) {
191	UInt32 c, v;	213	UInt32 c, v;
192	short data = (short)s->bufferList.mBuffers[0].mData;	214	smpl_t data = (smpl_t)s->bufferList.mBuffers[0].mData;
193	uint_t channels = aubio_sink_validate_input_channels("sink_apple_audio",	215	uint_t channels = aubio_sink_validate_input_channels("sink_apple_audio",
194	s->path, s->channels, write_data->height);	216	s->path, s->channels, write_data->height);
195	uint_t length = aubio_sink_validate_input_length("sink_apple_audio", s->path,	217	uint_t length = aubio_sink_validate_input_length("sink_apple_audio", s->path,
@@ -197,7 +219,7 @@ void aubio_sink_apple_audio_do_multi(aubio_sink_apple_audio_t * s, fmat_t * writ · 1 unmodified line
197		219
198	for (c = 0; c < channels; c++) {	220	for (c = 0; c < channels; c++) {
199	for (v = 0; v < length; v++) {	221	for (v = 0; v < length; v++) {
200	data[v * s->channels + c] = FLOAT_TO_SHORT(write_data->data[c][v]);	222	data[v * s->channels + c] = write_data->data[c][v];
201	}	223	}
202	}	224	}
203		225
@@ -206,6 +228,10 @@ void aubio_sink_apple_audio_do_multi(aubio_sink_apple_audio_t * s, fmat_t * writ · 2 unmodified lines
206		228
207	void aubio_sink_apple_audio_write(aubio_sink_apple_audio_t *s, uint_t write) {	229	void aubio_sink_apple_audio_write(aubio_sink_apple_audio_t *s, uint_t write) {
208	OSStatus err = noErr;	230	OSStatus err = noErr;
		231	// set mDataByteSize to match the number of frames to be written
		232	// see https://www.mail-archive.com/coreaudio-api@lists.apple.com/msg01109.html
		233	s->bufferList.mBuffers[0].mDataByteSize = write * s->channels
		234	* sizeof(smpl_t);
209	if (s->async) {	235	if (s->async) {
210	err = ExtAudioFileWriteAsync(s->audioFile, write, &s->bufferList);	236	err = ExtAudioFileWriteAsync(s->audioFile, write, &s->bufferList);
211	if (err) {	237	if (err) {

src/io/source_apple_audio.c+27−41

@@ -34,8 +34,6 @@ · 33 unmodified lines
34	#define RT_BYTE3( a ) ( ((a) >> 16) & 0xff )	34	#define RT_BYTE3( a ) ( ((a) >> 16) & 0xff )
35	#define RT_BYTE4( a ) ( ((a) >> 24) & 0xff )	35	#define RT_BYTE4( a ) ( ((a) >> 24) & 0xff )
36		36
37	#define SHORT_TO_FLOAT(x) (smpl_t)(x * 3.0517578125e-05)
38
39	struct _aubio_source_apple_audio_t {	37	struct _aubio_source_apple_audio_t {
40	uint_t channels;	38	uint_t channels;
41	uint_t samplerate; //< requested samplerate	39	uint_t samplerate; //< requested samplerate
@@ -48,7 +46,7 @@ struct _aubio_source_apple_audio_t { · 6 unmodified lines
48	AudioBufferList bufferList;	46	AudioBufferList bufferList;
49	};	47	};
50		48
51	extern int createAubioBufferList(AudioBufferList *bufferList, int channels, int max_source_samples);	49	extern int createAudioBufferList(AudioBufferList *bufferList, int channels, int max_source_samples);
52	extern void freeAudioBufferList(AudioBufferList *bufferList);	50	extern void freeAudioBufferList(AudioBufferList *bufferList);
53	extern CFURLRef createURLFromPath(const char * path);	51	extern CFURLRef createURLFromPath(const char * path);
54	char_t getPrintableOSStatusError(char_t str, OSStatus error);	52	char_t getPrintableOSStatusError(char_t str, OSStatus error);
@@ -138,17 +136,16 @@ uint_t aubio_source_apple_audio_open (aubio_source_apple_audio_t *s, const char_ · 83 unmodified lines
138	s->channels = fileFormat.mChannelsPerFrame;	136	s->channels = fileFormat.mChannelsPerFrame;
139		137
140	AudioStreamBasicDescription clientFormat;	138	AudioStreamBasicDescription clientFormat;
141	propSize = sizeof(clientFormat);	139	propSize = sizeof(AudioStreamBasicDescription);
142	memset(&clientFormat, 0, sizeof(AudioStreamBasicDescription));	140	memset(&clientFormat, 0, sizeof(AudioStreamBasicDescription));
143	clientFormat.mFormatID = kAudioFormatLinearPCM;	141	clientFormat.mFormatID = kAudioFormatLinearPCM;
144	clientFormat.mSampleRate = (Float64)(s->samplerate);	142	clientFormat.mSampleRate = (Float64)(s->samplerate);
145	clientFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger \| kAudioFormatFlagIsPacked;	143	clientFormat.mFormatFlags = kAudioFormatFlagIsFloat;
146	clientFormat.mChannelsPerFrame = s->channels;	144	clientFormat.mChannelsPerFrame = s->channels;
147	clientFormat.mBitsPerChannel = sizeof(short) * 8;	145	clientFormat.mBitsPerChannel = sizeof(smpl_t) * 8;
148	clientFormat.mFramesPerPacket = 1;	146	clientFormat.mFramesPerPacket = 1;
149	clientFormat.mBytesPerFrame = clientFormat.mBitsPerChannel * clientFormat.mChannelsPerFrame / 8;	147	clientFormat.mBytesPerFrame = clientFormat.mBitsPerChannel * clientFormat.mChannelsPerFrame / 8;
150	clientFormat.mBytesPerPacket = clientFormat.mFramesPerPacket * clientFormat.mBytesPerFrame;	148	clientFormat.mBytesPerPacket = clientFormat.mFramesPerPacket * clientFormat.mBytesPerFrame;
151	clientFormat.mReserved = 0;
152		149
153	// set the client format description	150	// set the client format description
154	err = ExtAudioFileSetProperty(s->audioFile, kExtAudioFileProperty_ClientDataFormat,	151	err = ExtAudioFileSetProperty(s->audioFile, kExtAudioFileProperty_ClientDataFormat,
@@ -186,7 +183,7 @@ uint_t aubio_source_apple_audio_open (aubio_source_apple_audio_t *s, const char_ · 31 unmodified lines
186		183
187	// allocate the AudioBufferList	184	// allocate the AudioBufferList
188	freeAudioBufferList(&s->bufferList);	185	freeAudioBufferList(&s->bufferList);
189	if (createAubioBufferList(&s->bufferList, s->channels, s->block_size * s->channels)) {	186	if (createAudioBufferList(&s->bufferList, s->channels, s->block_size * s->channels)) {
190	AUBIO_ERR("source_apple_audio: failed creating bufferList\n");	187	AUBIO_ERR("source_apple_audio: failed creating bufferList\n");
191	goto beach;	188	goto beach;
192	}	189	}
@@ -195,60 +192,51 @@ beach: · 2 unmodified lines
195	return err;	192	return err;
196	}	193	}
197		194
198	void aubio_source_apple_audio_do(aubio_source_apple_audio_t s, fvec_t read_to, uint_t * read) {	195	static UInt32 aubio_source_apple_audio_read_frame(aubio_source_apple_audio_t *s)
199	UInt32 c, v, loadedPackets = s->block_size;	196	{
		197	UInt32 loadedPackets = s->block_size;
200	OSStatus err = ExtAudioFileRead(s->audioFile, &loadedPackets, &s->bufferList);	198	OSStatus err = ExtAudioFileRead(s->audioFile, &loadedPackets, &s->bufferList);
201	if (err) {	199	if (err) {
202	char_t errorstr[20];	200	char_t errorstr[20];
203	AUBIO_ERROR("source_apple_audio: error while reading %s "	201	AUBIO_ERROR("source_apple_audio: error while reading %s "
204	"with ExtAudioFileRead (%s)\n", s->path,	202	"with ExtAudioFileRead (%s)\n", s->path,
205	getPrintableOSStatusError(errorstr, err));	203	getPrintableOSStatusError(errorstr, err));
206	goto beach;
207	}	204	}
		205	return loadedPackets;
		206	}
208		207
209	short data = (short)s->bufferList.mBuffers[0].mData;	208	void aubio_source_apple_audio_do(aubio_source_apple_audio_t s, fvec_t read_to,
210		209	uint_t * read) {
211	smpl_t *buf = read_to->data;	210	uint_t c, v;
		211	UInt32 loadedPackets = aubio_source_apple_audio_read_frame(s);
		212	smpl_t data = (smpl_t)s->bufferList.mBuffers[0].mData;
212		213
213	for (v = 0; v < loadedPackets; v++) {	214	for (v = 0; v < loadedPackets; v++) {
214	buf[v] = 0.;	215	read_to->data[v] = 0.;
215	for (c = 0; c < s->channels; c++) {	216	for (c = 0; c < s->channels; c++) {
216	buf[v] += SHORT_TO_FLOAT(data[ v * s->channels + c]);	217	read_to->data[v] += data[ v * s->channels + c];
217	}	218	}
218	buf[v] /= (smpl_t)s->channels;	219	read_to->data[v] /= (smpl_t)s->channels;
219	}	220	}
220	// short read, fill with zeros	221	// short read, fill with zeros
221	if (loadedPackets < s->block_size) {	222	if (loadedPackets < s->block_size) {
222	for (v = loadedPackets; v < s->block_size; v++) {	223	for (v = loadedPackets; v < s->block_size; v++) {
223	buf[v] = 0.;	224	read_to->data[v] = 0.;
224	}	225	}
225	}	226	}
226		227
227	*read = (uint_t)loadedPackets;	228	*read = (uint_t)loadedPackets;
228	return;	229	return;
229	beach:
230	*read = 0;
231	return;
232	}	230	}
233		231
234	void aubio_source_apple_audio_do_multi(aubio_source_apple_audio_t s, fmat_t read_to, uint_t * read) {	232	void aubio_source_apple_audio_do_multi(aubio_source_apple_audio_t s, fmat_t read_to, uint_t * read) {
235	UInt32 c, v, loadedPackets = s->block_size;	233	uint_t c, v;
236	OSStatus err = ExtAudioFileRead(s->audioFile, &loadedPackets, &s->bufferList);	234	UInt32 loadedPackets = aubio_source_apple_audio_read_frame(s);
237	if (err) {	235	smpl_t data = (smpl_t)s->bufferList.mBuffers[0].mData;
238	char_t errorstr[20];
239	AUBIO_ERROR("source_apple_audio: error while reading %s "
240	"with ExtAudioFileRead (%s)\n", s->path,
241	getPrintableOSStatusError(errorstr, err));
242	goto beach;
243	}
244
245	short data = (short)s->bufferList.mBuffers[0].mData;
246
247	smpl_t **buf = read_to->data;
248		236
249	for (v = 0; v < loadedPackets; v++) {	237	for (v = 0; v < loadedPackets; v++) {
250	for (c = 0; c < read_to->height; c++) {	238	for (c = 0; c < read_to->height; c++) {
251	buf[c][v] = SHORT_TO_FLOAT(data[ v * s->channels + c]);	239	read_to->data[c][v] = data[ v * s->channels + c];
252	}	240	}
253	}	241	}
254	// if read_data has more channels than the file	242	// if read_data has more channels than the file
@@ -256,7 +244,7 @@ void aubio_source_apple_audio_do_multi(aubio_source_apple_audio_t s, fmat_t r · 1 unmodified line
256	// copy last channel to all additional channels	244	// copy last channel to all additional channels
257	for (v = 0; v < loadedPackets; v++) {	245	for (v = 0; v < loadedPackets; v++) {
258	for (c = s->channels; c < read_to->height; c++) {	246	for (c = s->channels; c < read_to->height; c++) {
259	buf[c][v] = SHORT_TO_FLOAT(data[ v * s->channels + (s->channels - 1)]);	247	read_to->data[c][v] = data[ v * s->channels + (s->channels - 1)];
260	}	248	}
261	}	249	}
262	}	250	}
@@ -264,15 +252,13 @@ void aubio_source_apple_audio_do_multi(aubio_source_apple_audio_t s, fmat_t r · 1 unmodified line
264	if (loadedPackets < s->block_size) {	252	if (loadedPackets < s->block_size) {
265	for (v = loadedPackets; v < s->block_size; v++) {	253	for (v = loadedPackets; v < s->block_size; v++) {
266	for (c = 0; c < read_to->height; c++) {	254	for (c = 0; c < read_to->height; c++) {
267	buf[c][v] = 0.;	255	read_to->data[c][v] = 0.;
268	}	256	}
269	}	257	}
270	}	258	}
		259
271	*read = (uint_t)loadedPackets;	260	*read = (uint_t)loadedPackets;
272	return;	261	return;
273	beach:
274	*read = 0;
275	return;
276	}	262	}
277		263
278	uint_t aubio_source_apple_audio_close (aubio_source_apple_audio_t *s)	264	uint_t aubio_source_apple_audio_close (aubio_source_apple_audio_t *s)
@@ -322,7 +308,7 @@ uint_t aubio_source_apple_audio_seek (aubio_source_apple_audio_t * s, uint_t pos · 43 unmodified lines
322	}	308	}
323	// after a short read, the bufferList size needs to resetted to prepare for a full read	309	// after a short read, the bufferList size needs to resetted to prepare for a full read
324	AudioBufferList *bufferList = &s->bufferList;	310	AudioBufferList *bufferList = &s->bufferList;
325	bufferList->mBuffers[0].mDataByteSize = s->block_size * s->channels * sizeof (short);	311	bufferList->mBuffers[0].mDataByteSize = s->block_size * s->channels * sizeof (smpl_t);
326	// do the actual seek	312	// do the actual seek
327	err = ExtAudioFileSeek(s->audioFile, resampled_pos);	313	err = ExtAudioFileSeek(s->audioFile, resampled_pos);
328	if (err) {	314	if (err) {

src/io/utils_apple_audio.c+4−3

 CFURLRef getURLFromPath(const char * path);
 char_t *getPrintableOSStatusError(char_t *str, OSStatus error);
-int createAubioBufferList(AudioBufferList * bufferList, int channels, int max_source_samples) {
+int createAudioBufferList(AudioBufferList * bufferList, int channels,
+    int max_source_samples) {
   bufferList->mNumberBuffers = 1;
   bufferList->mBuffers[0].mNumberChannels = channels;
-  bufferList->mBuffers[0].mData = AUBIO_ARRAY(short, max_source_samples);
+  bufferList->mBuffers[0].mData = AUBIO_ARRAY(smpl_t, max_source_samples);
-  bufferList->mBuffers[0].mDataByteSize = max_source_samples * sizeof(short);
+  bufferList->mBuffers[0].mDataByteSize = max_source_samples * sizeof(smpl_t);
   return 0;
 }

tests/src/io/base-sink_custom.h+16−12

@@ -25,21 +25,25 @@ int base_main(int argc, char **argv) · 24 unmodified lines
25	char_t *source_path = argv[1];	25	char_t *source_path = argv[1];
26	char_t *sink_path = argv[2];	26	char_t *sink_path = argv[2];
27		27
		28	aubio_source_t *src = NULL;
		29	aubio_sink_custom_t *snk = NULL;
		30
28	if ( argc >= 4 ) samplerate = atoi(argv[3]);	31	if ( argc >= 4 ) samplerate = atoi(argv[3]);
29	if ( argc >= 5 ) hop_size = atoi(argv[4]);	32	if ( argc >= 5 ) hop_size = atoi(argv[4]);
30		33
31	fvec_t *vec = new_fvec(hop_size);	34	fvec_t *vec = new_fvec(hop_size);
		35	if (!vec) { err = 1; goto failure; }
32		36
33	aubio_source_t *i = new_aubio_source(source_path, samplerate, hop_size);	37	src = new_aubio_source(source_path, samplerate, hop_size);
34	if (samplerate == 0 ) samplerate = aubio_source_get_samplerate(i);	38	if (!src) { err = 1; goto failure; }
35		39	if (samplerate == 0 ) samplerate = aubio_source_get_samplerate(src);
36	aubio_sink_custom_t *o = new_aubio_sink_custom(sink_path, samplerate);
37		40
38	if (!vec \|\| !i \|\| !o) { err = 1; goto failure; }	41	snk = new_aubio_sink_custom(sink_path, samplerate);
		42	if (!snk) { err = 1; goto failure; }
39		43
40	do {	44	do {
41	aubio_source_do(i, vec, &read);	45	aubio_source_do(src, vec, &read);
42	aubio_sink_custom_do(o, vec, read);	46	aubio_sink_custom_do(snk, vec, read);
43	n_frames += read;	47	n_frames += read;
44	} while ( read == hop_size );	48	} while ( read == hop_size );
45		49
@@ -48,13 +52,13 @@ int base_main(int argc, char **argv) · 2 unmodified lines
48	source_path, sink_path);	52	source_path, sink_path);
49		53
50	// close sink now (optional)	54	// close sink now (optional)
51	aubio_sink_custom_close(o);	55	aubio_sink_custom_close(snk);
52		56
53	failure:	57	failure:
54	if (o)	58	if (snk)
55	del_aubio_sink_custom(o);	59	del_aubio_sink_custom(snk);
56	if (i)	60	if (src)
57	del_aubio_source(i);	61	del_aubio_source(src);
58	if (vec)	62	if (vec)
59	del_fvec(vec);	63	del_fvec(vec);
60		64

tests/src/io/test-sink.c+16−12

@@ -21,21 +21,25 @@ int main(int argc, char **argv) · 20 unmodified lines
21	char_t *source_path = argv[1];	21	char_t *source_path = argv[1];
22	char_t *sink_path = argv[2];	22	char_t *sink_path = argv[2];
23		23
		24	aubio_source_t *src = NULL;
		25	aubio_sink_t *snk = NULL;
		26
24	if ( argc >= 4 ) samplerate = atoi(argv[3]);	27	if ( argc >= 4 ) samplerate = atoi(argv[3]);
25	if ( argc >= 5 ) hop_size = atoi(argv[4]);	28	if ( argc >= 5 ) hop_size = atoi(argv[4]);
26		29
27	fvec_t *vec = new_fvec(hop_size);	30	fvec_t *vec = new_fvec(hop_size);
		31	if (!vec) { err = 1; goto failure; }
28		32
29	aubio_source_t *i = new_aubio_source(source_path, samplerate, hop_size);	33	src = new_aubio_source(source_path, samplerate, hop_size);
30	if (samplerate == 0 ) samplerate = aubio_source_get_samplerate(i);	34	if (!src) { err = 1; goto failure; }
31		35	if (samplerate == 0 ) samplerate = aubio_source_get_samplerate(src);
32	aubio_sink_t *o = new_aubio_sink(sink_path, samplerate);
33		36
34	if (!vec \|\| !i \|\| !o) { err = 1; goto failure; }	37	snk = new_aubio_sink(sink_path, samplerate);
		38	if (!snk) { err = 1; goto failure; }
35		39
36	do {	40	do {
37	aubio_source_do(i, vec, &read);	41	aubio_source_do(src, vec, &read);
38	aubio_sink_do(o, vec, read);	42	aubio_sink_do(snk, vec, read);
39	n_frames += read;	43	n_frames += read;
40	} while ( read == hop_size );	44	} while ( read == hop_size );
41		45
@@ -44,13 +48,13 @@ int main(int argc, char **argv) · 2 unmodified lines
44	source_path, sink_path);	48	source_path, sink_path);
45		49
46	// close sink now (optional)	50	// close sink now (optional)
47	aubio_sink_close(o);	51	aubio_sink_close(snk);
48		52
49	failure:	53	failure:
50	if (o)	54	if (snk)
51	del_aubio_sink(o);	55	del_aubio_sink(snk);
52	if (i)	56	if (src)
53	del_aubio_source(i);	57	del_aubio_source(src);
54	if (vec)	58	if (vec)
55	del_fvec(vec);	59	del_fvec(vec);
56		60

tests/src/onset/test-onset.c+9−12

@@ -69,21 +69,19 @@ int test_wrong_params(void) · 68 unmodified lines
69	uint_t hop_size = win_size / 2;	69	uint_t hop_size = win_size / 2;
70	uint_t samplerate = 44100;	70	uint_t samplerate = 44100;
71	// hop_size < 1	71	// hop_size < 1
72	if (new_aubio_onset("default", 5, 0, samplerate))	72	if (new_aubio_onset("default", 5, 0, samplerate)) return 1;
73	return 1;	73
74	// buf_size < 2	74	// buf_size < 2
75	if (new_aubio_onset("default", 1, 1, samplerate))	75	if (new_aubio_onset("default", 1, 1, samplerate)) return 1;
76	return 1;	76
77	// buf_size < hop_size	77	// buf_size < hop_size
78	if (new_aubio_onset("default", hop_size, win_size, samplerate))	78	if (new_aubio_onset("default", hop_size, win_size, samplerate)) return 1;
79	return 1;	79
80	// samplerate < 1	80	// samplerate < 1
81	if (new_aubio_onset("default", 1024, 512, 0))	81	if (new_aubio_onset("default", 1024, 512, 0)) return 1;
82	return 1;
83		82
84	// specdesc creation failed	83	// specdesc creation failed
85	if (new_aubio_onset("abcd", win_size, win_size/2, samplerate))	84	if (new_aubio_onset("abcd", win_size, win_size/2, samplerate)) return 1;
86	return 1;
87		85
88	aubio_onset_t *o;	86	aubio_onset_t *o;
89		87
@@ -92,8 +90,7 @@ int test_wrong_params(void) · 2 unmodified lines
92	if (o) del_aubio_onset(o);	90	if (o) del_aubio_onset(o);
93		91
94	o = new_aubio_onset("default", win_size, hop_size, samplerate);	92	o = new_aubio_onset("default", win_size, hop_size, samplerate);
95	if (!aubio_onset_set_default_parameters(o, "wrong_type"))	93	if (!aubio_onset_set_default_parameters(o, "wrong_type")) return 1;
96	return 1;
97	del_aubio_onset(o);	94	del_aubio_onset(o);
98		95
99	return run_on_default_source(main);	96	return run_on_default_source(main);

tests/src/tempo/test-tempo.c+7−14

   uint_t i;
   // test wrong method fails
-  if (new_aubio_tempo("unexisting_method", win_size, hop_size, samplerate))
+  if (new_aubio_tempo("undefined", win_size, hop_size, samplerate)) return 1;
-    return 1;
   // test hop > win fails
-  if (new_aubio_tempo("default", hop_size, win_size, samplerate))
+  if (new_aubio_tempo("default", hop_size, win_size, samplerate)) return 1;
-    return 1;
   // test null hop_size fails
-  if (new_aubio_tempo("default", win_size, 0, samplerate))
+  if (new_aubio_tempo("default", win_size, 0, samplerate)) return 1;
-    return 1;
   // test 1 buf_size fails
-  if (new_aubio_tempo("default", 1, 1, samplerate))
+  if (new_aubio_tempo("default", 1, 1, samplerate)) return 1;
-    return 1;
   // test null samplerate fails
-  if (new_aubio_tempo("default", win_size, hop_size, 0))
+  if (new_aubio_tempo("default", win_size, hop_size, 0)) return 1;
-    return 1;
   // test short sizes workaround
   t = new_aubio_tempo("default", 2048, 2048, 500);
-  if (!t)
+  if (!t) return 1;
-    return 1;
   del_aubio_tempo(t);
   t = new_aubio_tempo("default", win_size, hop_size, samplerate);
-  if (!t)
+  if (!t) return 1;
-    return 1;
   in = new_fvec(hop_size);
   out = new_fvec(1);

tests/src/temporal/test-filter.c+7−12

@@ -9,17 +9,13 @@ int main (void) · 8 unmodified lines
9		9
10	aubio_filter_t *o = new_aubio_filter_c_weighting (44100);	10	aubio_filter_t *o = new_aubio_filter_c_weighting (44100);
11		11
12	if (new_aubio_filter(0))	12	if (new_aubio_filter(0)) return 1;
13	return 1;
14		13
15	if (aubio_filter_get_samplerate(o) != 44100)	14	if (aubio_filter_get_samplerate(o) != 44100) return 1;
16	return 1;
17		15
18	if (aubio_filter_set_c_weighting (o, -1) == 0)	16	if (aubio_filter_set_c_weighting (o, -1) == 0) return 1;
19	return 1;
20		17
21	if (aubio_filter_set_c_weighting (0, 32000) == 0)	18	if (aubio_filter_set_c_weighting (0, 32000) == 0) return 1;
22	return 1;
23		19
24	in->data[impulse_at] = 0.5;	20	in->data[impulse_at] = 0.5;
25	fvec_print (in);	21	fvec_print (in);
@@ -29,10 +25,9 @@ int main (void) · 3 unmodified lines
29		25
30	o = new_aubio_filter_a_weighting (32000);	26	o = new_aubio_filter_a_weighting (32000);
31		27
32	if (aubio_filter_set_a_weighting (o, -1) == 0)	28	if (aubio_filter_set_a_weighting (o, -1) == 0) return 1;
33	return 1;	29
34	if (aubio_filter_set_a_weighting (0, 32000) == 0)	30	if (aubio_filter_set_a_weighting (0, 32000) == 0) return 1;
35	return 1;
36		31
37	in->data[impulse_at] = 0.5;	32	in->data[impulse_at] = 0.5;
38	fvec_print (in);	33	fvec_print (in);

tests/src/test-delnull.c+0−24

@@ -1,24 +0,0 @@
1	#include <stdlib.h>
2	#include "aubio.h"
3
4	// When creating an aubio object, the user should check whether the object is
5	// set NULL, indicating the creation failed and the object was not allocated.
6
7	int main (void)
8	{
9	uint_t return_code = 0;
10	fvec_t *f = new_fvec(-12);
11	cvec_t *c = new_cvec(-12);
12	lvec_t *l = new_lvec(-12);
13	aubio_fft_t *fft = new_aubio_fft(-12);
14	if (f != NULL) {
15	return_code = 1;
16	} else if (c != NULL) {
17	return_code = 2;
18	} else if (l != NULL) {
19	return_code = 3;
20	} else if (fft != NULL) {
21	return_code = 3;
22	}
23	return return_code;
24	}

Merge branch 'master' into feature/sink_vorbis

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code