update 33
This commit is contained in:
parent
c678fe4512
commit
d41df7f132
18 changed files with 462 additions and 260 deletions
138
lib/__init__.py
138
lib/__init__.py
|
|
@ -12,141 +12,13 @@ from .bs import *
|
|||
from .cepstrum import *
|
||||
from .windowing import *
|
||||
from .piir import *
|
||||
|
||||
import numpy as np
|
||||
|
||||
def analog(b, a):
|
||||
import sympy as sym
|
||||
w,s = sym.symbols('w s')
|
||||
filt_expr = sym.Poly(b, s)/sym.Poly(a, s)
|
||||
mag_expr = abs(filt_expr.subs({s: w*sym.I}))**2
|
||||
return sym.lambdify(w, mag_expr, 'numpy')
|
||||
|
||||
def makemag(w0, ba, gain=0):
|
||||
f = analog(*ba)
|
||||
def magf(w):
|
||||
a = f(w/w0)
|
||||
a[0] = 1e-35
|
||||
a = np.log10(a)*10 + gain
|
||||
a[0] = a[1] # safety measure
|
||||
return a
|
||||
return magf
|
||||
|
||||
def test_filter_raw(ba, fc=1000, gain=0, precision=4096):
|
||||
fig, ax = new_response(ymin=-24, ymax=24)
|
||||
xs = xsp(precision)
|
||||
ax.semilogx(xs, makemag(fc, ba, gain)(xs))
|
||||
|
||||
def test_filter(ff, A=toA(12), Q=toQ(1), **kwargs):
|
||||
test_filter_raw(ff(A, Q), **kwargs)
|
||||
|
||||
def neonpink(xs):
|
||||
lament("neonpink(): DEPRECATED; use tilter2(xs, 'raw') instead.")
|
||||
return tilter2(xs, 'raw')
|
||||
|
||||
def c_render(cascade, precision=4096):
|
||||
# TODO: deprecate in favor of tilter2
|
||||
xs = xsp(precision)
|
||||
return xs, tilter2(xs, cascade)
|
||||
|
||||
def c_render2(xs, cascade, phase=False):
|
||||
"""c_render optimized and specifically for first/second-order filters"""
|
||||
if phase:
|
||||
return c_render3(xs, cascade, mode='phase')
|
||||
else:
|
||||
return c_render3(xs, cascade, mode='magnitude')
|
||||
|
||||
def c_render3(xs, cascade, mode='magnitude'):
|
||||
"""c_render optimized and specifically for first/second-order filters"""
|
||||
import numexpr as ne
|
||||
j = np.complex(0, 1)
|
||||
|
||||
# obviously this could be extended to higher orders
|
||||
eq2 = '(b0 + b1*s + b2*s**2)/(a0 + a1*s + a2*s**2)'
|
||||
eq1 = '(b0 + b1*s)/(a0 + a1*s)'
|
||||
|
||||
if mode == 'magnitude':
|
||||
fmt = 'real(log10(abs({})**2)*10 + gain)'
|
||||
elif mode == 'phase' or mode == 'group delay':
|
||||
fmt = '-arctan2(imag({0}), real({0}))' # gross
|
||||
else:
|
||||
raise Exception("c_render3(): unknown mode: {}".format(mode))
|
||||
|
||||
ys = np.zeros(len(xs))
|
||||
for f in cascade:
|
||||
freq, ba, gain = f
|
||||
b, a = ba
|
||||
if len(b) == 3 and len(a) == 3:
|
||||
eq = fmt.format(eq2)
|
||||
b2, b1, b0 = b
|
||||
a2, a1, a0 = a
|
||||
elif len(b) == 2 and len(a) == 2:
|
||||
eq = fmt.format(eq1)
|
||||
b1, b0 = b
|
||||
a1, a0 = a
|
||||
else:
|
||||
raise Exception("incompatible cascade; consider using c_render instead")
|
||||
|
||||
if mode == 'group delay':
|
||||
# approximate derivative of phase by slope of tangent line
|
||||
step = 2**-8
|
||||
fa = freq - step
|
||||
fb = freq + step
|
||||
|
||||
s = xs/fa*j
|
||||
ya = ne.evaluate(eq)
|
||||
s = xs/fb*j
|
||||
yb = ne.evaluate(eq)
|
||||
|
||||
slope = (yb - ya)/(2*step)
|
||||
ys += -slope/(xs/freq*tau)
|
||||
else:
|
||||
s = xs/freq*j
|
||||
ys += ne.evaluate(eq)
|
||||
if mode == 'phase':
|
||||
ys = degrees_clamped(ys)
|
||||
return ys
|
||||
|
||||
def firize(xs, ys, n=4096, srate=44100, ax=None):
|
||||
import scipy.signal as sig
|
||||
if ax:
|
||||
ax.semilogx(xs, ys, label='desired')
|
||||
xf = xs/srate*2
|
||||
yg = 10**(ys/20)
|
||||
|
||||
xf = np.r_[0, xf, 1]
|
||||
yg = np.r_[0, yg, yg[-1]]
|
||||
|
||||
b = sig.firwin2(n, xf, yg, antisymmetric=True)
|
||||
|
||||
if ax:
|
||||
_, ys = sig.freqz(b, worN=xs/srate*tau)
|
||||
ys = 20*np.log10(np.abs(ys))
|
||||
ax.semilogx(xs, ys, label='FIR ({} taps)'.format(n))
|
||||
ax.legend(loc=8)
|
||||
|
||||
return b
|
||||
|
||||
def tilter(xs, ys, tilt):
|
||||
"""tilts a magnitude plot by some decibels, or by equalizer curve."""
|
||||
lament("tilter(): DEPRECATED; use ys -= tilter2(xs, tilt) instead.")
|
||||
return xs, ys - tilter2(xs, tilt)
|
||||
|
||||
def tilter2(xs, tilt): # TODO: rename
|
||||
noise = np.zeros(xs.shape)
|
||||
if isinstance(tilt, str) and tilt in cascades:
|
||||
tilt = cascades[tilt]
|
||||
if isinstance(tilt, list):
|
||||
c = [makemag(*f) for f in tilt]
|
||||
for f in c:
|
||||
noise += f(xs)
|
||||
elif isinstance(tilt, int) or isinstance(tilt, float):
|
||||
noise = tilt*(np.log2(1000) - np.log2(xs + 1e-35))
|
||||
return noise
|
||||
|
||||
from .mag import *
|
||||
from .plotwav import *
|
||||
|
||||
|
||||
# this is similar to default behaviour of having no __all__ variable at all,
|
||||
# but ours ignores modules as well. this allows for `import sys` and such
|
||||
# without clobbering `from our_module import *`.
|
||||
__all__ = [o for o in locals() if type(o) != 'module' and not o.startswith('_')]
|
||||
__all__ = [
|
||||
o for o in locals()
|
||||
if type(o) != 'module' and not o.startswith('_')]
|
||||
|
|
|
|||
92
lib/bq.py
92
lib/bq.py
|
|
@ -4,39 +4,79 @@ import scipy.signal as sig
|
|||
from .util import *
|
||||
from .planes import s2z
|
||||
|
||||
bq_run = lambda bq, xs: sig.lfilter(*bq, x=xs, axis=0)
|
||||
|
||||
nfba = lambda b, a: (1/tau, (b, a), 0)
|
||||
nf = lambda t, f, g, bw, mg: (f, t(toA(g), toQ(bw)), mg)
|
||||
# PEP 8 fucking destroyed this file. I'm sorry.
|
||||
|
||||
|
||||
def bq_run(bq, xs):
|
||||
return sig.lfilter(*bq, x=xs, axis=0)
|
||||
|
||||
|
||||
def nfba(b, a):
|
||||
return (1/tau, (b, a), 0)
|
||||
|
||||
|
||||
def nf(t, f, g, bw, mg):
|
||||
return (f, t(toA(g), toQ(bw)), mg)
|
||||
|
||||
|
||||
def LP1(A, Q):
|
||||
return ((0, 1), (1, 1))
|
||||
|
||||
|
||||
def HP1(A, Q):
|
||||
return ((1, 0), (1, 1))
|
||||
|
||||
|
||||
def LS1(A, Q):
|
||||
return ((1, A), (1, 1/A))
|
||||
|
||||
|
||||
def HS1(A, Q):
|
||||
return ((A, 1), (1/A, 1))
|
||||
|
||||
LP1 = lambda A, Q: ((0,1),(1,1))
|
||||
HP1 = lambda A, Q: ((1,0),(1,1))
|
||||
LS1 = lambda A, Q: ((1,A),(1,1/A))
|
||||
HS1 = lambda A, Q: ((A,1),(1/A,1))
|
||||
|
||||
# patterns observed, in case some simplification could be done:
|
||||
# a always gets divided by A instead of multiplied
|
||||
# b1 and a1 always /= Q
|
||||
|
||||
LP2 = lambda A, Q: ((0, 0, 1),
|
||||
(1, 1/Q, 1))
|
||||
HP2 = lambda A, Q: ((1, 0, 0),
|
||||
(1, 1/Q, 1))
|
||||
PE2 = lambda A, Q: ((1, A/Q, 1),
|
||||
(1, 1/A/Q, 1))
|
||||
AP2 = lambda A, Q: ((1, -1/Q, 1),
|
||||
(1, 1/Q, 1))
|
||||
BP2a= lambda A, Q: ((0, -A/Q, 0),
|
||||
(1, 1/A/Q, 1))
|
||||
BP2b= lambda A, Q: ((0,-A*A/Q, 0),
|
||||
(1, 1/Q, 1))
|
||||
NO2 = lambda A, Q: ((1, 0, 1),
|
||||
(1, 1/Q, 1))
|
||||
LS2 = lambda A, Q: ((1, np.sqrt(A)/Q, A),
|
||||
(1, 1/np.sqrt(A)/Q, 1/A))
|
||||
HS2 = lambda A, Q: ((A, np.sqrt(A)/Q, 1),
|
||||
(1/A, 1/np.sqrt(A)/Q, 1))
|
||||
def LP2(A, Q):
|
||||
return ((0, 0, 1), (1, 1/Q, 1))
|
||||
|
||||
gen_filters = lambda cascade, srate: [
|
||||
|
||||
def HP2(A, Q):
|
||||
return ((1, 0, 0), (1, 1/Q, 1))
|
||||
|
||||
|
||||
def PE2(A, Q):
|
||||
return ((1, A/Q, 1), (1, 1/A/Q, 1))
|
||||
|
||||
|
||||
def AP2(A, Q):
|
||||
return ((1, -1/Q, 1), (1, 1/Q, 1))
|
||||
|
||||
|
||||
def BP2a(A, Q):
|
||||
return ((0, -A/Q, 0), (1, 1/A/Q, 1))
|
||||
|
||||
|
||||
def BP2b(A, Q):
|
||||
return ((0, -A*A/Q, 0), (1, 1/Q, 1))
|
||||
|
||||
|
||||
def NO2(A, Q):
|
||||
return ((1, 0, 1), (1, 1/Q, 1))
|
||||
|
||||
|
||||
def LS2(A, Q):
|
||||
return ((1, np.sqrt(A)/Q, A), (1, 1/np.sqrt(A)/Q, 1/A))
|
||||
|
||||
|
||||
def HS2(A, Q):
|
||||
return ((A, np.sqrt(A)/Q, 1), (1/A, 1/np.sqrt(A)/Q, 1))
|
||||
|
||||
|
||||
def gen_filters(cascade, srate):
|
||||
return [
|
||||
s2z(*f[1], fc=f[0], srate=srate, gain=10**(f[2]/20)) for f in cascade
|
||||
]
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@ from . import blocks, convolve_each, gen_filters, cascades, bq_run, toLK
|
|||
import numpy as np
|
||||
import matplotlib.pyplot as plt
|
||||
|
||||
|
||||
def BS1770_3(s, srate, filters=None, window=0.4, overlap=0.75,
|
||||
gate=10, absolute_gate=70, detail=False):
|
||||
if filters is None:
|
||||
|
|
@ -10,7 +11,7 @@ def BS1770_3(s, srate, filters=None, window=0.4, overlap=0.75,
|
|||
|
||||
sf = np.copy(s)
|
||||
for f in filters:
|
||||
if len(f) is 2: # dumb but effective
|
||||
if len(f) is 2: # dumb way to tell what type we're given.
|
||||
sf = bq_run(f, sf)
|
||||
else:
|
||||
sf = convolve_each(sf, f, 'same')
|
||||
|
|
@ -35,6 +36,7 @@ def BS1770_3(s, srate, filters=None, window=0.4, overlap=0.75,
|
|||
else:
|
||||
return toLK(avg_g10), toLK(avg_g70), LKs, threshold
|
||||
|
||||
|
||||
def BS_plot(ys, g10=None, g70=None, threshold=None, fig=None, ax=None):
|
||||
if g10:
|
||||
center = np.round(g10)
|
||||
|
|
@ -75,6 +77,7 @@ def BS_plot(ys, g10=None, g70=None, threshold=None, fig=None, ax=None):
|
|||
|
||||
return fig, ax
|
||||
|
||||
|
||||
def normalize(s, srate):
|
||||
"""performs BS.1770-3 normalization and returns inverted gain."""
|
||||
db = BS1770_3(s, srate)
|
||||
|
|
|
|||
|
|
@ -1,12 +1,19 @@
|
|||
import numpy as np
|
||||
from .util import pad2
|
||||
|
||||
# fast cepstrum and inverted fast cepstrum
|
||||
fcs = lambda s: np.fft.ifft(np.log(np.fft.fft(s)))
|
||||
ifcs = lambda s: np.fft.fft(np.exp(np.fft.ifft(s)))
|
||||
|
||||
# magnitude
|
||||
mcs = lambda s: (np.abs(np.fft.ifft(np.log(np.abs(np.fft.fft(s))**2)))**2)[:len(s)//2]
|
||||
def fcs(s): # fast cepstrum
|
||||
return np.fft.ifft(np.log(np.fft.fft(s)))
|
||||
|
||||
|
||||
def ifcs(s): # inverted fast cepstrum
|
||||
return np.fft.fft(np.exp(np.fft.ifft(s)))
|
||||
|
||||
|
||||
def mcs(s): # magnitude
|
||||
return (np.abs(np.fft.ifft(np.log(np.abs(np.fft.fft(s))**2)))**2
|
||||
)[:len(s)//2]
|
||||
|
||||
|
||||
def clipdb(s, cutoff=-100):
|
||||
as_ = np.abs(s)
|
||||
|
|
@ -16,6 +23,7 @@ def clipdb(s, cutoff=-100):
|
|||
thresh = mas*10**(cutoff/20)
|
||||
return np.where(as_ < thresh, thresh, s)
|
||||
|
||||
|
||||
def fold(r):
|
||||
# via https://ccrma.stanford.edu/~jos/fp/Matlab_listing_fold_m.html
|
||||
# Fold left wing of vector in "FFT buffer format" onto right wing
|
||||
|
|
@ -33,6 +41,7 @@ def fold(r):
|
|||
rw = np.r_[r[0], rf, np.zeros(n-nt-1)]
|
||||
return rw
|
||||
|
||||
|
||||
def minphase(s, pad=True, os=False):
|
||||
# via https://ccrma.stanford.edu/~jos/fp/Matlab_listing_mps_m.html
|
||||
# TODO: actual oversampling
|
||||
|
|
|
|||
|
|
@ -14,6 +14,7 @@ cascades = {
|
|||
(1501, HS2(toA(4), toQ(1)), 0),
|
||||
(38.135457, HP2(0, 0.5003268), np.log10(1.004995)*20),
|
||||
],
|
||||
|
||||
# "neon pink"
|
||||
'raw': [
|
||||
nf(LP1, 20, 0, 1, 29),
|
||||
|
|
@ -23,6 +24,7 @@ cascades = {
|
|||
( 45, HP2( 0, 0.54), 0.5), # a 4-pole butterworth highpass
|
||||
nf(LP2, 14000, 0, 1.33, 0),
|
||||
],
|
||||
|
||||
# like neon pink but for feeding into RMS
|
||||
'raw2': [
|
||||
(10000, HP1(0, 0), 26),
|
||||
|
|
@ -33,6 +35,7 @@ cascades = {
|
|||
( 250, PE2(toA(3), toQ(1.33)), -1),
|
||||
( 4000, PE2(toA(3), toQ(1.33)), -1),
|
||||
],
|
||||
|
||||
# loosely based on the equal loudness contour at 60dB or something
|
||||
'raw_ELC': [
|
||||
( 40, HP2(0, toQ(1.33)), 0),
|
||||
|
|
@ -41,6 +44,7 @@ cascades = {
|
|||
( 4000, PE2(toA(5), toQ(1.00)),-1.5),
|
||||
( 4000, LP2(0, toQ(1.33)), 1.5),
|
||||
],
|
||||
|
||||
# here's the ideas written out:
|
||||
# low (<40) freqs dont contribute much to ears (feel doesnt count.)
|
||||
# high (>14000) freqs are mostly unheard.
|
||||
|
|
@ -55,6 +59,7 @@ cascades = {
|
|||
( 8000, PE2(toA(3), toQ(1.00)), 0.0),
|
||||
(10000, LP2(0, toQ(0.50)),-0.5),
|
||||
],
|
||||
|
||||
'tilt_test': [
|
||||
(10000, HP1(0,0), 30),
|
||||
( 1000, HS1(toA(-16), 0), 1.5),
|
||||
|
|
@ -62,6 +67,7 @@ cascades = {
|
|||
( 40, HP2(0, toQ(1.00)), 0.0),
|
||||
(10000, LP1(0, 0), 0.0),
|
||||
],
|
||||
|
||||
# average curve of my 227 favorite songs
|
||||
'np2': [
|
||||
nf(LP1, 20, 0, 1, 32),
|
||||
|
|
@ -72,6 +78,7 @@ cascades = {
|
|||
nf(LS2, 38, -9, 1.00, 0),
|
||||
nf(PE2, 64, 4.5, 1.20, 0),
|
||||
],
|
||||
|
||||
# same but for the side channel
|
||||
'np2s': [
|
||||
nf(LP1, 20, 0, 1, 32),
|
||||
|
|
@ -79,7 +86,5 @@ cascades = {
|
|||
nf(LP2, 14000, 0, 1.33, 0),
|
||||
nf(HP2, 90, 0, 1.11, 0),
|
||||
nf(PE2, 30, -9.5, 1.00, 0),
|
||||
#(17500, LP2(0, _bq2a), 0),
|
||||
#(17500, LP2(0, _bq2b), 0),
|
||||
],
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@ from . import rfft
|
|||
import numpy as np
|
||||
import scipy.signal as sig
|
||||
|
||||
|
||||
def magnitudes_window_setup(s, size=8192):
|
||||
L = s.shape[0]
|
||||
overlap = 0.661
|
||||
|
|
@ -10,6 +11,7 @@ def magnitudes_window_setup(s, size=8192):
|
|||
segs = np.ceil(L/step)
|
||||
return step, segs
|
||||
|
||||
|
||||
def magnitudes(s, size=8192):
|
||||
import scipy.linalg as linalg
|
||||
|
||||
|
|
@ -36,6 +38,7 @@ def magnitudes(s, size=8192):
|
|||
|
||||
# assert(segs == count) # this is probably no good in a generator
|
||||
|
||||
|
||||
def averfft(s, size=8192):
|
||||
"""calculates frequency magnitudes by fft and averages them together."""
|
||||
step, segs = magnitudes_window_setup(s, size)
|
||||
|
|
|
|||
145
lib/mag.py
Normal file
145
lib/mag.py
Normal file
|
|
@ -0,0 +1,145 @@
|
|||
from . import toA, toQ, cascades
|
||||
|
||||
import numpy as np
|
||||
|
||||
|
||||
def analog(b, a):
|
||||
import sympy as sym
|
||||
w, s = sym.symbols('w s')
|
||||
filt_expr = sym.Poly(b, s)/sym.Poly(a, s)
|
||||
mag_expr = abs(filt_expr.subs({s: w*sym.I}))**2
|
||||
return sym.lambdify(w, mag_expr, 'numpy')
|
||||
|
||||
|
||||
def makemag(w0, ba, gain=0):
|
||||
f = analog(*ba)
|
||||
|
||||
def magf(w):
|
||||
a = f(w/w0)
|
||||
a[0] = 1e-35
|
||||
a = np.log10(a)*10 + gain
|
||||
a[0] = a[1] # safety measure
|
||||
return a
|
||||
return magf
|
||||
|
||||
|
||||
def test_filter_raw(ba, fc=1000, gain=0, precision=4096):
|
||||
fig, ax = new_response(ymin=-24, ymax=24)
|
||||
xs = xsp(precision)
|
||||
ax.semilogx(xs, makemag(fc, ba, gain)(xs))
|
||||
|
||||
|
||||
def test_filter(ff, A=toA(12), Q=toQ(1), **kwargs):
|
||||
test_filter_raw(ff(A, Q), **kwargs)
|
||||
|
||||
|
||||
def neonpink(xs):
|
||||
lament("neonpink(): DEPRECATED; use tilter2(xs, 'raw') instead.")
|
||||
return tilter2(xs, 'raw')
|
||||
|
||||
|
||||
def c_render(cascade, precision=4096):
|
||||
# TODO: deprecate in favor of tilter2
|
||||
xs = xsp(precision)
|
||||
return xs, tilter2(xs, cascade)
|
||||
|
||||
|
||||
def c_render2(xs, cascade, phase=False):
|
||||
"""c_render optimized and specifically for first/second-order filters"""
|
||||
if phase:
|
||||
return c_render3(xs, cascade, mode='phase')
|
||||
else:
|
||||
return c_render3(xs, cascade, mode='magnitude')
|
||||
|
||||
|
||||
def c_render3(xs, cascade, mode='magnitude'):
|
||||
"""c_render optimized and specifically for first/second-order filters"""
|
||||
import numexpr as ne
|
||||
j = np.complex(0, 1)
|
||||
|
||||
# obviously this could be extended to higher orders
|
||||
eq2 = '(b0 + b1*s + b2*s**2)/(a0 + a1*s + a2*s**2)'
|
||||
eq1 = '(b0 + b1*s)/(a0 + a1*s)'
|
||||
|
||||
if mode == 'magnitude':
|
||||
fmt = 'real(log10(abs({})**2)*10 + gain)'
|
||||
elif mode == 'phase' or mode == 'group delay':
|
||||
fmt = '-arctan2(imag({0}), real({0}))' # gross
|
||||
else:
|
||||
raise Exception("c_render3(): unknown mode: {}".format(mode))
|
||||
|
||||
ys = np.zeros(len(xs))
|
||||
for f in cascade:
|
||||
freq, ba, gain = f
|
||||
b, a = ba
|
||||
if len(b) == 3 and len(a) == 3:
|
||||
eq = fmt.format(eq2)
|
||||
b2, b1, b0 = b
|
||||
a2, a1, a0 = a
|
||||
elif len(b) == 2 and len(a) == 2:
|
||||
eq = fmt.format(eq1)
|
||||
b1, b0 = b
|
||||
a1, a0 = a
|
||||
else:
|
||||
raise Exception(
|
||||
"incompatible cascade; consider using c_render instead")
|
||||
|
||||
if mode == 'group delay':
|
||||
# approximate derivative of phase by slope of tangent line
|
||||
step = 2**-8
|
||||
fa = freq - step
|
||||
fb = freq + step
|
||||
|
||||
s = xs/fa*j
|
||||
ya = ne.evaluate(eq)
|
||||
s = xs/fb*j
|
||||
yb = ne.evaluate(eq)
|
||||
|
||||
slope = (yb - ya)/(2*step)
|
||||
ys += -slope/(xs/freq*tau)
|
||||
else:
|
||||
s = xs/freq*j
|
||||
ys += ne.evaluate(eq)
|
||||
if mode == 'phase':
|
||||
ys = degrees_clamped(ys)
|
||||
return ys
|
||||
|
||||
|
||||
def firize(xs, ys, n=4096, srate=44100, ax=None):
|
||||
import scipy.signal as sig
|
||||
if ax:
|
||||
ax.semilogx(xs, ys, label='desired')
|
||||
xf = xs/srate*2
|
||||
yg = 10**(ys/20)
|
||||
|
||||
xf = np.r_[0, xf, 1]
|
||||
yg = np.r_[0, yg, yg[-1]]
|
||||
|
||||
b = sig.firwin2(n, xf, yg, antisymmetric=True)
|
||||
|
||||
if ax:
|
||||
_, ys = sig.freqz(b, worN=xs/srate*tau)
|
||||
ys = 20*np.log10(np.abs(ys))
|
||||
ax.semilogx(xs, ys, label='FIR ({} taps)'.format(n))
|
||||
ax.legend(loc=8)
|
||||
|
||||
return b
|
||||
|
||||
|
||||
def tilter(xs, ys, tilt):
|
||||
"""tilts a magnitude plot by some decibels, or by equalizer curve."""
|
||||
lament("tilter(): DEPRECATED; use ys -= tilter2(xs, tilt) instead.")
|
||||
return xs, ys - tilter2(xs, tilt)
|
||||
|
||||
|
||||
def tilter2(xs, tilt): # TODO: rename
|
||||
noise = np.zeros(xs.shape)
|
||||
if isinstance(tilt, str) and tilt in cascades:
|
||||
tilt = cascades[tilt]
|
||||
if isinstance(tilt, list):
|
||||
c = [makemag(*f) for f in tilt]
|
||||
for f in c:
|
||||
noise += f(xs)
|
||||
elif isinstance(tilt, int) or isinstance(tilt, float):
|
||||
noise = tilt*(np.log2(1000) - np.log2(xs + 1e-35))
|
||||
return noise
|
||||
|
|
@ -2,8 +2,10 @@
|
|||
|
||||
import numpy as np
|
||||
|
||||
|
||||
def LPB(n):
|
||||
# via https://github.com/vinniefalco/DSPFilters/blob/master/shared/DSPFilters/source
|
||||
# via:
|
||||
# https://github.com/vinniefalco/DSPFilters/blob/master/shared/DSPFilters/source
|
||||
"""n-th order butterworth low-pass filter cascade
|
||||
|
||||
-3 dB at center frequency."""
|
||||
|
|
@ -24,8 +26,10 @@ def LPB(n):
|
|||
series += [(num, den)]
|
||||
return series
|
||||
|
||||
|
||||
def LPC(n, ripple, type=1):
|
||||
# via https://github.com/vinniefalco/DSPFilters/blob/master/shared/DSPFilters/source
|
||||
# via:
|
||||
# https://github.com/vinniefalco/DSPFilters/blob/master/shared/DSPFilters/source
|
||||
# FIXME: type 2 has wrong center frequency?
|
||||
"""n-th order chebyshev low-pass filter cascade
|
||||
|
||||
|
|
|
|||
|
|
@ -57,6 +57,7 @@ halfband_c['olli'] = [
|
|||
0.9987488452737**2,
|
||||
]
|
||||
|
||||
|
||||
class Halfband:
|
||||
def __init__(self, c='olli'):
|
||||
self.x = np.zeros(4)
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@ from . import tau
|
|||
|
||||
import numpy as np
|
||||
|
||||
|
||||
# implements the modified bilinear transform:
|
||||
# s <- 1/tan(w0/2)*(1 - z^-1)/(1 + z^-1)
|
||||
# this requires the s-plane coefficients to be frequency-normalized,
|
||||
|
|
@ -20,6 +21,7 @@ def zcgen_py(n, d):
|
|||
zcs[i] += zcs[i - 1]
|
||||
return zcs
|
||||
|
||||
|
||||
def zcgen_sym(n, d):
|
||||
import sympy as sym
|
||||
z = sym.symbols('z')
|
||||
|
|
@ -27,6 +29,7 @@ def zcgen_sym(n, d):
|
|||
coeffs = expr.equals(1) and [1] or expr.as_poly().all_coeffs()
|
||||
return coeffs[::-1]
|
||||
|
||||
|
||||
def s2z_two(b, a, fc, srate, gain=1):
|
||||
"""
|
||||
converts s-plane coefficients to z-plane for digital usage.
|
||||
|
|
@ -40,17 +43,18 @@ def s2z_two(b, a, fc, srate, gain=1):
|
|||
cw = np.cos(w0)
|
||||
sw = np.sin(w0)
|
||||
zb = np.array((
|
||||
b[2]*(1 - cw) + b[0]*(1 + cw) + b[1]*sw,
|
||||
2*(b[2]*(1 - cw) - b[0]*(1 + cw)),
|
||||
b[2]*(1 - cw) + b[0]*(1 + cw) - b[1]*sw,
|
||||
(b[2]*(1 - cw) + b[0]*(1 + cw) + b[1]*sw),
|
||||
(b[2]*(1 - cw) - b[0]*(1 + cw)) * 2,
|
||||
(b[2]*(1 - cw) + b[0]*(1 + cw) - b[1]*sw),
|
||||
))
|
||||
za = np.array((
|
||||
a[2]*(1 - cw) + a[0]*(1 + cw) + a[1]*sw,
|
||||
2*(a[2]*(1 - cw) - a[0]*(1 + cw)),
|
||||
a[2]*(1 - cw) + a[0]*(1 + cw) - a[1]*sw,
|
||||
(a[2]*(1 - cw) + a[0]*(1 + cw) + a[1]*sw),
|
||||
(a[2]*(1 - cw) - a[0]*(1 + cw)) * 2,
|
||||
(a[2]*(1 - cw) + a[0]*(1 + cw) - a[1]*sw),
|
||||
))
|
||||
return zb*gain, za
|
||||
|
||||
|
||||
def s2z1(w0, s, d):
|
||||
"""
|
||||
s: array of s-plane coefficients (num OR den, not both)
|
||||
|
|
@ -67,6 +71,7 @@ def s2z1(w0, s, d):
|
|||
y[i] += trig*zcs[i]*s[n]
|
||||
return y
|
||||
|
||||
|
||||
def s2z_any(b, a, fc, srate, gain=1, d=-1):
|
||||
"""
|
||||
converts s-plane coefficients to z-plane for digital usage.
|
||||
|
|
@ -83,8 +88,10 @@ def s2z_any(b, a, fc, srate, gain=1, d=-1):
|
|||
za = s2z1(w0, sa, cs - 1)
|
||||
return zb*gain, za
|
||||
|
||||
# set our preference. zcgen_py is 1000+ times faster than zcgen_sym
|
||||
|
||||
# set our preference. zcgen_py is 1000+ times faster than zcgen_sym.
|
||||
zcgen = zcgen_py
|
||||
|
||||
# s2z_any is only ~2.4 times slower than s2z_two and allows for filters of any degree
|
||||
# s2z_any is only ~2.4 times slower than s2z_two
|
||||
# and allows for filters of any degree.
|
||||
s2z = s2z_any
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
import matplotlib.pyplot as plt
|
||||
from matplotlib import ticker
|
||||
|
||||
|
||||
def response_setup(ax, ymin=-24, ymax=24, yL=ticker.AutoMinorLocator(3)):
|
||||
ax.set_xlim(20, 20000)
|
||||
ax.set_ylim(ymin, ymax)
|
||||
|
|
@ -10,6 +11,7 @@ def response_setup(ax, ymin=-24, ymax=24, yL=ticker.AutoMinorLocator(3)):
|
|||
ax.set_xlabel('frequency (Hz)')
|
||||
ax.set_ylabel('magnitude (dB)')
|
||||
|
||||
|
||||
def phase_response_setup(ax, div=12, yL=ticker.AutoMinorLocator(2)):
|
||||
ax.set_xlim(20, 20000)
|
||||
ax.set_ylim(-180, 180)
|
||||
|
|
@ -19,22 +21,26 @@ def phase_response_setup(ax, div=12, yL=ticker.AutoMinorLocator(2)):
|
|||
ax.set_xlabel('frequency (Hz)')
|
||||
ax.set_ylabel('phase (degrees)')
|
||||
|
||||
|
||||
def cleanplot():
|
||||
fig, ax = plt.subplots()
|
||||
ax.set_axis_off()
|
||||
ax.set_position([0, 0, 1, 1])
|
||||
return fig, ax
|
||||
|
||||
|
||||
def new_response(*args, **kwargs):
|
||||
fig, ax = plt.subplots()
|
||||
response_setup(ax, *args, **kwargs)
|
||||
return fig, ax
|
||||
|
||||
|
||||
def new_phase_response(*args, **kwargs):
|
||||
fig, ax = plt.subplots()
|
||||
phase_response_setup(ax, *args, **kwargs)
|
||||
return fig, ax
|
||||
|
||||
|
||||
def new_bode(magnitude_offset=0):
|
||||
fig, ax1 = plt.subplots()
|
||||
ax2 = ax1.twinx()
|
||||
|
|
|
|||
|
|
@ -5,7 +5,9 @@ from . import new_response, magnitude_x, convolve_each, monoize, count_channels
|
|||
|
||||
import numpy as np
|
||||
|
||||
def plotfftsmooth(s, srate, ax=None, bw=1, tilt=None, size=8192, window=0, raw=False, **kwargs):
|
||||
|
||||
def plotfftsmooth(s, srate, ax=None, bw=1, tilt=None, size=8192,
|
||||
window=0, raw=False, **kwargs):
|
||||
sm = monoize(s)
|
||||
|
||||
xs_raw = magnitude_x(srate, size)
|
||||
|
|
@ -16,11 +18,13 @@ def plotfftsmooth(s, srate, ax=None, bw=1, tilt=None, size=8192, window=0, raw=F
|
|||
xs, ys = smoothfft(xs_raw, ys_raw, bw=bw)
|
||||
|
||||
if ax:
|
||||
if raw: ax.semilogx(xs_raw, ys_raw, **kwargs)
|
||||
if raw:
|
||||
ax.semilogx(xs_raw, ys_raw, **kwargs)
|
||||
ax.semilogx(xs, ys, **kwargs)
|
||||
|
||||
return xs, ys
|
||||
|
||||
|
||||
def plotwavinternal(sm, ss, srate, bw=1, size=8192, smoother=smoothfft2):
|
||||
xs_raw = magnitude_x(srate, size)
|
||||
ys_raw_m = averfft(sm, size=size)
|
||||
|
|
@ -38,6 +42,7 @@ def plotwavinternal(sm, ss, srate, bw=1, size=8192, smoother=smoothfft2):
|
|||
|
||||
return xs, ys_m, ys_s
|
||||
|
||||
|
||||
def plotwav2(fn, bw=1, size=8192, fix=False,
|
||||
smoother=smoothfft2, **kwargs):
|
||||
s, srate = wav_read(fn)
|
||||
|
|
@ -64,19 +69,22 @@ def plotwav2(fn, bw=1, size=8192, fix=False,
|
|||
sf = np.array((smf + ssf, smf - ssf)).T
|
||||
|
||||
import ewave
|
||||
with ewave.open(fno, 'w', sampling_rate=srate, nchannels=count_channels(sf)) as f:
|
||||
with ewave.open(fno, 'w', sampling_rate=srate,
|
||||
nchannels=count_channels(sf)) as f:
|
||||
f.write(sf)
|
||||
print('wrote '+fno)
|
||||
|
||||
return xs, ys_m, ys_s
|
||||
|
||||
|
||||
def pw2(fn, label=None, bw=1/6, **kwargs):
|
||||
fno = fn[:-4]+"-proc.wav"
|
||||
xs, ys_m, ys_s = plotwav2(fn, fix=True, bw=bw, **kwargs)
|
||||
xs, ys_m, ys_s = plotwav2(fno, fix=False, bw=bw, **kwargs)
|
||||
|
||||
fig, ax = new_response(-18, 18)
|
||||
ax.set_title('averaged magnitudes of normalized songs with tilt and smoothing')
|
||||
ax.set_title(
|
||||
'averaged magnitudes of normalized songs with tilt and smoothing')
|
||||
label = label or fn
|
||||
ax.semilogx(xs, ys_m + 0, label=label+' (mid)')
|
||||
ax.semilogx(xs, ys_s + 9, label=label+' (side)')
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
from . import xsp, lament
|
||||
import numpy as np
|
||||
|
||||
|
||||
def smoothfft(xs, ys, bw=1, precision=512):
|
||||
"""performs log-lin smoothing on magnitude data,
|
||||
generally from the output of averfft."""
|
||||
|
|
@ -18,6 +19,7 @@ def smoothfft(xs, ys, bw=1, precision=512):
|
|||
ys2[i] = np.sum(ys*window/wsum)
|
||||
return xs2, ys2
|
||||
|
||||
|
||||
def smoothfft2(xs, ys, bw=1, precision=512, compensate=True):
|
||||
"""performs log-lin smoothing on magnitude data,
|
||||
generally from the output of averfft."""
|
||||
|
|
@ -32,6 +34,7 @@ def smoothfft2(xs, ys, bw=1, precision=512, compensate=True):
|
|||
window = np.exp(-dist**2/(0.5/2)) # gaussian function (non-truncated)
|
||||
ys2 += ys[i]*window
|
||||
if compensate:
|
||||
_, temp = smoothfft2(xs, np.ones(len(xs)), bw=bw, precision=precision, compensate=False)
|
||||
_, temp = smoothfft2(xs, np.ones(len(xs)),
|
||||
bw=bw, precision=precision, compensate=False)
|
||||
ys2 /= temp
|
||||
return xs2, ys2
|
||||
|
|
|
|||
57
lib/svf.py
57
lib/svf.py
|
|
@ -2,8 +2,10 @@ from . import tau, unwarp
|
|||
|
||||
import numpy as np
|
||||
|
||||
# via http://nbviewer.ipython.org/urls/music-synthesizer-for-android.googlecode.com/git/lab/Second%20order%20sections%20in%20matrix%20form.ipynb
|
||||
|
||||
def svf_core(w0, Q, m, shelfA=1, gain=1):
|
||||
# via:
|
||||
# http://nbviewer.ipython.org/urls/music-synthesizer-for-android.googlecode.com/git/lab/Second%20order%20sections%20in%20matrix%20form.ipynb
|
||||
# TODO: implement constant gain parameter
|
||||
g = unwarp(w0)*shelfA
|
||||
a1 = 1/(1 + g*(g + 1/Q))
|
||||
|
|
@ -17,28 +19,53 @@ def svf_core(w0, Q, m, shelfA=1, gain=1):
|
|||
C = v0*m[0] + v1*m[1] + v2*m[2]
|
||||
return A, B, C
|
||||
|
||||
LP2S = lambda A, Q: (Q, [0, 0, 1], 1)
|
||||
BP2S = lambda A, Q: (Q, [0, 1, 0], 1)
|
||||
HP2S = lambda A, Q: (Q, [1, -1/Q, -1], 1)
|
||||
#AP2S = lambda A, Q:
|
||||
#BP2aS = lambda A, Q:
|
||||
#BP2bS = lambda A, Q:
|
||||
NO2S = lambda A, Q: (Q, [1, -1/Q, 0], 1)
|
||||
PE2S = lambda A, Q: (Q*A, [1, (A*A - 1)/A/Q, 0], 1)
|
||||
LS2S = lambda A, Q: (Q, [1, (A - 1)/Q, A*A - 1], 1/np.sqrt(A))
|
||||
HS2S = lambda A, Q: (Q, [A*A, (1 - A)*A/Q, 1 - A*A], np.sqrt(A))
|
||||
|
||||
# actual peaking filter (not a bell?)
|
||||
def LP2S(A, Q):
|
||||
return (Q, [0, 0, 1], 1)
|
||||
|
||||
|
||||
def BP2S(A, Q):
|
||||
return (Q, [0, 1, 0], 1)
|
||||
|
||||
|
||||
def HP2S(A, Q):
|
||||
return (Q, [1, -1/Q, -1], 1)
|
||||
|
||||
|
||||
# TODO: AP2S
|
||||
# TODO: BP2aS
|
||||
# TODO: BP2bS
|
||||
|
||||
|
||||
def NO2S(A, Q):
|
||||
return (Q, [1, -1/Q, 0], 1)
|
||||
|
||||
|
||||
def PE2S(A, Q):
|
||||
return (Q*A, [1, (A*A - 1)/A/Q, 0], 1)
|
||||
|
||||
|
||||
def LS2S(A, Q):
|
||||
return (Q, [1, (A - 1)/Q, A*A - 1], 1/np.sqrt(A))
|
||||
|
||||
|
||||
def HS2S(A, Q):
|
||||
return (Q, [A*A, (1 - A)*A/Q, 1 - A*A], np.sqrt(A))
|
||||
|
||||
|
||||
# actual peaking filter: (not a bell?)
|
||||
# PE2S = lambda A, Q: ([1, -1/Q, -2], 1)
|
||||
# original uncompensated
|
||||
# original uncompensated:
|
||||
# PE2S = lambda A, Q: (Q, [1, (A*A - 1)/Q, 0], 1)
|
||||
# LS2S = lambda A, Q: (Q, [1, (A - 1)/Q, A*A - 1], 1/np.sqrt(A))
|
||||
# HS2S = lambda A, Q: (Q, [A*A, (A - A*A)/Q, 1 - A*A], 1/np.sqrt(A))
|
||||
|
||||
gen_filters_svf = lambda cascade, srate: [
|
||||
def gen_filters_svf(cascade, srate):
|
||||
return [
|
||||
svf_core(tau*f[0]/srate, *f[1], gain=10**(f[2]/20)) for f in cascade
|
||||
]
|
||||
|
||||
|
||||
def svf_run(svf, xs):
|
||||
A, B, C = svf
|
||||
result = []
|
||||
|
|
@ -48,6 +75,7 @@ def svf_run(svf, xs):
|
|||
y = B*x + np.dot(A, y)
|
||||
return np.array(result)
|
||||
|
||||
|
||||
def svf_mat(svf):
|
||||
A, B, C = svf
|
||||
AA = np.dot(A, A)
|
||||
|
|
@ -59,6 +87,7 @@ def svf_mat(svf):
|
|||
[AB[0], B[0], AA[0][0], AA[0][1]],
|
||||
[AB[1], B[1], AA[1][0], AA[1][1]]])
|
||||
|
||||
|
||||
def svf_run4(mat, xs):
|
||||
assert(len(xs) % 2 == 0)
|
||||
out = np.zeros(len(xs))
|
||||
|
|
|
|||
|
|
@ -2,18 +2,19 @@ from . import tau
|
|||
|
||||
import numpy as np
|
||||
|
||||
|
||||
def sweep(amp, length, begin=20, end=20480, method='linear'):
|
||||
method = method or 'linear'
|
||||
xs = np.arange(length)/length
|
||||
if method in ('linear', 'quadratic', 'logarithmic', 'hyperbolic'):
|
||||
ys = amp*sig.chirp(xs, begin, 1, end, method=method)
|
||||
elif method is 'sinesweep':
|
||||
ang = lambda f: tau*f
|
||||
# because xs ranges from 0:1, length is 1 and has been simplified out
|
||||
domain = np.log(ang(end)/ang(begin))
|
||||
ys = amp*np.sin(ang(begin)/domain*(np.exp(xs*domain) - 1))
|
||||
domain = np.log((tau * end)/(tau * begin))
|
||||
ys = amp*np.sin((tau * begin)/domain*(np.exp(xs*domain) - 1))
|
||||
return ys
|
||||
|
||||
|
||||
def tsp(N, m=0.5):
|
||||
"""
|
||||
OATSP(Optimized Aoshima's Time-Stretched Pulse) generator
|
||||
|
|
|
|||
77
lib/util.py
77
lib/util.py
|
|
@ -2,33 +2,73 @@ import sys
|
|||
import numpy as np
|
||||
import scipy.signal as sig
|
||||
|
||||
dummy = lambda *args, **kwargs: None
|
||||
lament = lambda *args, **kwargs: print(*args, file=sys.stderr, **kwargs)
|
||||
|
||||
toLK = lambda x: -0.691 + 10*np.log10(x)
|
||||
isqrt2 = 1/np.sqrt(2)
|
||||
toQ = lambda bw: isqrt2/bw
|
||||
toA = lambda db: 10**(db/40)
|
||||
|
||||
tau = 2*np.pi
|
||||
unwarp = lambda w: np.tan(w/2)
|
||||
warp = lambda w: np.arctan(w)*2
|
||||
|
||||
ceil2 = lambda x: np.power(2, np.ceil(np.log2(x)))
|
||||
pad2 = lambda x: np.r_[x, np.zeros(ceil2(len(x)) - len(x))]
|
||||
|
||||
rfft = lambda src, size: np.fft.rfft(src, size*2)
|
||||
magnitude = lambda src, size: 10*np.log10(np.abs(rfft(src, size))**2)[0:size]
|
||||
def dummy(*args, **kwargs):
|
||||
return None
|
||||
|
||||
|
||||
def lament(*args, **kwargs):
|
||||
return print(*args, file=sys.stderr, **kwargs)
|
||||
|
||||
|
||||
def toLK(x):
|
||||
return -0.691 + 10*np.log10(x)
|
||||
|
||||
|
||||
def toQ(bw):
|
||||
return isqrt2/bw
|
||||
|
||||
|
||||
def toA(db):
|
||||
return 10**(db/40)
|
||||
|
||||
|
||||
def unwarp(w):
|
||||
return np.tan(w/2)
|
||||
|
||||
|
||||
def warp(w):
|
||||
return np.arctan(w)*2
|
||||
|
||||
|
||||
def ceil2(x):
|
||||
return np.power(2, np.ceil(np.log2(x)))
|
||||
|
||||
|
||||
def pad2(x):
|
||||
return np.r_[x, np.zeros(ceil2(len(x)) - len(x))]
|
||||
|
||||
|
||||
def rfft(src, size):
|
||||
return np.fft.rfft(src, size*2)
|
||||
|
||||
|
||||
def magnitude(src, size):
|
||||
return 10*np.log10(np.abs(rfft(src, size))**2)[0:size]
|
||||
|
||||
|
||||
# x axis for plotting above magnitude
|
||||
magnitude_x = lambda srate, size: np.arange(0, srate/2, srate/2/size)
|
||||
def magnitude_x(srate, size):
|
||||
return np.arange(0, srate/2, srate/2/size)
|
||||
|
||||
|
||||
def degrees_clamped(x):
|
||||
return ((x*180/np.pi + 180) % 360) - 180
|
||||
|
||||
degrees_clamped = lambda x: ((x*180/np.pi + 180) % 360) - 180
|
||||
|
||||
def xsp(precision=4096):
|
||||
"""create #precision log-spaced points from 20 Hz (inclusive) to 20480 Hz (exclusive)"""
|
||||
"""
|
||||
create #precision log-spaced points from
|
||||
20 Hz (inclusive) to 20480 Hz (exclusive)
|
||||
"""
|
||||
xs = np.arange(0, precision)/precision
|
||||
return 20*1024**xs
|
||||
|
||||
|
||||
def blocks(a, step, size=None):
|
||||
"""break an iterable into chunks"""
|
||||
if size is None:
|
||||
|
|
@ -39,14 +79,18 @@ def blocks(a, step, size=None):
|
|||
break
|
||||
yield a[start:end]
|
||||
|
||||
|
||||
def convolve_each(s, fir, mode='same', axis=0):
|
||||
return np.apply_along_axis(lambda s: sig.fftconvolve(s, fir, mode), axis, s)
|
||||
return np.apply_along_axis(
|
||||
lambda s: sig.fftconvolve(s, fir, mode), axis, s)
|
||||
|
||||
|
||||
def count_channels(s):
|
||||
if s.ndim < 2:
|
||||
return 1
|
||||
return s.shape[1]
|
||||
|
||||
|
||||
def monoize(s):
|
||||
"""mixes an n-channel signal down to one channel.
|
||||
technically, it averages a 2D array to be 1D.
|
||||
|
|
@ -56,6 +100,7 @@ def monoize(s):
|
|||
s = np.average(s, axis=1)
|
||||
return s
|
||||
|
||||
|
||||
def div0(a, b):
|
||||
"""division, whereby division by zero equals zero"""
|
||||
# http://stackoverflow.com/a/35696047
|
||||
|
|
|
|||
|
|
@ -1,15 +1,18 @@
|
|||
import numpy as np
|
||||
from .util import lament, count_channels
|
||||
|
||||
|
||||
def wav_smart_read(fn):
|
||||
lament('wav_smart_read(): DEPRECATED; use wav_read instead.')
|
||||
import scipy.io.wavfile as wav # don't use this, it fails to load good files
|
||||
# don't use this, it fails to load good files.
|
||||
import scipy.io.wavfile as wav
|
||||
srate, s = wav.read(fn)
|
||||
if s.dtype != np.float64:
|
||||
bits = s.dtype.itemsize*8
|
||||
s = np.asfarray(s)/2**(bits - 1)
|
||||
return srate, s
|
||||
|
||||
|
||||
def wav_smart_write(fn, srate, s):
|
||||
lament('wav_smart_write(): DEPRECATED; use wav_write instead.')
|
||||
import scipy.io.wavfile as wav
|
||||
|
|
@ -18,6 +21,7 @@ def wav_smart_write(fn, srate, s):
|
|||
si += np.clip(s*2**(bits - 1), -32768, 32767)
|
||||
wav.write(fn, srate, si)
|
||||
|
||||
|
||||
def wav_read(fn):
|
||||
import ewave
|
||||
with ewave.open(fn) as f:
|
||||
|
|
@ -30,6 +34,7 @@ def wav_read(fn):
|
|||
s = np.asfarray(s)/2**(bits - 1)
|
||||
return s, srate
|
||||
|
||||
|
||||
def wav_write(fn, s, srate, dtype='h'):
|
||||
import ewave
|
||||
if dtype in ('b', 'h', 'i', 'l') and np.max(np.abs(s)) > 1:
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
import numpy as np
|
||||
|
||||
|
||||
def _deco_win(f):
|
||||
# gives scipy compatibility
|
||||
def deco(N, *args, sym=True, **kwargs):
|
||||
|
|
@ -18,25 +19,33 @@ def _deco_win(f):
|
|||
return w
|
||||
return deco
|
||||
|
||||
|
||||
def _gen_hamming(*a):
|
||||
L = len(a)
|
||||
a += (0, 0, 0, 0, 0) # pad so orders definition doesn't error
|
||||
orders = [
|
||||
lambda fac: 0,
|
||||
lambda fac: a[0],
|
||||
lambda fac: a[0] - a[1]*np.cos(fac),
|
||||
lambda fac: a[0] - a[1]*np.cos(fac) + a[2]*np.cos(2*fac),
|
||||
lambda fac: a[0] - a[1]*np.cos(fac) + a[2]*np.cos(2*fac) - a[3]*np.cos(3*fac),
|
||||
lambda fac: a[0] - a[1]*np.cos(fac) + a[2]*np.cos(2*fac) - a[3]*np.cos(3*fac) + a[4]*np.cos(4*fac),
|
||||
lambda fac: a[0] - a[1]*np.cos(1*fac),
|
||||
lambda fac: a[0] - a[1]*np.cos(1*fac) + a[2]*np.cos(2*fac),
|
||||
lambda fac: a[0] - a[1]*np.cos(1*fac) + a[2]*np.cos(2*fac)
|
||||
- a[3]*np.cos(3*fac),
|
||||
lambda fac: a[0] - a[1]*np.cos(1*fac) + a[2]*np.cos(2*fac)
|
||||
- a[3]*np.cos(3*fac) + a[4]*np.cos(4*fac),
|
||||
]
|
||||
f = orders[L]
|
||||
return lambda N: f(np.arange(0, N)*2*np.pi/(N - 1))
|
||||
|
||||
|
||||
def _normalize(*args):
|
||||
a = np.asfarray(args)
|
||||
return a/np.sum(a)
|
||||
|
||||
_h = lambda *args: _deco_win(_gen_hamming(*args))
|
||||
|
||||
def _h(*args):
|
||||
return _deco_win(_gen_hamming(*args))
|
||||
|
||||
|
||||
blackman_inexact = _h(0.42, 0.5, 0.08)
|
||||
blackman = _h(0.42659, 0.49656, 0.076849)
|
||||
blackman_nuttall = _h(0.3635819, 0.4891775, 0.1365995, 0.0106411)
|
||||
|
|
@ -49,6 +58,7 @@ hann = _h(0.5, 0.5)
|
|||
hamming_inexact = _h(0.54, 0.46)
|
||||
hamming = _h(0.53836, 0.46164)
|
||||
|
||||
|
||||
@_deco_win
|
||||
def triangular(N):
|
||||
if N % 2 == 0:
|
||||
|
|
@ -56,6 +66,7 @@ def triangular(N):
|
|||
else:
|
||||
return 1 - np.abs(2*(np.arange(N) + 1)/(N + 1) - 1)
|
||||
|
||||
|
||||
@_deco_win
|
||||
def parzen(N):
|
||||
odd = N % 2
|
||||
|
|
@ -71,17 +82,22 @@ def parzen(N):
|
|||
else:
|
||||
return np.r_[outer[::-1], center[::-1], center[1:], outer]
|
||||
|
||||
|
||||
@_deco_win
|
||||
def cosine(N):
|
||||
return np.sin(np.pi*(np.arange(N) + 0.5)/N)
|
||||
|
||||
|
||||
@_deco_win
|
||||
def welch(N):
|
||||
return 1 - (2*np.arange(N)/(N - 1) - 1)**2
|
||||
|
||||
|
||||
# TODO: rename or something
|
||||
@_deco_win
|
||||
def sinc(N):
|
||||
return np.sinc((np.arange(N) - (N - 1)/2)/2)
|
||||
|
||||
winmod = lambda f: lambda N: f(N + 2)[1:-1]
|
||||
|
||||
def winmod(f):
|
||||
return lambda N: f(N + 2)[1:-1]
|
||||
|
|
|
|||
Loading…
Reference in a new issue