This is a topic I used to geek around with for more than a year. I never had any real interaction with like minded individuals back then. Just studying what I could find on the interwebs and trying out stuff in PD and ABox.

PD comes with a few premade reverberators but I never really liked the sound of them. I like reverb to be longtaily and diffuse, like those old schools plates of the 60ties/70ties. I'll be sharing some of my homegrowns here, and if anyone want to join the party they are welcome.

Exhibit A, the jVerb, is a monster, capable of generating infinte tail (dont try). It's basically a handful of scattering junctions joined in a circular matrix with nested allpass filters at each node. To run it requires a set of also homegrown abstractions so I've zipped it up including a demo patch (jVerbDemo.pd).

WARNING: This patch has been known to blow up headphones. The regeneration of energy within the circuit can accumulate very fast and fuck up everything, so careful on the knobs. Also, fairly heavy on the CPU...

Any feeback or questions are welcome

And of course, feel free to exploit the patch at will

jVerb.zip

@bocanegra https://forum.pdpatchrepo.info/topic/5349/patching-a-good-reverb/6
not from me, but reverbCH~ and reverb282~ from @acreil are by far the best Pd reverbs I've heard.

@weightless said:

@bocanegra https://forum.pdpatchrepo.info/topic/5349/patching-a-good-reverb/6
not from me, but reverbCH~ and reverb282~ from @acreil are by far the best Pd reverbs I've heard.

Thanks for replying. I'll check those out. I'm not big on having to install externals tho. Also, I've been trhotugh the algortithms mentioned in the thread.

I was kinda hoping we could have a discussion about reverberation that will provide techniques for newbs rather than go on about our fave this and that. But maybe I started off wrong by showing of my mutant...

Under all circumstances, here is my experience modelling reverb in short:

While freeverb sucks (sorry), Schoeder is your friend. The trick is to find a way of recycling you allpass series (or even better, nests!) that makes sense to your ears. Dattoro's work is pretty much that. If you look at his "tank" section of his first plate verb emulation, that's what it does, very cleverly so: it creates a simple feedback matrix of phased out echoes bouncing back and forth. My jVerb is in many ways an elaborate Dattoro tank.

Now, you can build reverb tanks in many ways. The jVerb is extremely heavy on CPU (but gaaawd I love the sound). A simple way is having two lines going through a series of N allpass nests and having the two lines feedback into each other like ping pong delay. If you tune the allpass filters right (primes!!!) and add some tiny modulation to delay times you are rid of eigentones or whatever they are called.

I'll make the effort to describe how a Schroeder allpass nest is constructed (no math):

You put three allpass filters in series and give them Z coefficients (that is delay in samples) of dimishing magnitude, following some log rule or another. Schroeder liked to approximate 1/3 for each allpass. MAKING SURE THEY ARE ALL PRIMES!!!

Then you put that chain inside the loop of another allpass filter, and tune it's Z to fit the series in such a way that the outer loop has the highest Z.

A single allpass nest can pass for primitive reverberation with the right tweaking. A handful in series will create a lot of diffusion and sound better (less echo-y). BUT: Make sure every nest has it's unique series of Z values.

Then add low frequency modulators to the Z value (delay time) on each and every allpass loop. Random values are preferable over sinusoids or any other periodical thing. The APN abstractions I used in jVerb have all this built in already.

What's left is to add some pre-delay if you like that, and some bandlimiting somewhere in the feedback loop.

I have a CPU friendly verb following this scheme somewhere. I'll upload it ASAP

@bocanegra I guess I misunderstood your post then, my bad. I didn't mean to show off my favourites but rather point you to some nice work that has already been done in Pd (especially the Dattoro one) in case you didn't know about it, for you to study and take some inspiration from.

Reverb design goes a bit over my head to be honest, even though I tried to study a few algorithms, so perhaps somebody else will join in for the discussion.

Your jVerb sounds very nice to me, thank you very much for sharing it.

Sounds very nice. Thanks!

My only "complaint" with the sound is that it's a bit too much random stereo sometimes, but that's easy fixed by a simple mix of mono/stereo before the final output.

But yeah, very CPU hungry.
I had a look, and here's my suggestions on how to cut down on CPU a bit:

1. throw~ / catch~ and s~ / r~ pairs are quite CPU hungry too. There are lots of places in abstractions where you just use those to tidy the patch a bit, Not worth it if you want to keep CPU down. Just do direct cable connections. The less you use these, the lighter your patch will get on CPU.

2. vd~ uses a lot more CPU than delread~. For your modulated stuff, you'll need to stick with vd~, but i noticed that the [delay~] abstractions used vd~ when the delay time was fixed, so no need for those. And fcbc~ uses vd~, but its input is originally just control signals, so you can change it to delread~ too.

3. Probably no need for [vline~] objects, just use [line~]

Sorry, might have just been faster for me to change the patch, but maybe it helps people to see where these bottlenecks come from?

@mod Thanks for the reply and suggestions. I always thought the CPU suckage came from the amount of recycled sludge going on for seemingly ever in the delay matrix. I'll try to clear out sends and receives from the abstractions. wont be pretty tho

Oh, and I wholeheartedly agree to the notion of writing suggestions here rather than just editing patches. The more practical info we can get on these pages, the better.

