19 Nov
2020
19 Nov
'20
11:05 p.m.
Hello all,
Some people have asked me to provide a bit more documentation
on the state-variable filters I used in zita-eq1 and zita-jacktools.
So I've written a short technical note on this. You can find it at
<http://kokkinizita.linuxaudio.org/papers/digsvfilt.pdf>
Ciao,
--
FA
20 Nov
20 Nov
8:50 p.m.
On Thu, 19 Nov 2020 22:05:00 +0100
Fons Adriaensen <fons(a)linuxaudio.org> wrote:
Hello all,
Some people have asked me to provide a bit more documentation
on the state-variable filters I used in zita-eq1 and zita-jacktools.
So I've written a short technical note on this. You can find it at
<http://kokkinizita.linuxaudio.org/papers/digsvfilt.pdf>
Ciao,
Thanks for this. Very interesting. I recognised the hardware drawing instantly.
I used a variant on an amp some years ago for splitting out sub-bass, just
using the high and low pass outputs. It made tuning to suit the actual speakers
extremely easy.
--
It wasn't me! (Well actually, it probably was)
... the hard part is not dodging what life throws at you,
but trying to catch the good bits.
22 Nov
22 Nov
12:36 a.m.
On Thu, Nov 19, 2020 at 10:05:00PM +0100, Fons Adriaensen wrote:
Hello all,
Some people have asked me to provide a bit more documentation
on the state-variable filters I used in zita-eq1 and zita-jacktools.
So I've written a short technical note on this. You can find it at
<http://kokkinizita.linuxaudio.org/papers/digsvfilt.pdf>
I wish I was good at maths! This makes it all look so simple, and it works well.
I guess with the corrected parameters, you can't get it to self-oscillate without Q
really being infinite? With the uncorrected parameters it seems to go "over
unity" with Q set to about 10, but a soft clipper would stop it blowing up.
It behaves well if you interpolate the c1 and c2 values to sweep the filter across a block
of samples, which is handy.
--
Gordonjcp
2:09 p.m.
On Sat, Nov 21, 2020 at 10:17:31PM +0000, Gordonjcp wrote:
I guess with the corrected parameters, you can't
get it to self-oscillate
without Q really being infinite?
Apart from numerical precision issues which could occur for extremely high Q.
For anything required in audio processing there won't be any problem.
With the uncorrected parameters it seems to go
"over unity" with Q set to
about 10
The actual value will depend on the resonance frequency.
It behaves well if you interpolate the c1 and c2
values to sweep the
filter across a block of samples, which is handy.
You'd have to interpolate the 'd*' as well. Not for stability but in
order to maintain the required response during the sweep.
The way I do this is in gain controls, equalisers etc. is in two steps:
Define some internal block size N, independent of jack period etc.
I normally use something like sample rate / 100 (i.e. 10 milliseconds).
1. Every N samples, check if the user parameters (e.g. center frequency
for an EQ) are equal to the current ones. If they are not, then
* Move the current value towards the user value at a controlled rate
(for example limit the frequency change to one octave).
* Recompute internal parameters (e.g. filter coefficients) using the
new current values.
Big changes in any user parameter may require more than one step to
reach their target.
2. Within each block of N samples, if the internal parameters computed
in (1) are not equal to the current ones, use linear interpolation.
If they are equal, optionally use a version of the DSP code that
skips the interpolation.
The block size N and the rate limits in (1) should be chosen such that
there is no apparent delay to a human user.
This requires a lot of extra logic and code (much more than the actual
DSP code in most cases), but the result is a process that will never
produce clicks or pops and is therefore safe to use in e.g. a live
performance. Impact on CPU load is minimal since most of the work is
done only every N samples, and only when user parameters change.
Ciao,
--
FA
13 Jan
13 Jan
1:16 p.m.
Hi Fons,
I have a question (sanity checking my understanding) regarding the
implementation: You note in your introduction that the SV-Filter
provides lowpass, highpass and bandpass outputs. If I wanted to provide
all three to the user then this could be done with the following C-Code,
right (adapted from your individual examples)?
d0_high = 1 - c1 / 2 + c1 * c2 / 4;
d1_band = 1 - c2;
d0_band = d1 * c1 / 2;
d0_low = c1 * c2 / 4;
d1_low = c2;
for (i = 0; i < n; ++i)
{
x = inp[i] - z1 - z2;
out_high = d0_high * x;
out_band = d0_band * x + d1_band * z1;
z2 = c2 * z1;
out_low = d0_low * x + z2;
z1 = c1 * x;
}
Regards,
FPS
Oh, looking at it again, and if I'm not completely confused, this should
also be equivalent:
for (i = 0; i < n; ++i)
{
x = inp[i] - z1 - z2;
z2 = c2 * z1;
out_high = d0_high * x;
out_band = d0_band * x + d1_band * z1;
out_low = d0_low * x + z2;
z1 = c1 * x;
}
On 11/19/2020 10:05 PM, Fons Adriaensen wrote:
Hello all,
Some people have asked me to provide a bit more documentation
on the state-variable filters I used in zita-eq1 and zita-jacktools.
So I've written a short technical note on this. You can find it at
<http://kokkinizita.linuxaudio.org/papers/digsvfilt.pdf>
Ciao,
--
https://fps.io
14 Jan
14 Jan
5:56 p.m.
FYI - Naive LV2 implementation:
https://github.com/fps/state-variable-filter.lv2
Regards,
FPS
P.S.: PRs welcome ;)
On 1/13/2021 12:16 PM, Florian Paul Schmidt wrote:
Hi Fons,
I have a question (sanity checking my understanding) regarding the
implementation: You note in your introduction that the SV-Filter
provides lowpass, highpass and bandpass outputs. If I wanted to provide
all three to the user then this could be done with the following C-Code,
right (adapted from your individual examples)?
d0_high = 1 - c1 / 2 + c1 * c2 / 4;
d1_band = 1 - c2;
d0_band = d1 * c1 / 2;
d0_low = c1 * c2 / 4;
d1_low = c2;
for (i = 0; i < n; ++i)
{
x = inp[i] - z1 - z2;
out_high = d0_high * x;
out_band = d0_band * x + d1_band * z1;
z2 = c2 * z1;
out_low = d0_low * x + z2;
z1 = c1 * x;
}
Regards,
FPS
Oh, looking at it again, and if I'm not completely confused, this should
also be equivalent:
for (i = 0; i < n; ++i)
{
x = inp[i] - z1 - z2;
z2 = c2 * z1;
out_high = d0_high * x;
out_band = d0_band * x + d1_band * z1;
out_low = d0_low * x + z2;
z1 = c1 * x;
}
On 11/19/2020 10:05 PM, Fons Adriaensen wrote:
--
https://fps.io
Hello all,
Some people have asked me to provide a bit more documentation
on the state-variable filters I used in zita-eq1 and zita-jacktools.
So I've written a short technical note on this. You can find it at
<http://kokkinizita.linuxaudio.org/papers/digsvfilt.pdf>
Ciao,
--
https://fps.io
_______________________________________________
Linux-audio-dev mailing list
Linux-audio-dev(a)lists.linuxaudio.org
https://lists.linuxaudio.org/listinfo/linux-audio-dev
1760
days inactive
1816
days old
linux-audio-dev@lists.linuxaudio.org
5 comments
4 participants
participants (4)
-
Florian Paul Schmidt -
Fons Adriaensen -
Gordonjcp -
Will J Godfrey