source: python/tests/test_phasevoc.py @ 6091189

feature/autosinkfeature/constantqfeature/pitchshiftfeature/pydocstringsfeature/timestretch
Last change on this file since 6091189 was 6091189, checked in by Paul Brossier <piem@piem.org>, 2 years ago

[tests] run phase vocoder with hop_s = win_s

  • Property mode set to 100755
File size: 6.0 KB
Line 
1#! /usr/bin/env python
2
3from numpy.testing import TestCase, assert_equal, assert_array_less
4from aubio import fvec, cvec, pvoc, float_type
5from nose2 import main
6from nose2.tools import params
7import numpy as np
8
9if float_type == 'float32':
10    max_sq_error = 1.e-12
11else:
12    max_sq_error = 1.e-29
13
14def create_sine(hop_s, freq, samplerate):
15    t = np.arange(hop_s).astype(float_type)
16    return np.sin( 2. * np.pi * freq * t / float(samplerate))
17
18def create_noise(hop_s):
19    return np.random.rand(hop_s).astype(float_type) * 2. - 1.
20
21class aubio_pvoc_test_case(TestCase):
22    """ pvoc object test case """
23
24    def test_members_automatic_sizes_default(self):
25        """ check object creation with default parameters """
26        f = pvoc()
27        assert_equal ([f.win_s, f.hop_s], [1024, 512])
28
29    def test_members_unnamed_params(self):
30        """ check object creation with unnamed parameters """
31        f = pvoc(2048, 128)
32        assert_equal ([f.win_s, f.hop_s], [2048, 128])
33
34    def test_members_named_params(self):
35        """ check object creation with named parameters """
36        f = pvoc(hop_s = 128, win_s = 2048)
37        assert_equal ([f.win_s, f.hop_s], [2048, 128])
38
39    def test_zeros(self):
40        """ check the resynthesis of zeros gives zeros """
41        win_s, hop_s = 1024, 256
42        f = pvoc (win_s, hop_s)
43        t = fvec (hop_s)
44        for _ in range( int ( 4 * win_s / hop_s ) ):
45            s = f(t)
46            r = f.rdo(s)
47            assert_equal ( t, 0.)
48            assert_equal ( s.norm, 0.)
49            try:
50                assert_equal ( s.phas, 0 )
51            except AssertionError:
52                assert_equal (s.phas[s.phas > 0], +np.pi)
53                assert_equal (s.phas[s.phas < 0], -np.pi)
54                assert_equal (np.abs(s.phas[np.abs(s.phas) != np.pi]), 0)
55                self.skipTest('pvoc(fvec(%d)).phas != +0, ' % win_s \
56                        + 'This is expected when using fftw3 on powerpc.')
57            assert_equal ( r, 0.)
58
59    def test_no_overlap(self):
60        win_s, hop_s = 1024, 1024
61        f = pvoc (win_s, hop_s)
62        t = fvec (hop_s)
63        for _ in range(4):
64            s = f(t)
65            r = f.rdo(s)
66            assert_equal ( t, 0.)
67
68    @params(
69            ( 256, 8),
70            ( 256, 4),
71            ( 256, 2),
72            ( 512, 8),
73            ( 512, 4),
74            ( 512, 2),
75            #( 129, 2),
76            #( 320, 4),
77            #(  13, 8),
78            (1024, 8),
79            (1024, 4),
80            (1024, 2),
81            (2048, 8),
82            (2048, 4),
83            (2048, 2),
84            (4096, 8),
85            (4096, 4),
86            (4096, 2),
87            (8192, 8),
88            (8192, 4),
89            (8192, 2),
90            )
91    def test_resynth_steps_noise(self, hop_s, ratio):
92        """ check the resynthesis of a random signal is correct """
93        sigin = create_noise(hop_s)
94        self.reconstruction(sigin, hop_s, ratio)
95
96    @params(
97            (44100,  256, 8,   441),
98            (44100,  256, 4,  1203),
99            (44100,  256, 2,  3045),
100            (44100,  512, 8,   445),
101            (44100,  512, 4,   445),
102            (44100,  512, 2,   445),
103            (44100, 1024, 8,   445),
104            (44100, 1024, 4,   445),
105            (44100, 1024, 2,   445),
106            ( 8000, 1024, 2,   445),
107            (22050, 1024, 2,   445),
108            (22050,  256, 8,   445),
109            (96000, 1024, 8, 47000),
110            (96000, 1024, 8,    20),
111            )
112    def test_resynth_steps_sine(self, samplerate, hop_s, ratio, freq):
113        """ check the resynthesis of a sine is correct """
114        sigin = create_sine(hop_s, freq, samplerate)
115        self.reconstruction(sigin, hop_s, ratio)
116
117    def reconstruction(self, sigin, hop_s, ratio):
118        buf_s = hop_s * ratio
119        f = pvoc(buf_s, hop_s)
120        zeros = fvec(hop_s)
121        r2 = f.rdo( f(sigin) )
122        for _ in range(1, ratio):
123            r2 = f.rdo( f(zeros) )
124        # compute square errors
125        sq_error = (r2 - sigin)**2
126        # make sure all square errors are less than desired precision
127        assert_array_less(sq_error, max_sq_error)
128
129class aubio_pvoc_strange_params(TestCase):
130
131    def test_win_size_short(self):
132        with self.assertRaises(RuntimeError):
133            pvoc(1, 1)
134
135    def test_hop_size_long(self):
136        with self.assertRaises(RuntimeError):
137            pvoc(1024, 1025)
138
139    def test_large_input_timegrain(self):
140        win_s = 1024
141        f = pvoc(win_s)
142        t = fvec(win_s + 1)
143        with self.assertRaises(ValueError):
144            f(t)
145
146    def test_small_input_timegrain(self):
147        win_s = 1024
148        f = pvoc(win_s)
149        t = fvec(1)
150        with self.assertRaises(ValueError):
151            f(t)
152
153    def test_large_input_fftgrain(self):
154        win_s = 1024
155        f = pvoc(win_s)
156        s = cvec(win_s + 5)
157        with self.assertRaises(ValueError):
158            f.rdo(s)
159
160    def test_small_input_fftgrain(self):
161        win_s = 1024
162        f = pvoc(win_s)
163        s = cvec(16)
164        with self.assertRaises(ValueError):
165            f.rdo(s)
166
167class aubio_pvoc_wrong_params(TestCase):
168
169    def test_wrong_buf_size(self):
170        win_s = -1
171        with self.assertRaises(ValueError):
172            pvoc(win_s)
173
174    def test_buf_size_too_small(self):
175        win_s = 1
176        with self.assertRaises(RuntimeError):
177            pvoc(win_s)
178
179    def test_hop_size_negative(self):
180        win_s = 512
181        hop_s = -2
182        with self.assertRaises(ValueError):
183            pvoc(win_s, hop_s)
184
185    def test_hop_size_too_small(self):
186        win_s = 1
187        hop_s = 1
188        with self.assertRaises(RuntimeError):
189            pvoc(win_s, hop_s)
190
191    def test_buf_size_not_power_of_two(self):
192        win_s = 320
193        hop_s = win_s // 2
194        try:
195            with self.assertRaises(RuntimeError):
196                pvoc(win_s, hop_s)
197        except AssertionError:
198            # when compiled with fftw3, aubio supports non power of two fft sizes
199            self.skipTest('creating aubio.pvoc with size %d did not fail' % win_s)
200
201if __name__ == '__main__':
202    main()
203
Note: See TracBrowser for help on using the repository browser.