The Orvillain DSP Thread

[SillyOctpuss]

The chip I use for prototyping is DaisySeed. Which is about as powerful as something like a Meris MercuryX, on paper.

FV1 is definitely another option though. Cheaper too!

Keep posting your findings and how you're getting on. I'm pretty good with pt2399 and BBD chips but know nothing about the types of delay you're working on.

 

[Orvillain]

So feedback delay networks. I've been experimenting with them a fair bit.

What is a feedback delay network?
The tldr version - an FDN is a big tangle of delays, all connected to each other, feeding their signal to every other delay. This creates a crazy network of feedback that typically results in very unpredictable echoes.

The more guitarist centric version:
Imagine you've got a bunch of delay pedals running in parallel. The outputs of those pedals all mix back into each others inputs. So pedal 1 goes to pedal 2+3+4. Pedal 2 goes to 1+3+4. Pedal 3 goes to 1+2+4. Pedal 4 goes to 1+2+3.

The deeper explanation:
An FDN is <n> number of delay lines. After each delay the outputs are stacked into a vector. That vector gets multipled by a feedback matrix, before being sent back into the delay inputs.

What is a feedback matrix?
Think of this as a "mixing box". If you've specified <n> number of delay lines, then the feedback matrix is NxN in size. Each row describes the mix that goes into one delay input. Each column describes how one delays output is spread across all the inputs.

For 4 delays, it is a 4x4 grid of numbers. Each number is more or less like a "send level" knob, that controls how much signal gets fed from one delay pedal to another. For example:

However, won't that sound poopy? Yes, most likely. Which is why we want to ensure orthogonality.

What is orthogonality?
Orthogonality is a fancy word for "the rows (and columns) of the matrix are at right angles to each other in math space."

An orthogonal feedback matrix is energy preserving. This means the echoes do not blow up uncontrollably (turning your analog delay feedback to max for example) but also they don't vanish too quickly either (setting your feedback knob to minimum) - the network just keeps redistributing energy around until it naturally decays.

The choice of the type of matrix give the network its flavour. These are the types:

Circulant Phase
DCT4Mixer
Givens Cascade
Hadamard
Householder
Random Orthogonal
Signed Permutation

All images below follow this ordering.

One of the types of signal we send into effects algorithms to try and determine what is happening, is known as a DIRAC impulse - essentially a single sample click:

This quite often can help to reveal the structure of delays and reverbs, amongst other effects.

So in the pursuit of knowledge, I have been testing out various sizes and types of feedback matrices, to figure out what they look like, and what they sound like. A picture paints a thousand monkey words.

If you have 2 delays, for a matrix of 2x2, you get this kind of thing.

You can see that CirculantPhase looks just like a delay. There's nothing special going on. DCT4Mixer has a delay quality to it, but there is a patterened scattering and polarity flip for each of the clicks. Whereas GivensCascade, Hadamard, Householder... these all immediately have a random diffused scattering effect, even with such a small number of delays and matrix size. SignedPermutation looks closer to DCT4Mixer.

Then we go up to 4 delays, for a matrix of 4x4:

You can see we have far more randomness and complexity now.

Here are 8x8, 12x12, and 16x16:

Now while these all look similar on the surface, the sonic complexity does massively vary. Suffice to say, the type of matrix you choose and the number of delay lines, as well as the delay values used, all make a massive difference to the final quality of reverb you end up with.

There are other things that affect the quality of the reverb, but I'm not ready to go into that yet.

 

[Orvillain]

Interpolation is super important, yo.

 

[[Nathan]]

I dunno anything about this nerd shit, but that first video sounded mint!

 

[Orvillain]

This is a Cepstrum of an IR, with the graph gain boosted to raise peaks.

Y-axis (up/down) == frequency
X-axis (left/right) == time

Those red bars are essentially delay times.

Delay Time (ms) = 1000 / Frequency.

So that very top one, at 77hz. Delay time is 12.98ms. Or at a 48kHz sample-rate, 623 samples.

 

[Orvillain]

So now my next step is to write a peak picking algorithm that can process this cepstrum information. The idea being, I can get the idealised delay times for a particular impulse response. Of a hardware reverb unit, lets say....

 

[AlbertA]

I dunno anything about this nerd shit

I'm here for the nerd shit

 

[Orvillain]

 

[SillyOctpuss]

I'm here for the nerd shit

I can't stop watching it.

 

[AlbertA]

View attachment 52479

This is a Cepstrum of an IR, with the graph gain boosted to raise peaks.

Y-axis (up/down) == frequency
X-axis (left/right) == time

Those red bars are essentially delay times.

Delay Time (ms) = 1000 / Frequency.

