alpha forever...upcoming modular synth

[9b0]

Verry weird decision .
I know that A.F is an amazing program because I demoed it a few years ago , eventually I did not purchase it because I can do eveything in reaktor .
For some reason , I want to give it a second chance but that is sadly not possible .
How do attract possible buyers ?

It was not an easy choice, but from our point of view, it has rational reasons. You're right that it might be harder to find new customers this way.

[9b0]

In my latest video, we are going to perform oversampling on a TanH saturator.

[9b0]

Last year I did videos demonstrating the ZDF/TPT filter design workflow for linear filters. I like the reliability and stability of linear filters, but I can also understand why one would like to add saturation to these algorithms. This is probably my last video on this topic, I hope, you'll find it interesting.

[gentleclockdivider]

Your video's are gold , I do wish you would re-think your "no-demo available " decision .
Best of luck , alpha forever has really proven to be a worthy contender

[9b0]

Your video's are gold , I do wish you would re-think your "no-demo available " decision .
Best of luck , alpha forever has really proven to be a worthy contender

I'm exporting a fix to this video ATM since I made some mistakes here. I'm happy, you enjoy the content anyway. You also have a PM from me (sent it a few weeks ago), but since Premiere keeps breaking (just broke again), I'll upload it tomorrow.

I've messed up a few things during the build, and it's a wonder that the filter works the way it does. When I watched back the video, I felt the dip in the frequency response on higher frequencies was too strong (I remembered, that there should be a dip compared to the linear filter, but it's really subtle). Today I checked things and felt really bad for posting the video.

Explanation: I coded the filter a few months ago in LUA for fun, and it looks like I remembered things wrong while I was building the patch, and also read the code wrong (it was opened on my second monitor while patching).

Anyway: the updated patch is going to be fine (I've already posted the patch on our Discord), using 2x polyphase allpass oversampling the filter sounds really good to me (without oversampling, aliasing is really audible on higher cutoffs and resonance values >1.95). I hope I'll be able to post the video tomorrow.

[9b0]

I made a few mistakes in my previous video and recorded a new one quickly to fix the mistakes. I hope, no one was trying to build it the way I've done it! I've described the issues in the video description.

[kmonkey]

Admittedly I was living under a rock when it came to this one...wtf This is pure gold.

[9b0]

And I've made another mistake during the fix... I wont make another video, but will explain the fix here.

The mistake I did:
I've messed up the filter equation once again. I wanted to subtract from y in the end, and not y from the equation.


This mistake caused the need to move the solver in front of everything, so the solver is good in the end:


Correct filter response:
https://www.dropbox.com/scl/fi/bl2tpp86 ... jgneq&dl=1

Sound demo:
https://www.dropbox.com/scl/fi/o9as42y3 ... jc0cc&dl=1

I'm not making up excuses: just sorry for the misinformation. I'll try to be better prepared next time, and not hurry with fixes either.

To fight aliasing it's worth considering inserting a lowpass filter into the feedback, that dampens above half Nyquist, or using oversampling.

[lalo]

Wouldn't be this rather complex equations a perfect match for the new LUA node?

[9b0]

Wouldn't be this rather complex equations a perfect match for the new LUA node?

That's where I do all the DSP stuff nowadays: probably this is the reason why I'm struggling with making video content. I just don't want to create videos where I write code, because I don't think I'm good at it.

Anyway, my solution looks like below. This code runs perfectly with the LuaJIT compiler. The distortion in this case is not a simple TanH, it has DC offset too. The performance is about 50% of the same code compiled in C++ (which is fine for me). The code is derived from my n-pole NL SK filter code, which is the reason why I'm using loops for everything.

EDIT: using many LUA nodes is not efficient. The compiler adds it's own overhead to the process, and makes the node inefficient as an 'expression' node. It shines at more complex tasks, like filters and oscillators or samplers.

Code: Select all

numInputs=6
numOutputs=5

local function tan(x) -- tangent approximation
	local a=x*-0.089663+0.0388452
	local b=x*-0.430871+0.0404318
	local c=a*x+1.00005
	local d=b*x+1
	return c*x/d
end

local function min(n,limit) -- minimum function using arithmetics
	return limit+((n-limit)-math.abs(n-limit))*0.5
end

local function max(n,limit) -- maximum function using arithmetics
    return ((n+limit)+math.abs(n-limit))*0.5
end

local FilterSKNL2pole={} -- 4-pole linear multi-mode SK filter (x:input, F: cutoff frequency (Hz), k: resonance (0..4))
for i=0,31 do
    FilterSKNL2pole[i]={}
end

local function create_FilterSKNL2pole(self)
    self.s={}
    self.y={}
    self.g=0
    self.fb=0
    self.Nmax=16
    for i=0,self.Nmax do
        self.s[i]=0
        self.y[i]=0
    end
    self.lp=0
    self.bp=0
    self.hp=0
    self.driveDC=0
end

local function dsp_FilterSKNL2pole(self,x,F,k,drv,ofs,samplerate)

    local function preWarp() -- Frequency to coeff warper using bilinear transform
        local BLT=math.pi/samplerate
        return tan(min(max(F,0.01)*BLT,1.508))
    end

    local drvR=1/drv

    local function drive(n,dc)
        return (math.tanh((n+ofs)*drv)-dc)*drvR
    end

    local function filterEquation(y,s,g,dc)
        local output={}
        local input=drive(x+y*k,dc)
        for i=1,2 do
            output[i]=g*input+s[i]
            input=output[i]
        end
        
        return output[1]-output[2]-y
    end
 
    local function secantMethod(y0,y1,tolerance,maxIterations,s,g,dc)
        local yPrev=y0
        local yCurr=y1
        local f_yPrev=filterEquation(yPrev,s,g,dc)
        local iteration=0
        while iteration<maxIterations do
            local f_yCurr = filterEquation(yCurr,s,g,dc)
    
            if math.abs(f_yCurr-f_yPrev)<tolerance then
                return yCurr
            end
    
            local y_next=yCurr-f_yCurr*(yCurr-yPrev)/(f_yCurr-f_yPrev)
            yPrev=yCurr
            f_yPrev=f_yCurr
            yCurr=y_next
            iteration=iteration+1
        end
        return yCurr
    end

    local w=preWarp()
    local g=w/(1+w)
    self.driveDc=math.tanh(ofs*drv)

    self.s[0]=x

    local input=drive(x+(self.fb*k),self.driveDc)

    self.y[0]=input

    for i=1,2 do
        self.y[i]=g*self.y[i-1]+self.s[i]
        self.s[i]=drive(self.s[i]+2*((self.y[i-1]-self.y[i])*g),self.driveDc)
    end

    self.lp2=self.y[2]
    self.lp1=self.y[1]
    self.bp=self.y[2]-self.y[1]
    self.hp=self.y[1]-self.y[0]
    self.input=self.y[0]

    self.fb=secantMethod(0,1,0.00001,3,self.s,g,self.driveDc)

    return self.lp2
end

function init(idx)
    create_FilterSKNL2pole(FilterSKNL2pole[idx])
end

function process(idx)
    dsp_FilterSKNL2pole(FilterSKNL2pole[idx],ins[1],max(ins[2],1),max(ins[3],0),max(ins[4],1),ins[5],samplerate)
    outs[1]=FilterSKNL2pole[idx].hp
    outs[2]=FilterSKNL2pole[idx].bp
    outs[3]=FilterSKNL2pole[idx].lp2
    outs[4]=FilterSKNL2pole[idx].lp1
    outs[5]=FilterSKNL2pole[idx].input
end

[leodu]

Maybe it can be used

[9b0]

I've also rebuilt CamelCrusher.

[gentleclockdivider]

Excellent , as always

[9b0]

Tired of generic compression algorithms? Discover how to add unique character to your compressors in my new video.

[9b0]

I've created a saxophone patch recently, this is the breakdown video of it: