category = "Filter",
license = "GPLv2",
author = "Ardour Team",
- description = [[An Ardour High and Low Pass Filter with de-zipped controls, written in Lua]]
+ description = [[High and Low Pass Filter with de-zipped controls, written in Ardour-Lua]]
}
function dsp_ioconfig ()
local cur = {0, 0, 0, 0, 0, 0} -- current parameters
local lpf = 0.03 -- parameter low-pass filter time-constant
local chn = 0 -- channel/filter count
+local lpf_chunk = 0 -- chunk size for audio processing when interpolating parameters
+local max_freq = 20000
local mem = nil -- memory x-fade buffer
-- allocate some mix-buffer
mem = ARDOUR.DSP.DspShm (8192)
+ -- max allowed cut-off frequency
+ max_freq = .499 * rate
+
-- create a table of objects to share with the GUI
local tbl = {}
tbl['samplerate'] = rate
+ tbl['max_freq'] = max_freq
self:table ():set (tbl)
- -- interpolation time constant, ~15Hz @ 64fpp
- lpf = 5000 / rate
+
+ -- Parameter smoothing: we want to filter out parameter changes that are
+ -- faster than 15Hz, and interpolate between parameter values.
+ -- For performance reasons, we want to ensure that two consecutive values
+ -- of the interpolated "steepness" are less that 1 apart. By choosing the
+ -- interpolation chunk size to be 64 in most cases, but 32 if the rate is
+ -- strictly less than 22kHz (there's only 8kHz in standard rates), we can
+ -- ensure that steepness interpolation will never change the parameter by
+ -- more than ~0.86.
+ lpf_chunk = 64
+ if rate < 22000 then lpf_chunk = 32 end
+ -- We apply a discrete version of the standard RC low-pass, with a cutoff
+ -- frequency of 15Hz. For more information about the underlying math, see
+ -- https://en.wikipedia.org/wiki/Low-pass_filter#Discrete-time_realization
+ -- (here Δt is lpf_chunk / rate)
+ local R = 2 * math.pi * lpf_chunk * 15 -- Hz
+ lpf = R / (R + rate)
end
function dsp_configure (ins, outs)
end
end
+function santize_params (ctrl)
+ -- don't allow manual cross-fades. enforce enums
+ ctrl[1] = math.floor(ctrl[1] + .5)
+ ctrl[4] = math.floor(ctrl[4] + .5)
+
+ -- high pass, clamp range
+ ctrl[2] = math.min (max_freq, math.max (5, ctrl[2]))
+ ctrl[3] = math.min (6, math.max (0.1, ctrl[3]))
+
+ -- low pass, clamp range
+ ctrl[5] = math.min (max_freq, math.max (20, ctrl[5]))
+ ctrl[6] = math.min (6, math.max (0.1, ctrl[6]))
+ return ctrl
+end
+
-- helper functions for parameter interpolation
function param_changed (ctrl)
for p = 1,6 do
-- the actual DSP callback
function dsp_run (ins, outs, n_samples)
- assert (n_samples < 8192)
+ assert (n_samples <= 8192)
assert (#ins == chn)
+ local ctrl = santize_params (CtrlPorts:array ())
local changed = false
local siz = n_samples
local off = 0
- -- if a parameter was changed, process at most 64 samples at a time
- -- and interpolate parameters until the current settings match
- -- the target values
- if param_changed (CtrlPorts:array ()) then
+ -- if a parameter was changed, process at most lpf_chunk samples
+ -- at a time and interpolate parameters until the current settings
+ -- match the target values
+ if param_changed (ctrl) then
changed = true
- siz = 64
+ siz = lpf_chunk
end
while n_samples > 0 do
- if changed then apply_params (CtrlPorts:array ()) end
+ if changed then apply_params (ctrl) end
if siz > n_samples then siz = n_samples end
local ho = math.floor(cur[1])
if xfade > 0 then
ARDOUR.DSP.apply_gain_to_buffer (outs[c]:offset (off), siz, 1 - xfade)
hp[c][ho+1]:run (mem:to_float (off), siz)
- ARDOUR.DSP.mix_buffers_with_gain (outs[c]:offset (off), mem:to_float (off), siz, 1 - xfade)
- ho = ho + 1 -- to avoid running another time the biguad |ho+1|
- end
-
- -- run remaining biquads because they need to have the correct state
- -- in case they start affecting the next chunck of output
- -- TODO: only run the ones that have a chance to run next cycle
- for k = ho+1,4 do
- hp[c][k]:run (mem:to_float (off), siz)
+ ARDOUR.DSP.mix_buffers_with_gain (outs[c]:offset (off), mem:to_float (off), siz, xfade)
+ -- also run the next biquad because it needs to have the correct state
+ -- in case it start affecting the next chunck of output. Higher order
+ -- ones are guaranteed not to be needed for the next run because the
+ -- interpolated order won't increase more than 0.86 in one step thanks
+ -- to the choice of the value of |lpf|.
+ if ho + 2 <= 4 then hp[c][ho+2]:run (mem:to_float (off), siz) end
+ elseif ho + 1 <= 4 then
+ -- run the next biquad in case it is used next chunk
+ hp[c][ho+1]:run (mem:to_float (off), siz)
end
-- Low Pass
if xfade > 0 then
ARDOUR.DSP.apply_gain_to_buffer (outs[c]:offset (off), siz, 1 - xfade)
lp[c][lo+1]:run (mem:to_float (off), siz)
- ARDOUR.DSP.mix_buffers_with_gain (outs[c]:offset (off), mem:to_float (off), siz, 1 - xfade)
- lo = lo + 1 -- to avoid running another time the biguad |lo+1|
- end
-
- -- again, run remaining biquads
- for k = lo+1,4 do
- lp[c][k]:run (mem:to_float (off), siz)
+ ARDOUR.DSP.mix_buffers_with_gain (outs[c]:offset (off), mem:to_float (off), siz, xfade)
+ -- also run the next biquad in case it start affecting the next
+ -- chunck of output.
+ if lo + 2 <= 4 then lp[c][lo+2]:run (mem:to_float (off), siz) end
+ elseif lo + 1 <= 4 then
+ -- run the next biquad in case it is used next chunk
+ lp[c][lo+1]:run (mem:to_float (off), siz)
end
end
filt = {}
filt['hp'] = ARDOUR.DSP.Biquad (tbl['samplerate'])
filt['lp'] = ARDOUR.DSP.Biquad (tbl['samplerate'])
+ max_freq = tbl['max_freq']
end
+ local ctrl = santize_params (CtrlPorts:array ())
-- set filter coefficients if they have changed
- if param_changed (CtrlPorts:array ()) then
- local ctrl = CtrlPorts:array ()
+ if param_changed (ctrl) then
for k = 1,6 do cur[k] = ctrl[k] end
filt['hp']:compute (ARDOUR.DSP.BiquadType.HighPass, cur[2], cur[3], 0)
filt['lp']:compute (ARDOUR.DSP.BiquadType.LowPass, cur[5], cur[6], 0)
projects / ardour.git / blobdiff