So that very top one, at 77hz. Delay time is 12.98ms. Or at a 48kHz sample-rate, 623 samples.

Is this power ceptstrum? Or are you computing the complex cepstrum and showing the magnitude there?

Are you trying to get a feel for the early reflections delay times?

I see some smearing => I guess modulation?

 

[Richard_G]

This isn't my field, @Orvillain, but I'm trying to get a basic understanding of what you're working on. From what I gather, you're using cepstrum analysis to extract information from a reverb — like early reflections and other delay patterns — and then using that as a kind of "delay blueprint" to recreate or approximate the reverb using your delay-based algorithms, through feedback delay networks (FDNs)? Is that roughly right?

 

[AlbertA]

Interpolation is super important, yo.

For sure - IIRC, the Axe-FX I used 4th-order Lagrange on its delay lines - I wonder if that still the same in the III.

 

[Orvillain]

For sure - IIRC, the Axe-FX I used 4th-order Lagrange on its delay lines - I wonder if that still the same in the III.

I'd imagine by now they've upgraded to some kind of fractional sinc method, (single row, or two-row blended) or at least have the capability to switch certain delay based processors to that kind of read method. It is much higher quality.

But sometimes you don't want high quality. Sometimes you want horrible 1980's linear interpolation.

The RingDelay I wrote for myself offers:

Quality considerations:
• Nearest – very fast, but audible stepping and strong HF loss
(stylistically matches late-1970s / early-1980s
primitive digital delays & samplers).
• Linear – lightweight; smoother but with HF roll-off
(mid-1980s digital rack FX, early drum machines / ROMplers).
• Cubic / Lagrange3 – 4-point interpolators with better HF extension
(1990s–2000s “prosumer” samplers, workstation synths).
• Sinc (rowNearest) – bandlimited interpolation with moderate CPU cost
(modern digital FX units from ~2010 onward).
• Sinc (rowBlend) – highest quality, minimal aliasing, more CPU
(contemporary software plugins and hi-fi DSP).

It is kind of magical when you take the exact same reverb algorithm and change the read mode; all of a sudden you can get a world of absolute crufty shite, by going down to nearest or linear. Actually, I'm willing to be the reverb block on Axe3 switches this and more.

 

[Orvillain]

This isn't my field, @Orvillain, but I'm trying to get a basic understanding of what you're working on. From what I gather, you're using cepstrum analysis to extract information from a reverb — like early reflections and other delay patterns — and then using that as a kind of "delay blueprint" to recreate or approximate the reverb using your delay-based algorithms, through feedback delay networks (FDNs)? Is that roughly right?

That's almost spot on. Except for this, I'm not using FDN's, because I'm chasing Alesis Midiverb II tones, and back in 1987, FDN's basically weren't in any commercial product - from what I can gather anyway. Even the much loved Lexicon reverbs of that era didn't use FDN's.

A cepstrum is the inverse Fourier transform of a log spectrum.

It is a way of looking for repeating patterns - so reverbs and delays are really good candidates for that.

So imagine you knew this much about reverb design - stacked all-pass filters to create an early reflections diffusion circuit, followed by a bank of delays with longer delay times to give a specific decay length, and then on top of that perhaps a feedback path within the bank of delays, followed by the outputs of each individual delay summing at the main audio output.

Let's say you knew that. You might want to analyse some reverbs out there in the world, to try and ascertain what the coefficients of the all-pass filters would be, and what the delay times for the delays in the bank would be.

But of course it isn't really THAT easy. Let's say you get a delay time of 100ms. How do you know that is one delay at 100ms, or two delays at 50ms, or 4 delays at 25ms, or 5 delays where 4 are at 12ms and the 5th one is at 40ms.

Yeah I can't answer that one either right now!!

 

[Someoldqueenorother]

The chip I use for prototyping is DaisySeed. Which is about as powerful as something like a Meris MercuryX, on paper.

FV1 is definitely another option though. Cheaper too!

I know zilch about the programming stuff but I've spent a lot of time with the Midiverb II and SPX90 aka the old crusty gunk.

The guy who makes these uses the FV-1.

https://reverb.com/item/73762189-early-reflections-reverse-reverb-by-jma

It's hands down the best recreation of anything from the gunky era that I've used. I don't know what he did but he nailed the feel of Reverse Gate, the tone, everything.

I do remember that Sean @ Valhalla wrote a bit on the FV-1 chip:

"My current theory is that the peculiarities of the FV-1 hardware are adding this coloration to any algorithms that run on them, and that these peculiarities are shared with the Alesis hardware."

https://www.kvraudio.com/forum/viewtopic.php?t=349039&start=30

So perhaps the FV-1 coloration means it has a bit of Alesis-style gunk in there.

(I'll stop talking technical now).