I'm attaching a more simple all purpose room/verb following the algorithm I described in my previous post. I should probably give it the same treatment you prescribed, but it's not really that much of a CPU hog. It can't produce those freaky super long tails jVerb is capable of, but it's gives off just that sort of neat balanced shimmery reverb I like for most of my mixes. It comes with a text table of delay times in samples, following the prime/golden ratio rule and a subpatch to parse it meaningfully, which is very useful for tuning the allpass nests.

It has no predelay, but you could easily add that by setting up a couple of delay lines at the input stages (before the tank-loop).

I didn't make a demo patch like I did for jVerb, so you'll have to insert it as an abstraction in your own patch to hear it at work

Schroom.zip

Ok, so, I've cleaned up both the verbs abstractions. And fixed a bunch of errors I wasnt aware about. Took going through the guts of all to discover all my sloppyness.

jVerb1.2 changelog:

• Added one preset
• Fixed delay time calculation in the [delay~] abstraction
• Reduced sends and throws etc (see later discussion)
• Changed [vline~] to [line~]
• Fixed a bug with the control subpatch not sending correct gain messages for the APNs
• Changed se S control from binary to "analogue"
• Added pseudorandom seeding (using $0) for all delay modulation

jVerb1.2.zip

Schroom1.2 changelog:

• Using the a lot of the same abstractions, a lot of the same changes apply. Basicially the APNs and below.
• added a missing abstraction which rendered the patch useless. The [xfade~] providing crossfade between natural verb and beefcake. I'm sure the smart ones of you made one up on the fly.

Schroom1.2.zip

Now, about reducing sends/receives or throw/catches. The signal flow in jVerbs matrix go like this: https://imgur.com/a/cE3b0gi

If I substitute the receives and throws for direct lines I get "DSP loop detected" error messages. I suspect I can do away with that by putting the delreads at the junction outputs outside their abstractions, but I'm too tired to try now.

Oh, and I get this error message whenever I open the jverbdemo patch: "$2: argument number out of range". I've not been able to locate the error...

For those interested in the jVerb algortihm, I'll try to elaborate on the design. First of all you need to wrap your head around the idea of the Kelly-Lochbaum scattering junction. I think there's even an object in extended modelling it. My own version is highly modified, but I'll get to that later. Here's the primer on KL-junctions: https://ccrma.stanford.edu/~jos/pasp/Kelly_Lochbaum_Scattering_Junctions.html

As you can see from my flow diagram above, that is the primary building block in jVerb. The second one is Schroeder allpass nests, which also form the essential guts of Schroom.. Neat diagram + discussion can be found here: https://valhalladsp.com/2009/05/30/schroeder-reverbs-the-forgotten-algorithm/

The things not explained in my ms-paint flow chart are the stuff I added to jVerb in order to get rid of metallic ringing and out of control feedback. You can still tweak the patch to do both if that's your thing.

First of all, each allpass nest has a slowmo random modulator on the outer delay loop, with a low amplitude (300 ms, 11 samples).

Second all junctions are provided with a fixed delay plus a randomly modulated delay on each output.

This is all to avoid metallic ringing.

Third, there is a gain control on the inlet of each junction. This is pretty essential in preventing nasty build ups. If you play around with it you'll see that the junction gain is what saves your headphones (and ears).

Finally, there's a cross fade function between the two inlets of each junction. This pretty much destroys the original equation, but can produce some very interesting results.

The latter two are controllable.

You might wanna try adding some filters to the chain or constructing your very own matrix of junctions and nests.

If I spend more time on jVerb, it will be adding delay tuning like Schroom has and maybe optional individual controls for each junction... Dunno.

Post your own mods if you like

Just a quick post again to give many thanks for sharing these, and such good explanations of what is going on inside.

Will be digging in soon to have a proper look and see if i can make some worthwhile edits.

Count me as interested in this thread too, only I won't have much to contribute as I am absolutely new to actually designing reverb patches. Thanks for sharing your patches and links. I've always had a kind of background fascination with reverb ever since I learned audio production techniques in the 1990's. Back then, I couldn't get enough Lexicon 'math' in my mixes, while of course it was a special treat to have access to a beautiful room that could be mic'd up and used as an old-school reverb chamber.

I'm happy to see there's interest in the subject. I think I'll dedicate my following posts to going through some classic reverb design algorithms with the purpose of allowing the readers to learn from the bottom up. In the history of digital reverberation, Schroeder was the pioneer, and while his reverberators sound kinda crappy, he was the one who laid down the basics (connecting and tuning allpass and comb filters in a smart way). The infamous freeverb is basically an extended Schroeder reverberator with some lowpass filtering.

So, I built a patch implementing this algortihm: https://ccrma.stanford.edu/~jos/pasp/Schroeder_Reverberators.html

It doesnt sound conventionally nice, but it enables you to experiment with ALL parameters and experience hands on what the APs and combs do to the sound. There's a preset memory for 8 patches, so you can have fun developing alternative filter tunings and such. I splattered it with explanatory comments so you should be able to manipulate it without too many questions. But more importantly, with the abstractions provided (APS1 and FBCF and maybe MM4X4), you should be able to build your own simple reverberators.

Notes on the mixing matrix: Schroeders suggested matrix can be reduced and reproduced simply by following the math on the ccrma page I linked to, but I wanted to make the patch 100% modable, so you get an expensive mixing matrix to play with on top of the Aps and combs.

Enjoy, and do post your homegrown verbs if you get that deep into the rabbit hole. Also, feel free to ask any questions - there is no such thing as a stupid question!!!

I'll endeavour to post another didactically designed patch next week!