def test_bandpass_gammatone(self): # check real valued output sig = audio.Signal(1, 1, 48000).add_tone(500) sig2 = sig.copy() sig.bandpass(500, 100, 'gammatone') assert not np.iscomplexobj(sig) assert sig.shape == sig2.shape # check complex output sig = audio.Signal(1, 1, 48000).add_tone(500) sig2 = sig.copy() sig.bandpass(500, 100, 'gammatone', return_complex=True) assert np.iscomplexobj(sig) assert sig.shape == sig2.shape # check equivalence of real and complex results sig = audio.Signal(1, 1, 48000).add_tone(500) sig2 = sig.copy() sig.bandpass(500, 100, 'gammatone') sig2.bandpass(500, 100, 'gammatone', return_complex=True) testing.assert_array_equal(sig2.real, sig) # check kwargs sig = audio.Signal(1, 1, 48000).add_tone(500) out = audio.filter.gammatone(sig, 500, 100, sig2.fs, order=2, attenuation_db=-1) sig.bandpass(500, 100, 'gammatone', order=2, attenuation_db=-1) testing.assert_array_equal(sig, out.real)
def test_gammatone(self): # Tone located at center frequency sig = audio.Signal(1, 1, 48000).add_tone(500) out = filter.gammatone(sig, 500, 75, 48000, order=4, attenuation_db=-3) testing.assert_almost_equal(out.real.std(), 1 / np.sqrt(2), 2) # Tone located at -3dB frequency sig = audio.Signal(2, 1, 48000).add_tone(400) out = filter.gammatone(sig, 500, 200, 48000, order=4, attenuation_db=-3) testing.assert_almost_equal(out.real.std(), 0.5, 2) # Test Multichannel sig = audio.Signal((2, 2), 1, 48000).add_tone(400) out = filter.gammatone(sig, 500, 200, 48000, order=4, attenuation_db=-3) testing.assert_almost_equal(out.real.std(), 0.5, 2) assert (sig.shape == out.shape)
def test_calc_coherence(self): cf = 500 bw = 100 sig = audio.Signal(2, 100, 48000).add_noise().bandpass(cf, bw, 'brickwall') coh = audio.calc_coherence(sig) # Analytic coherence for aboves signal coh_analytic = (np.sin(np.pi * bw * sig.time[1:]) / (np.pi * bw * sig.time[1:]) * np.exp(1j * 2 * np.pi * cf * sig.time[1:])) assert isinstance(coh, audio.Signal) testing.assert_almost_equal(np.abs(coh[coh.time==0]), 1) nsamp = 1000 start = np.where(coh.time == 0)[0][0] testing.assert_allclose(coh[start+1:start + nsamp], coh_analytic[:nsamp-1], rtol=0, atol=0.03) # calculate auto-coherrence coh2 = audio.calc_coherence(sig.ch[0]) testing.assert_array_equal(coh, coh2) # test using numpy arrays sig = np.asarray(sig) coh3 = audio.calc_coherence(sig) testing.assert_array_equal(coh3, coh) cf = 500 bw = 100 sig = audio.Signal(2, 100, 48000).add_uncorr_noise(0.5).bandpass(cf, bw, 'brickwall') coh = audio.calc_coherence(sig) testing.assert_allclose(coh.abs()[coh.time==0], 0.5, rtol=0.05)
def test_timeshift(self): #timeshift a tone by one full phase sig = audio.Signal(2, 1, 48000).add_tone(100) sig[:, 1] = sig[:, 1].to_freqdomain().time_shift(1. / 100).to_timedomain() testing.assert_almost_equal(sig[:, 1], sig[:, 0]) shift_samples = 500 shift_time = shift_samples / 48000 sig = audio.Signal(2, 1, 48000).add_noise() sig[:, 1] = sig[:, 1].to_freqdomain().time_shift(shift_time).to_timedomain() testing.assert_almost_equal(sig[shift_samples:, 1], sig[:-shift_samples, 0]) shift_time = 3.2e-4 sig = audio.Signal(2, 1.000, 48000).add_noise() res = sig[:, 1].to_freqdomain().time_shift(shift_time).to_timedomain() assert np.all(np.isreal(res)) shift_time = 3.2e-4 sig = audio.Signal((2, 2), 1.000, 48000).add_noise() res = sig[:, 1].to_freqdomain().time_shift(shift_time).to_timedomain() assert np.all(np.isreal(res))
def test_zeropad(self): signal = audio.generate_tone(1, 1, 1e3) buffered = audio.zeropad(signal, 10) assert len(buffered) - len(signal) == 20 assert np.array_equal(buffered[:10], buffered[-10:]) assert np.array_equal(buffered[:10], np.zeros(10)) buffered = audio.zeropad(signal, 0) assert len(buffered) == len(signal) # Test multichannel signal signal = audio.generate_tone(1, 1, 1e3) mc_signal = np.column_stack([signal, signal]) mc_buffered = audio.zeropad(mc_signal, 10) assert np.array_equal(mc_buffered[:10, 0], mc_buffered[-10:, 1]) # Test different start and end zeros signal = audio.generate_tone(1, 1, 1e3) mc_signal = np.column_stack([signal, signal]) mc_buffered = audio.zeropad(mc_signal, (10, 5)) assert np.all(mc_buffered[:10] == 0) assert np.all(mc_buffered[-5:] == 0) sig = audio.Signal(2, 1, 1) sig[:] = 1 zpsig = audio.zeropad(sig, [2, 2]) assert zpsig.shape == (5, 2) sig = audio.Signal((2, 3), 1, 1) sig[:] = 1 zpsig = audio.zeropad(sig, [2, 2]) assert zpsig.shape == (5, 2, 3)
def test_plot(self): sig = audio.Signal(2, 1, 48000).add_noise() fig, ax = sig.plot() assert len(ax.lines) == sig.n_channels # Test for the correct colors in case of two channels assert ax.lines[0].get_color() == '#5c5cd6' assert ax.lines[1].get_color() == '#d65c5c'
def test_butterworth(self): fc = [100, 200, 5000] bw = [10, 5, 8] fs = 48000 butter = create_filterbank(fc, bw, 'butter', fs) for i_filt, (fc, bw) in enumerate(zip(fc, bw)): low_f = fc - bw / 2 high_f = fc + bw / 2 sos = butterworth_filt.design_butterworth(low_f, high_f, fs) coeff = butter.coefficents[:, :, i_filt] testing.assert_array_equal(sos, coeff) # Test filter gain sig = audio.Signal(1, 1, 48000) fc = np.round(audio.freqarange(100, 4000, 1, 'erb')) bw = audio.calc_bandwidth(fc, 'erb') # add a tone at every fc for f in fc: sig.add_tone(f) # create filterbank an run signal bank = create_filterbank(fc, bw, 'butter', 48000) sig_out = bank.filt(sig) #check amplitudes at fc of every filter amps = np.zeros(len(fc)) for i_fc, f in enumerate(fc): spec = sig_out.ch[i_fc].to_freqdomain() amps[i_fc] = np.abs(spec[spec.freq==f]) # Amplitudes should be 0.5 (two sided spectrum) assert np.all((amps - 0.5) <= 0.01)
def test_gammatone(self): # Test if filter coefficents are equivalent tho those of # individual filters fc = [100, 200, 5000] bw = [10, 5, 8] fs = 48000 gamma = create_filterbank(fc, bw, 'gammatone', fs) for i_filt, (fc, bw) in enumerate(zip(fc, bw)): b, a = gammatone_filt.design_gammatone(fc, bw, fs) b_bank = gamma.coefficents[0, i_filt] a_bank = gamma.coefficents[2:, i_filt] testing.assert_array_equal(a, a_bank) testing.assert_array_equal(b, b_bank) # Test the gain at fc sig = audio.Signal(1, 1, 48000) fc = np.round(audio.freqarange(100, 4000, 1, 'erb')) bw = audio.calc_bandwidth(fc, 'erb') # add a tone at every fc for f in fc: sig.add_tone(f) # create filterbank an run signal bank = create_filterbank(fc, bw, 'gammatone', 48000) sig_out = bank.filt(sig) #check amplitudes at fc of every filter amps = np.zeros(len(fc)) for i_fc, f in enumerate(fc): spec = sig_out.ch[i_fc].to_freqdomain() amps[i_fc] = np.abs(spec[spec.freq==f]) # Amplitudes hould be 1 (one sided spectrum) assert np.all((amps - 1) <= 0.01)
def test_bandpass(self): sig = audio.Signal(1, 1, 48000).add_noise() sig_out = audio.filter.bandpass(sig, 500, 100, 'gammatone') sig_out2 = audio.filter.gammatone(sig, 500, 100, 48000) testing.assert_array_equal(sig_out, sig_out2) sig = audio.Signal(1, 1, 48000).add_noise() sig_out = audio.filter.bandpass(sig, 500, 100, 'butter') sig_out2 = audio.filter.butterworth(sig, 450, 550, 48000) testing.assert_array_equal(sig_out, sig_out2) sig = audio.Signal(1, 1, 48000).add_noise() sig_out = audio.filter.bandpass(sig, 500, 100, 'brickwall') sig_out2 = audio.filter.brickwall(sig, 450, 550, 48000) testing.assert_array_equal(sig_out, sig_out2)
def test_duration_is_signal(self): #direct input duration, fs, n_ch = audio.audiotools._duration_is_signal(1, 2, 3) assert duration == 1 assert fs == 2 assert n_ch == 3 duration, fs, n_ch = audio.audiotools._duration_is_signal(1, 2) assert duration == 1 assert fs == 2 assert n_ch == None #signal as input sig = audio.Signal((2, 3), 1, 2) duration, fs, n_ch = audio.audiotools._duration_is_signal(sig) assert duration == 1 assert fs == 2 assert n_ch == (2, 3) #Numpy array as input sig = np.zeros((11, 2, 3)) duration, fs, n_ch = audio.audiotools._duration_is_signal(sig, 3) assert duration == 11 / 3 assert fs == 3 assert n_ch == (2, 3)
def test_gauss_fade_window(self): window = audio.gaussian_fade_window(np.zeros(1000), 100e-3, 1e3) n_window = 100 #test symmentry assert np.array_equal(window[:100], window[-100:][::-1]) #test starts at -60dB testing.assert_almost_equal(window[0], 0.001) #test setting cutoff window = audio.gaussian_fade_window(np.zeros(1000), 100e-3, 1e3, cutoff=-20) testing.assert_almost_equal(window[0], 0.1) # Test that the last sample in the window is not equal to 1 nsamp = audio.nsamples(200e-3, 1e3) window = audio.gaussian_fade_window(np.zeros(nsamp + 1), 100e-3 , 1e3) n_window = 100 assert window[int(nsamp / 2)] == 1 assert window[int(nsamp / 2 - 1)] != 1 assert window[int(nsamp / 2 + 1)] != 1 assert window[int(nsamp / 2 + 1)] == window[int(nsamp / 2 - 1)] # Test multichannel window window = audio.gaussian_fade_window(np.zeros([1000, 2]), 100e-3, 1e3) assert np.array_equal(window[:, 0], window[:, 1]) assert np.array_equal(window[:100, 0], window[-100:, 0][::-1]) sig = audio.Signal((2, 3), 1, 48000) win = audio.gaussian_fade_window(sig, 100e-3) assert win.shape == sig.shape testing.assert_array_equal (win[:, 1, 0], win[:, 0, 1])
def test_highpass(self): types = ['brickwall', 'butter'] f_cut = 300 for ftype in types: sig = audio.Signal(2, 1, 48000).add_noise() sig2 = audio.filter.highpass(sig, f_cut, ftype) sig.highpass(f_cut, ftype) testing.assert_array_equal(sig, sig2)
def test_nsamples(self): duration = 1 fs = 10 assert audio.nsamples(duration, fs) == 10 # test for directly using signal class sig = audio.Signal(1, 1, 10) assert audio.nsamples(sig) == 10
def test_highpass(self): sig = audio.Signal(1, 1, 48000).add_noise() sig_out = audio.filter.highpass(sig, 500, 'butter') sig_out2 = audio.filter.butterworth(sig, 500, None, 48000) testing.assert_array_equal(sig_out, sig_out2) sig_out = audio.filter.highpass(sig, 500, 'brickwall') sig_out2 = audio.filter.brickwall(sig, 500, None, 48000) testing.assert_array_equal(sig_out, sig_out2)
def test_bandpass_brickwall(self): sig = audio.Signal((2, 2), 1, 48000) sig.add_noise().bandpass(500, 100, 'brickwall') sig = sig.to_freqdomain() testing.assert_array_almost_equal(sig[np.abs(sig.freq) > 550], 0) testing.assert_array_almost_equal(sig[np.abs(sig.freq) < 450], 0) assert np.all(sig[(np.abs(sig.freq) < 550) & (np.abs(sig.freq) > 450)] != 0)
def test_low_noise_noise(self): noise = audio.generate_low_noise_noise(1, 500, 200, fs=48000) assert noise.shape == (48000,) # test directly using signal sig = audio.Signal((2, 3), 1, 48000) noise = audio.generate_low_noise_noise(sig, 500, 200, n_rep=10) assert noise.shape == (48000, 2, 3) testing.assert_array_equal(noise[:, 0, :], noise[:, 1, :]) testing.assert_array_equal(noise[:, :, 0], noise[:, :, 1])
def test_writewav_readwav(self): """Test invertability of readwav and writewav""" fs = 41200 signal = audio.Signal(2, 2, fs) signal[:] = np.linspace(-1, 1, signal.n_samples)[:, None] bitdepth = [8, 16] for bd in bitdepth: wav.writewav('test.wav', signal, signal.fs, bd) out8, fs = wav.readwav('test.wav') testing.assert_allclose(out8, signal, atol=2 / 2**bd, rtol=1)
def test_cos_amp_modulator(self): fs = 100e3 signal = audio.generate_tone(1, 100, fs) mod = audio.cos_amp_modulator(signal, 5, fs) test = audio.generate_tone(1, 5, fs) testing.assert_array_almost_equal(mod, test + 1) assert max(mod) == 2.0 mod = audio.cos_amp_modulator(signal, 5, fs, 0.5) assert mod[0] == 1.5 mod = audio.cos_amp_modulator(signal, 5, fs, start_phase=np.pi) test = audio.generate_tone(1, 5, fs, start_phase=np.pi) testing.assert_array_almost_equal(mod, test + 1) sig = audio.Signal(1, 1, 48000).add_tone(5) + 1 mod = audio.cos_amp_modulator(sig, 5, 1) testing.assert_array_equal(sig, mod) sig = audio.Signal((2, 3), 1, 48000).add_tone(5) + 1 mod = audio.cos_amp_modulator(sig, 5, 1)
def test_analytical(self): sig = audio.Signal(2, 1, 48000).add_noise() fsig = sig.to_freqdomain() fsig.to_analytical() # All but the niquist bin should be zero testing.assert_array_equal(fsig[fsig.freq < 0][1:], 0) asig = fsig.to_timedomain() testing.assert_almost_equal(asig.real, sig) sig = audio.Signal(1, 0.1, 48000).add_tone(500) sig2 = audio.Signal(1, 0.1, 48000).add_tone(500, start_phase=-np.pi / 2) fsig = sig.to_freqdomain() fsig.to_analytical() asig = fsig.to_timedomain() testing.assert_almost_equal(asig.imag, sig2) testing.assert_almost_equal(asig.real, sig) sig = audio.Signal((2, 2), 1, 48000).add_noise() fsig = sig.to_freqdomain() fsig.to_analytical() asig = fsig.to_timedomain() testing.assert_almost_equal(asig.real, sig)
def test_phaseshift(self): #phase shifting a full period sig = audio.Signal(2, 1, 48000).add_tone(100) sig[:, 1] = sig[:, 1].to_freqdomain().phase_shift(2 * np.pi).to_timedomain() testing.assert_almost_equal(sig[:, 1], sig[:, 0]) # phase shifting half a period sig = audio.Signal(2, 1, 48000) sig[:, 0].add_tone(100, start_phase=-0.5 * np.pi) sig[:, 1].add_tone(100) sig[:, 1] = sig[:, 1].to_freqdomain().phase_shift( 0.5 * np.pi).to_timedomain() testing.assert_almost_equal(sig[:, 1], sig[:, 0]) # phase shifting half a period sig = audio.Signal((2, 2), 1, 48000) sig[:, :, 0].add_tone(100, start_phase=-0.5 * np.pi) sig[:, :, 1].add_tone(100) sig[:, :, 1] = sig[:, :, 1].to_freqdomain().phase_shift( 0.5 * np.pi).to_timedomain() testing.assert_almost_equal(sig[:, :, 1], sig[:, :, 0])
def test_generate_tone(self): # test frequency, sampling rate and duration tone1 = audio.generate_tone(1, 1, 1e3) tone2 = audio.generate_tone(0.5, 2, 2e3) assert np.array_equal(tone1, tone2) # test phaseshift tone = audio.generate_tone(1, 1, 1e3, start_phase=np.pi / 2) testing.assert_almost_equal(tone[0], 0) tone = audio.generate_tone(1, 1, 1e3, start_phase=1 * np.pi) testing.assert_almost_equal(tone[0], -1) sig = audio.Signal((2, 3), 1, 48000).add_tone(50) tone = audio.generate_tone(sig, 50) testing.assert_array_equal(sig, tone)
def test_brickwall(self): # Test the gain at fc sig = audio.Signal(1, 1, 48000) fc = np.round(audio.freqarange(100, 4000, 1, 'erb')) bw = audio.calc_bandwidth(fc, 'erb') # add a tone at every fc for f in fc: sig.add_tone(f) # create filterbank an run signal bank = create_filterbank(fc, bw, 'brickwall', 48000) sig_out = bank.filt(sig) #check amplitudes at fc of every filter amps = np.zeros(len(fc)) for i_fc, f in enumerate(fc): spec = sig_out.ch[i_fc].to_freqdomain() amps[i_fc] = np.abs(spec[spec.freq==f]) # Amplitudes hould be 0.5 (double sided spectrum) assert np.all((amps - 0.5) <= 0.01)
def test_generate_noise(self): duration = 1 fs = 100e3 noise = audio.generate_noise(duration, fs) assert len(noise) == audio.nsamples(duration, fs) assert np.ndim(noise) == 1 # Test for whole spectrum spec = np.fft.fft(noise) assert np.all(~np.isclose(np.abs(spec)[1:], 0)) testing.assert_almost_equal(np.abs(spec[0]), 0) testing.assert_almost_equal(np.var(noise), 1) # # Test no offset testing.assert_almost_equal(noise.mean(), 0) # test seed noise1 = audio.generate_noise(duration, fs, seed=1) noise2 = audio.generate_noise(duration, fs, seed=1) noise3 = audio.generate_noise(duration, fs, seed=2) testing.assert_equal(noise1, noise2) assert ~np.all(noise1 == noise3) # test directly handing over signal sig = audio.Signal((2, 3), 1, 10) noise = audio.generate_noise(sig) assert noise.shape == (10, 2, 3) testing.assert_array_equal(noise[:, 0, :], noise[:, 1, :]) testing.assert_array_equal(noise[:, :, 0], noise[:, :, 1]) # test directly handing over signal noise = audio.generate_noise(1, 10, n_channels=(2, 3)) assert noise.shape == (10, 2, 3) testing.assert_array_equal(noise[:, 0, :], noise[:, 1, :]) testing.assert_array_equal(noise[:, :, 0], noise[:, :, 1]) # test multichannel noise = audio.generate_noise(1, 10, n_channels=(2, 3), ntype='pink') assert noise.shape == (10, 2, 3) testing.assert_array_equal(noise[:, 0, :], noise[:, 1, :]) testing.assert_array_equal(noise[:, :, 0], noise[:, :, 1])
def test_writewav(self): """Test invertability of readwav and writewav""" fs = 41200 signal = audio.Signal(2, 2, fs) signal[:] = np.linspace(-1, 1, signal.n_samples)[:, None] bitdepth = [8, 16, 32] for bd in bitdepth: wav.writewav('test.wav', signal, signal.fs, bd) self.assertRaises(ValueError, wav.writewav, filename='test.wav', signal=signal, fs=signal.fs, bitdepth=7) self.assertRaises(ValueError, wav.writewav, filename='test.wav', signal=signal, fs=signal.fs, bitdepth=64)
def test_cosine_fade_window(self): window = audio.cosine_fade_window(np.zeros(1000), 100e-3, 1e3) n_window = 100 #test symmentry assert np.array_equal(window[:100], window[-100:][::-1]) #test starts with 0 assert window[0] == 0 window = audio.cosine_fade_window(np.zeros(1000), 100e-3, 1e3) n_window = 100 #test if the window is a cosine curve of the right type cos_curve = np.concatenate([window[:100], window[-101:]]) sin = (0.5 * audio.generate_tone(0.2 + 1. / 1e3, 5, 1e3, start_phase=np.pi)) + 0.5 testing.assert_array_almost_equal(cos_curve, sin) # Test that the last sample in the window is not equal to 1 nsamp = audio.nsamples(200e-3, 1e3) window = audio.cosine_fade_window(np.zeros(nsamp + 1), 100e-3 , 1e3) n_window = 100 assert window[int(nsamp / 2)] == 1 assert window[int(nsamp / 2 - 1)] != 1 assert window[int(nsamp / 2 + 1)] != 1 assert window[int(nsamp / 2 + 1)] == window[int(nsamp / 2 - 1)] # Test multichannel window window = audio.cosine_fade_window(np.zeros([1000, 2]), 100e-3, 1e3) assert np.array_equal(window[:, 0], window[:, 1]) assert np.array_equal(window[:100, 0], window[-100:, 0][::-1]) sig = audio.Signal((2, 3), 1, 48000) win = audio.cosine_fade_window(sig, 100e-3) assert win.shape == sig.shape testing.assert_array_equal (win[:, 1, 0], win[:, 0, 1])
def to_timedomain(self): """Convert to timedomain. Convert to timedomain by means of inverse DFT. If the complex part after DFT is small (< 222e-16), it is neglected. This method is not applied in-place but a new :meth:'audiotools.Signal' object is returned Returns: -------- The timedomain representation: Signal """ # revert normalization self *= self.n_samples wv = np.fft.ifft(self, axis=0) wv = np.real_if_close(wv) signal = audio.Signal(self.n_channels, self.duration, self.fs, dtype=wv.dtype) signal[:] = wv return signal
def test_butterworth_filt(self): # Test Lowpass sig = audio.Signal(10, 1, 48000).add_tone(500) sig_out = filter.butterworth(sig, None, 500, 48000) testing.assert_almost_equal(sig_out[:].std(), 0.5, 3) sig = audio.Signal(1, 1, 48000).add_tone(400) sig_out = filter.butterworth(sig, None, 500, 48000) assert sig_out[:].std() > 0.5 sig = audio.Signal(1, 1, 48000).add_tone(600) sig_out = filter.butterworth(sig, None, 500, 48000) assert sig_out[:].std() < 0.5 # test Highpass sig = audio.Signal(1, 1, 48000).add_tone(500) sig_out = filter.butterworth(sig, 500, None, 48000) testing.assert_almost_equal(sig_out[:].std(), 0.5, 3) sig = audio.Signal(1, 1, 48000).add_tone(400) sig_out = filter.butterworth(sig, 500, None, 48000) assert sig_out[:].std() < 0.5 sig = audio.Signal(1, 1, 48000).add_tone(600) sig_out = filter.butterworth(sig, 500, None, 48000) assert sig_out[:].std() > 0.5 sig = audio.Signal(1, 1, 48000).add_tone(500) sig_out = filter.butterworth(sig, 400, 600, 48000) testing.assert_almost_equal(sig_out[:].std(), 1 / np.sqrt(2), 3) sig = audio.Signal(1, 1, 48000).add_tone(400) sig_out = filter.butterworth(sig, 400, 600, 48000) testing.assert_almost_equal(sig_out[:].std(), 0.5, 3) sig = audio.Signal(1, 1, 48000).add_tone(600) sig_out = filter.butterworth(sig, 400, 600, 48000) testing.assert_almost_equal(sig_out[:].std(), 0.5, 3) sig = audio.Signal((2, 3), 1, 48000).add_tone(500) sig_out = filter.butterworth(sig, 400, 600, 48000) testing.assert_almost_equal(np.std(sig_out, axis=0), 1 / np.sqrt(2), 3) sig = audio.Signal((2, 3), 1, 48000).add_tone(400) sig_out = filter.butterworth(sig, 400, 600, 48000) testing.assert_almost_equal(np.std(sig_out, axis=0), 0.5, 3)
def test_bandpass_butterworth(self): sig = audio.Signal(1, 1, 48000).add_noise() sig2 = audio.filter.butterworth(sig, 100, 300) sig = sig.bandpass(200, 200, 'butter') testing.assert_array_equal(sig, sig2)
def test_analytical(self): sig = audio.Signal((2, 2), 1, 48000).add_noise() asig = sig.to_analytical() testing.assert_almost_equal(sig, asig.real)
def test_calc_dbspl(self): assert audio.calc_dbspl(2e-3) == 40 assert audio.calc_dbspl(20e-6) == 0 sig = audio.Signal(1, 1, 48000).add_tone(500) l_tone = 20*np.log10(np.sqrt(0.5) / 20e-6) assert audio.calc_dbspl(sig) == l_tone