Old 02-21-2023, 01:34 PM   #121
Arthur McArthur
Human being with feelings
 
Arthur McArthur's Avatar
 
Join Date: Sep 2016
Location: Toronto
Posts: 744
Default

Thanks for all your hard work! Just sent a donation. Enjoy your time unplugged from the matrix
Arthur McArthur is offline   Reply With Quote
Old 02-21-2023, 02:00 PM   #122
Steviekeys
Human being with feelings
 
Join Date: Jun 2016
Location: UK
Posts: 285
Default

Quote:
Originally Posted by chmaha View Post
Interesting! The vinyl crackle is super fun but the "fractal" variety doesn't seem to be consistent across plays and sometimes ends with a prolonged electronic pitched sound.
Now it's consistent and decays faster, the metallic sound is still there just more buried now!
Steviekeys is offline   Reply With Quote
Old 02-21-2023, 03:10 PM   #123
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default NEW: A-coo-sticks tape delay echo

NEW: A-coo-sticks tape delay echo



Q: Why does a pigeon call not reverberate in a concert hall?
A: A-coo-sticks.

Using DSP from airwindows TapeDelay2.

Well, I can't believe I'm saying it but this is the most fun I've had with a plugin in a while. Play with the time slider in realtime, set it to a static value, set regen, flutter, frequency, resonance etc and...just have a lot of fun. I don't want to say much more as it would spoil the fun of discovery. A veritable toychest of delay for all sorts of purposes. It can do subtle tape ambience to full-on psychedelic can't-help-but-smile stuff and lots in between. And, with that, I'm taking a short break. À plus tard...À plus tard...À plus tard...
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides

Last edited by chmaha; 02-21-2023 at 03:31 PM.
chmaha is offline   Reply With Quote
Old 02-21-2023, 08:15 PM   #124
dyross
Human being with feelings
 
Join Date: Jan 2023
Posts: 68
Default

Hi chmaha,

I'm new to the airwindows console stuff, and wondering if you, as you are probably as close of an expert on this stuff outside of chris himself given you ported the code, can comment on what it's actually doing?

What does it do in the "summing" phase specifically that you can't do by effects at the end of your track and beginning of 2 bus?

(I don't need to know mathematically - I can read the code - but curious if you can provide the intuition for it.)

Great work on this stuff!
dyross is offline   Reply With Quote
Old 02-22-2023, 12:02 AM   #125
Arthur McArthur
Human being with feelings
 
Arthur McArthur's Avatar
 
Join Date: Sep 2016
Location: Toronto
Posts: 744
Default

Hey I have a general request for these plugins: output sliders on the plugins that make sense to have them. Not having them makes A/Bing or balancing the effect much more difficult. For example Valvity Tube Saturation or Altitude Brighness EQ and others could benefit

Would also be REALLY useful to have Tempo Sync for time based effects like Delay, this would make your versions much more useful than the originals, haha

Last edited by Arthur McArthur; 02-22-2023 at 12:16 AM.
Arthur McArthur is offline   Reply With Quote
Old 02-22-2023, 01:14 AM   #126
Steviekeys
Human being with feelings
 
Join Date: Jun 2016
Location: UK
Posts: 285
Default

Quote:
Originally Posted by Arthur McArthur View Post
Hey I have a general request for these plugins: output sliders on the plugins that make sense to have them. Not having them makes A/Bing or balancing the effect much more difficult. For example Valvity Tube Saturation or Altitude Brighness EQ and others could benefit

Would also be REALLY useful to have Tempo Sync for time based effects like Delay, this would make your versions much more useful than the originals, haha
Yes! And GR meters for the compressors.
Steviekeys is offline   Reply With Quote
Old 02-22-2023, 01:43 AM   #127
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

Quote:
Originally Posted by dyross View Post
Hi chmaha,

I'm new to the airwindows console stuff, and wondering if you, as you are probably as close of an expert on this stuff outside of chris himself given you ported the code, can comment on what it's actually doing?

What does it do in the "summing" phase specifically that you can't do by effects at the end of your track and beginning of 2 bus?

(I don't need to know mathematically - I can read the code - but curious if you can provide the intuition for it.)

Great work on this stuff!
Hehe, it's sometimes difficult to put into words what an airwindows plugin is doing, but without doing an injustice to the DSP, here's a simplistic way of thinking about it. Each pair of plugins (channel > auxbus, auxbus>final 2-bus) works its magic by applying equal and opposite amounts of processing (which I understand to be saturation). When there is only one channel, it creates a perfect cancellation and you only have the sound you put in. But, the magic occurs when there are multiple channels all feeding the next stage. In those situations, the equal and opposite processing does not fully cancel out and you get pleasing analog-style saturation.

Bottom line is that the more channels you have feeding the next stage, the more pronounced the effect just as it would be in a real analog console. Yes, you could just use other plugins at appropriate points but it wouldn't be doing the same magic. It's why in other posts my general rule of thumb is to always think in pairs. It also means that you can use Orpheus Lite and Eurydice in deeper chains because I removed the final hard clipping module and therefore a bus track can have a channel plugin at the end of the chain which in turn can lead to another submix etc. I don't think people need to go too crazy with this aspect as it is always fun to think in terms of real-world console limitations (hence the included templates as a starting point).

I hope that somewhat answers the question?
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides

Last edited by chmaha; 02-22-2023 at 02:53 AM.
chmaha is offline   Reply With Quote
Old 02-24-2023, 02:42 PM   #128
dyross
Human being with feelings
 
Join Date: Jan 2023
Posts: 68
Default

Quote:
Originally Posted by chmaha View Post
Hehe, it's sometimes difficult to put into words what an airwindows plugin is doing, but without doing an injustice to the DSP, here's a simplistic way of thinking about it. Each pair of plugins (channel > auxbus, auxbus>final 2-bus) works its magic by applying equal and opposite amounts of processing (which I understand to be saturation). When there is only one channel, it creates a perfect cancellation and you only have the sound you put in. But, the magic occurs when there are multiple channels all feeding the next stage. In those situations, the equal and opposite processing does not fully cancel out and you get pleasing analog-style saturation.

Bottom line is that the more channels you have feeding the next stage, the more pronounced the effect just as it would be in a real analog console. Yes, you could just use other plugins at appropriate points but it wouldn't be doing the same magic. It's why in other posts my general rule of thumb is to always think in pairs. It also means that you can use Orpheus Lite and Eurydice in deeper chains because I removed the final hard clipping module and therefore a bus track can have a channel plugin at the end of the chain which in turn can lead to another submix etc. I don't think people need to go too crazy with this aspect as it is always fun to think in terms of real-world console limitations (hence the included templates as a starting point).

I hope that somewhat answers the question?
Thanks, this makes a lot of sense.

But what I'm still confused about is why does this require overriding default summing? What about the "de-saturation" stage requires it to be done as part of summing rather than against an already summed mix?
dyross is offline   Reply With Quote
Old 02-25-2023, 08:35 AM   #129
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

Quote:
Originally Posted by dyross View Post
Thanks, this makes a lot of sense.

But what I'm still confused about is why does this require overriding default summing? What about the "de-saturation" stage requires it to be done as part of summing rather than against an already summed mix?
I'm not sure what you mean by default summing but with the console system set up correctly, you use the faders in the plugins and leave the REAPER channel faders at unity. Why the saturation/de-saturation pairings at each stage of summing? To mimic a real analog console. An analog console doesn't just add "warmth" etc at the final stage...it happens throughout in subtle ways which accumulate in pleasing ways.

I'm not sure you could even use the console system plugins on an already summed mix. What would you use? If you artificially pushed a final stereo mix through a single stage of a channel and bus pair, you probably won't get much of anything in return. Many-to-one routing is the trick to getting a decent amount of analog goodness.

I suppose that the only real way to figure all this out is via critical listening. If you can use one of the plugins to get the sound you want in a single final stage, go for it! In my own tests, I much prefer the Orpheus/Console8 system with a pinch of MagicFairyDust at the very end. It will be interesting to compare with the newer Orpheus Lite.
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides

Last edited by chmaha; 02-25-2023 at 09:06 AM.
chmaha is offline   Reply With Quote
Old 02-25-2023, 02:48 PM   #130
dyross
Human being with feelings
 
Join Date: Jan 2023
Posts: 68
Default

Quote:
Originally Posted by chmaha View Post
I'm not sure what you mean by default summing but with the console system set up correctly, you use the faders in the plugins and leave the REAPER channel faders at unity. Why the saturation/de-saturation pairings at each stage of summing? To mimic a real analog console. An analog console doesn't just add "warmth" etc at the final stage...it happens throughout in subtle ways which accumulate in pleasing ways.

I'm not sure you could even use the console system plugins on an already summed mix. What would you use? If you artificially pushed a final stereo mix through a single stage of a channel and bus pair, you probably won't get much of anything in return. Many-to-one routing is the trick to getting a decent amount of analog goodness.

I suppose that the only real way to figure all this out is via critical listening. If you can use one of the plugins to get the sound you want in a single final stage, go for it! In my own tests, I much prefer the Orpheus/Console8 system with a pinch of MagicFairyDust at the very end. It will be interesting to compare with the newer Orpheus Lite.
I'm sorry that my question wasn't clear. Here are two different scenarios:

1. "Console channel out" on all channels, "console bus in" in as first on mix bus, but "console bus in" doesn't override summing, it just applies its desaturation processing etc. to the summed stereo mix

2. "Console channel out" on all channels, "console bus in" in as first on mix bus, where "console channel out" sends audio directly to "console bus in" (hence unity gain), which overrides the summing and does its desaturation processing etc.

So, I'm trying to understand what it does at the summing phase specifically (before the desaturation).

Does the question make sense?
dyross is offline   Reply With Quote
Old 02-25-2023, 05:00 PM   #131
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

Quote:
Originally Posted by dyross View Post
I'm sorry that my question wasn't clear. Here are two different scenarios:

1. "Console channel out" on all channels, "console bus in" in as first on mix bus, but "console bus in" doesn't override summing, it just applies its desaturation processing etc. to the summed stereo mix

2. "Console channel out" on all channels, "console bus in" in as first on mix bus, where "console channel out" sends audio directly to "console bus in" (hence unity gain), which overrides the summing and does its desaturation processing etc.

So, I'm trying to understand what it does at the summing phase specifically (before the desaturation).

Does the question make sense?
OK, I'll have another quick go at this. I think I understand what you are asking now. So before the desaturation, the reason we want to just use the plugin sliders is because because we need calibration between the saturation and desaturation. In your first example, you would not be applying equal amounts of desaturation to the saturation that came in. What is happening exactly? Well, the best I can make out is that things in phase return to their original sounds after the sat/de-sat pairing and things in varying amounts of out-of-phaseness don't and have a residual amount of distortion. The whole point seems to be to mimic bus input impedance. In other words, how is the bus reacting to the various audio channels coming in at any given point? I don't believe you can faithfully recreate this sort of analog behavior with a single plugin on the final 2-bus. But, if I'm wrong, I'll happily hold my hands up
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides

Last edited by chmaha; 02-25-2023 at 05:07 PM.
chmaha is offline   Reply With Quote
Old 02-25-2023, 05:17 PM   #132
dyross
Human being with feelings
 
Join Date: Jan 2023
Posts: 68
Default

Quote:
Originally Posted by chmaha View Post
OK, I'll have another quick go at this. I think I understand what you are asking now. So before the desaturation, the reason we want to just use the plugin sliders is because because we need calibration between the saturation and desaturation. In your first example, you would not be applying equal amounts of desaturation to the saturation that came in. What is happening exactly? Well, the best I can make out is that things in phase return to their original sounds after the sat/de-sat pairing and things in varying amounts of out-of-phaseness don't and have a residual amount of distortion. The whole point seems to be to mimic bus input impedance. In other words, how is the bus reacting to the various audio channels coming in at any given point? I don't believe you can faithfully recreate this sort of analog behavior with a single plugin on the final 2-bus. But, if I'm wrong, I'll happily hold my hands up
Fascinating, thanks.
dyross is offline   Reply With Quote
Old 02-27-2023, 08:22 AM   #133
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

Update: Altitude Brightness EQ v1.1
  • Update according to airwindows commit 09cdb13
I think Chris was still working on his SlewSonic when I ported the source code so here's v1.1 with the updates. Essentially it is a change in slider range for Frequency (now more usefully called "Mute"), and some cascading values through the 1–3 stages of SlewOnly DSP.
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides

Last edited by chmaha; 02-27-2023 at 10:24 AM.
chmaha is offline   Reply With Quote
Old 02-27-2023, 03:43 PM   #134
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

NEW: PirateDither



Did you say you wanted yet another dither? Sure, here you go Using DSP from both airwindows DitherMeTimbers (24-bit) and DitherMeDiskers (16-bit) combined into a single swashbucklin' plugin. The tonal opposite of RCDither's Avant-garde. Try it, you might like it!

BTW, I think the likely issue with high cpu numbers when running the attempted BussColors4 port (Clio) is because a jsfx instance only uses a single thread. It's computationally intense to generate impulse responses on the fly so that's my current best guess. It would be great to figure this out for definite but likely it will simply stay on github and not be part of the ReaPack repo.
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides

Last edited by chmaha; 02-27-2023 at 04:16 PM.
chmaha is offline   Reply With Quote
Old 02-28-2023, 06:09 AM   #135
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

NEW: All Ears Monitoring Utility



Using DSP from airwindows Monitoring3. Note that this does not include the dithers as I've already created separate plugins for those (RCDither, Twilight and Nintenda for all the airwindows monitoring-related dithers). Stick this on the master bus and check for issues with your mixes via the first 14 modules. The 15th is called "V Trick" and is for recording vocals without headphones if you place your microphone exactly between the two speakers. I wouldn't bother with that one but it's there just in case.

Peaks, slew and subs are about exaggerating certain aspects of the mix so that if it sounds completely wrong when listening on those settings, maybe think about re-balancing. Mono and Side are obvious. Vinyl, Aurat (and MonoRat/Lat) and Phone are about how things would sound on a record player, auratone cube (stereo and mono "grot-box") and cellphone. There are also four different "cans" that utilize crossfeed for when mixing/mastering on headphones. Cans A = subtle, B = more obvious, for late night mixing, C = like A but a bit stronger and D = well, weird if you have very wide stereo mixes. Have fun.

EDIT: Anyone interested in a port of Pockey2? It's listed first in the lo-fi category.
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides

Last edited by chmaha; 02-28-2023 at 12:04 PM.
chmaha is offline   Reply With Quote
Old 03-03-2023, 02:20 AM   #136
Arthur McArthur
Human being with feelings
 
Arthur McArthur's Avatar
 
Join Date: Sep 2016
Location: Toronto
Posts: 744
Default

Hey chmaha, don't worry about that plugin that I requested, the new FX Container feature in the pre forum should make it quite easy to do on my end. Thanks for considering it
Arthur McArthur is offline   Reply With Quote
Old 03-03-2023, 02:59 AM   #137
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

Quote:
Originally Posted by Arthur McArthur View Post
Hey chmaha, don't worry about that plugin that I requested, the new FX Container feature in the pre forum should make it quite easy to do on my end. Thanks for considering it
I was going to comment on this too. I think I understand what it is offering and it should be great!
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides
chmaha is offline   Reply With Quote
Old 03-03-2023, 02:21 PM   #138
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

NEW: Hippity Hoppity Lo-Fi



Using DSP from airwindows Pockey2. Mess with DeFreq (try automating it!) and DeRez. Make hiphop sounds. Not my bag (for now) but enjoy
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides

Last edited by chmaha; 03-03-2023 at 02:32 PM.
chmaha is offline   Reply With Quote
Old 03-07-2023, 11:34 AM   #139
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

NEW: Millie Brightness EQ



Using DSP from airwindows PurestAir. Tame or boost the brightness via the Air Boost slider and limit the amount of brightness possible with Air Limit. Simple (and weird)!
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides
chmaha is offline   Reply With Quote
Old 03-08-2023, 03:35 PM   #140
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

NEW: Flutternutter



Using DSP from airwindows Flutter. One slider to be liberally covered in marshmallow and peanut butter and...oh wait.
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides
chmaha is offline   Reply With Quote
Old 03-08-2023, 04:37 PM   #141
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

NEW: Analog-a-licious Console Colors



Using DSP from airwindows Desk, TransDesk and TubeDesk all rolled into one jsfx. Subtle "Vanilla", "SSL" and "Vintage Tube" analog colorization. No controls (other than to select which console type you want). Place wherever you wish with more instances meaning more of the effect.

I need to take a short break again. Enjoy the recent additions.
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides

Last edited by chmaha; 03-08-2023 at 04:50 PM.
chmaha is offline   Reply With Quote
Old 03-11-2023, 09:23 AM   #142
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

NEW: Desk-a-docious Console Colors



Using DSP from airwindows Desk4 and successor to the previous iterations of Desk that were rolled into Analog-a-licious. Instead of no controls, you have SIX. Note that "Frequency" works in tandem with "Power Sag". As with Analog-a-licious, use multiple instances as you see fit.
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides

Last edited by chmaha; 03-11-2023 at 09:32 AM.
chmaha is offline   Reply With Quote
Old 03-11-2023, 02:00 PM   #143
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

NEW: Ambrosia Tape Emulation



Using DSP from airwindows Tape (redux) to which I added an output gain slider (useful!). It's a good one. Stick on the final 2-bus and enjoy. It's apparently Chris' ultimate mastering tape emulation (minus the flutter etc) now made more ultimate with control over the output

I'm honestly now at the mercy of checking the airwindows github repository once a week to see what comes down the pipeline next. I was already ahead of the official binary releases with Orpheus Lite (Console8Lite), PhiVerb (Chamber2) and Altitude (Slewsonic) and there's nothing else existing that I want to port However, with the current count at over 60 plugins it's been a good run
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides

Last edited by chmaha; 03-11-2023 at 02:25 PM.
chmaha is offline   Reply With Quote
Old 03-12-2023, 09:38 AM   #144
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default Evolution Channel Strip

New: Evolution Channel Strip



Chris delivered quickly! Using DSP from airwindows CStrip2. A go-to channel strip containing EQ, high/low pass (using Titan aka airwindows Capacitor), compression and output drive (including two different saturation models). With Output at 0.33 or lower there is no saturation. From 0.34 to 0.66 it transitions into Spiral and then from 0.66 transitions into Density.
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides

Last edited by chmaha; 03-12-2023 at 11:53 AM.
chmaha is offline   Reply With Quote
Old 03-12-2023, 09:44 AM   #145
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

NEW: Genesis Console

Using DSP from Console0. No controls. Two plugins: channel and bus. Use as you would Orpheus, Orpheus Lite or Eurydice with channel last in the channel chain and bus first on the...bus (potentially leading to another channel at the end of the chain etc). This one uses trig and inverse trig (in the form of sin and arcsin) to create delicious console-style saturation. Very pleasing sound even with a single stereo channel going into the final 2-bus. There might be more to come from Chris on this so I'll tweak as and when.
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides
chmaha is offline   Reply With Quote
Old 03-12-2023, 04:18 PM   #146
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

New: Domar Brightness Acceleration Limiter



There was one existing airwindows plugin I'd forgotten about. Using DSP from Acceleration2. Domar is a Portuguese word which in English means "to tame". This plugin tames any nasty brightness without affecting the tonal balance of your mix. Shame it couldn't tame the nasty bright magenta title
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides

Last edited by chmaha; 03-13-2023 at 06:57 AM.
chmaha is offline   Reply With Quote
Old 03-13-2023, 06:57 AM   #147
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

Updates: Orpheus Lite and Genesis Consoles
  • Fix missing routing in Orpheus Lite B template
  • Add templates to Genesis Console metapackage
I realized that Orpheus Lite B template channels were not routed to the final 2-bus so that's now fixed. I also added two similar templates for the new Genesis console.
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides

Last edited by chmaha; 03-13-2023 at 12:20 PM.
chmaha is offline   Reply With Quote
Old 03-14-2023, 12:33 PM   #148
Steviekeys
Human being with feelings
 
Join Date: Jun 2016
Location: UK
Posts: 285
Default

Quote:
Originally Posted by chmaha View Post
Using DSP from airwindows Tape (redux) to which I added an output gain slider (useful!). It's a good one. Stick on the final 2-bus and enjoy. It's apparently Chris' ultimate mastering tape emulation (minus the flutter etc) now made more ultimate with control over the output
I'll have to try this now it's got an output. I had occasionally used totape6 I think
Steviekeys is offline   Reply With Quote
Old 03-14-2023, 01:17 PM   #149
Steviekeys
Human being with feelings
 
Join Date: Jun 2016
Location: UK
Posts: 285
Default

New mode for RCDither experimental

HD fractal

I think it is as good as the original mode in many ways.
The first fractal mode sounds rubbish by comparison now, I may rename it.

https://stash.reaper.fm/v/46337/RCDi...erimental.jsfx
Steviekeys is offline   Reply With Quote
Old 03-14-2023, 04:18 PM   #150
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default New: Biquadicus

New: Biquadicus Biquad Filters



Using DSP from airwindows Biquad, BiquadDouble and BiquadTriple. Yes, another jsfx port that doesn't exist in airwindows world. Three biquadratic plugins rolled into one: single, double and triple with four different types: lowpass, highpass, bandpass and notch. Useful? Perhaps.
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides

Last edited by chmaha; 03-14-2023 at 04:27 PM.
chmaha is offline   Reply With Quote
Old 03-15-2023, 04:04 PM   #151
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

NEW: SAW — Seriously Amazing Widener



Using DSP from airwindows Srsly. Don't panic! This isn't a mistake. This is the DSP from the original Srsly. I've renamed the version based on Srsly2 to SAW2 and renamed at the file level too.

This is apparently the best (and less extreme range) version, at least according to airwindopedia.txt.
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides

Last edited by chmaha; 03-18-2023 at 04:45 PM.
chmaha is offline   Reply With Quote
Old 03-16-2023, 12:28 PM   #152
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default Essenza Dither (16-bit)

NEW: Essenza Dither (16-bit)



Using DSP from airwindows RawTimbers and RawGlitters. Essenza = essense (truncation) of PirateDither and Stan (aka DitherMeTimbers and StudioTan). Choose between "Sotto" (below) and "Sopra" (above) for truncation favoring lows and highs respectively. Only 16-bit as you already know my science talk about why 24-bit dither/truncation is unnecessary.

Why Italian this time around? I'm kinda obsessed with L'amica geniale aka "My Brilliant Friend".
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides

Last edited by chmaha; 03-17-2023 at 04:49 AM.
chmaha is offline   Reply With Quote
Old 03-18-2023, 04:38 PM   #153
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

NEW: Phasity Delay Timing Tool



Using DSP from airwindows SampleDelay. You have sliders for 0–100ms, 0–10 samples then 0–1 sample (i.e. fraction of a single sample) then the inverse/wet slider.

For a regular delay effect, maybe use A-coo-sticks (Tape Delay Echo) but for fixing out-of-phase multi-mike setups, this is golden. For spot microphones that need delaying, turn the 4th slider fully inverse, find the values that cancel out the signal as much as possible by moving any or all of the top three sliders then switch to fully wet for the most in-phase sound.

Merging's panNoir for the masses
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides
chmaha is offline   Reply With Quote
Old 03-21-2023, 02:17 AM   #154
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default Phasity: small bugfix from airwindows

NEW: Phasity Delay Timing Tool v1.1
  • Small change to a conditional by Chris from airwindows
Code:
(gcount < 1 || gcount > maxtime) ? gcount = maxtime;
on line 47 becomes

Code:
(gcount < 0 || gcount > maxtime) ? gcount = maxtime;
EDIT: I've also been playing with switching out the milliseconds for meters (not released this yet):



I changed the max value to 20m (to match panNoir). It might be useful in orchestral recordings where engineers often measure distances to spot microphones from the main pair. Basically, I could imagine setting the first slider to the measured distance (for an approximate starting point) then using the second and third to hone in on the most in-phase sound. panNoir addresses all sorts of cool things like differing distances to the left and right of the main pair (including pattern type, angle etc) but that's a mathematical coding project for further down the line.
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides

Last edited by chmaha; 03-21-2023 at 04:52 PM.
chmaha is offline   Reply With Quote
Old 03-25-2023, 02:24 AM   #155
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

NEW: Phasity Delay Timing Tool v1.2



I've changed things up a bit Now there's a slider that allows you to dial in the horizontal distance in meters from a spot microphone to your main pair (0–20m) and then another slider to enter the height of your main pair minus the height of your spot (0–10m). A bit of trig later and you have a pretty good behind-the-scenes delay value in ms which you can then further tweak using the Samples and Subsample sliders.

If you want the original airwindows offering, just pin version 1.1. Otherwise, this should be useful for classical engineers. There's potential for it to become an "RC" series plugin but there's lots more to do in order to get it into panNoir territory.
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides
chmaha is offline   Reply With Quote
Old 03-25-2023, 07:50 AM   #156
Zeno
Human being with feelings
 
Zeno's Avatar
 
Join Date: Sep 2018
Location: HH
Posts: 916
Default

Quote:
Originally Posted by chmaha View Post
NEW: Phasity Delay Timing Tool v1.2

I've changed things up a bit Now there's a slider that allows you to dial in the horizontal distance in meters from a spot microphone to your main pair (0–20m) and then another slider to enter the height of your main pair minus the height of your spot (0–10m). A bit of trig later and you have a pretty good behind-the-scenes delay value in ms which you can then further tweak using the Samples and Subsample sliders.
Cool!
But why so overcomplicated slider names?
Why not "Distance (in meters)" and "Height (in meters)"?
Pretty self-explanatory.
IMO the current naming is rather confusing.
Zeno is offline   Reply With Quote
Old 03-25-2023, 04:19 PM   #157
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

Quote:
Originally Posted by Zeno View Post
Cool!
But why so overcomplicated slider names?
Why not "Distance (in meters)" and "Height (in meters)"?
Pretty self-explanatory.
IMO the current naming is rather confusing.
Distance from/to what? Height of what? I find the details important here. I'm not saying there's not a better way to label but I find losing the detail even more confusing. For example, the height of the main pair is not from the floor but the difference between main pair and spot heights. How best to label that?
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides
chmaha is offline   Reply With Quote
Old 03-26-2023, 10:45 AM   #158
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

NEW: Multisine Chebyshev Filter



I was going to include this in my ReaClassical repo then had second thoughts as it doesn't seem particularly useful. However, I didn't want to waste the porting effort so here you go:
Code:
Version: 1.0
desc:Multisine Chebyshev Filter (chmaha)
author: chmaha
about:
  Uses DSP from airwindows "Pafnuty2" by Chris Johnson
  https://github.com/airwindows/airwindows/tree/master/plugins/LinuxVST/src/Pafnuty2 (MIT License)
  JSFX version released under GPLv3 license

slider1:0<-1,1,0.01>Second
slider2:0<-1,1,0.01>Third
slider3:0<-1,1,0.01>Fourth
slider4:0<-1,1,0.01>Fifth
slider5:0<-1,1,0.01>Sixth
slider6:0<-1,1,0.01>Seventh
slider7:0<-1,1,0.01>Eighth
slider8:0<-1,1,0.01>Ninth
slider9:0<-1,1,0.01>Tenth
slider10:0<-1,1,0.01>Inv/Wet

in_pin:left input
in_pin:right input
out_pin:left output
out_pin:right output

@init

@slider

@block

second = slider1*1.0;
second = second * abs(second);
third = -slider2*0.60;
third = third * abs(third);
fourth = -slider3*0.60;
fourth = fourth * abs(fourth);
fifth = slider4*0.45;
fifth = fifth * abs(fifth);
sixth = slider5*0.45;
sixth = sixth * abs(sixth);
seventh = -slider6*0.38;
seventh = seventh * abs(seventh);
eighth = -slider7*0.38;
eighth = eighth * abs(eighth);
ninth = slider8*0.35;
ninth = ninth * abs(ninth);
tenth = slider9*0.35;
tenth = tenth * abs(tenth);
amount = slider10;
amount = amount * abs(amount);

@sample
inputSampleL = spl0;
inputSampleR = spl1;

effect = 0.0;
inP2 = inputSampleL * inputSampleL;
inP3 = inP2 * inputSampleL;
inP4 = inP3 * inputSampleL;
inP5 = inP4 * inputSampleL;
inP6 = inP5 * inputSampleL;
inP7 = inP6 * inputSampleL;
inP8 = inP7 * inputSampleL;
inP9 = inP8 * inputSampleL;
inP10 = inP9 * inputSampleL;

(second != 0.0) ?
(
  chebyshev = (2 * inP2);
  effect += (chebyshev * second);
);
(third != 0.0) ?
(
  chebyshev = (4 * inP3) - (3*inputSampleL);
  effect += (chebyshev * third);
);
(fourth != 0.0) ?
(
  chebyshev = (8 * inP4) - (8 * inP2);
  effect += (chebyshev * fourth);
);
(fifth != 0.0) ?
(
  chebyshev = (16 * inP5) - (20 * inP3) + (5*inputSampleL);
  effect += (chebyshev * fifth);
);
(sixth != 0.0) ?
(
  chebyshev = (32 * inP6) - (48 * inP4) + (18 * inP2);
  effect += (chebyshev * sixth);
);
(seventh != 0.0) ?
(
  chebyshev = (64 * inP7) - (112 * inP5) + (56 * inP3) - (7*inputSampleL);
  effect += (chebyshev * seventh);
);
(eighth != 0.0) ?
(
  chebyshev = (128 * inP8) - (256 * inP6) + (160 * inP4) - (32 * inP2);
  effect += (chebyshev * eighth);
);
(ninth != 0.0) ?
(
  chebyshev = (256 * inP9) - (576 * inP7) + (432 * inP5) - (120 * inP3) + (9*inputSampleL);
  effect += (chebyshev * ninth);
);
(tenth != 0.0) ?
(
  chebyshev = (512 * inP10) - (1280 * inP8) + (1120 * inP6) - (400 * inP4) + (50 * inP2);
  effect += (chebyshev * tenth);
);

inputSampleL += (effect * amount);

effect = 0.0;
inP2 = inputSampleR * inputSampleR;
inP3 = inP2 * inputSampleR;
inP4 = inP3 * inputSampleR;
inP5 = inP4 * inputSampleR;
inP6 = inP5 * inputSampleR;
inP7 = inP6 * inputSampleR;
inP8 = inP7 * inputSampleR;
inP9 = inP8 * inputSampleR;
inP10 = inP9 * inputSampleR;

(second != 0.0) ?
(
  chebyshev = (2 * inP2);
  effect += (chebyshev * second);
);
(third != 0.0) ?
(
  chebyshev = (4 * inP3) - (3*inputSampleR);
  effect += (chebyshev * third);
);
(fourth != 0.0) ?
(
  chebyshev = (8 * inP4) - (8 * inP2);
  effect += (chebyshev * fourth);
);
(fifth != 0.0) ?
(
  chebyshev = (16 * inP5) - (20 * inP3) + (5*inputSampleR);
  effect += (chebyshev * fifth);
);
(sixth != 0.0) ?
(
  chebyshev = (32 * inP6) - (48 * inP4) + (18 * inP2);
  effect += (chebyshev * sixth);
);
(seventh != 0.0) ?
(
  chebyshev = (64 * inP7) - (112 * inP5) + (56 * inP3) - (7*inputSampleR);
  effect += (chebyshev * seventh);
);
(eighth != 0.0) ?
(
  chebyshev = (128 * inP8) - (256 * inP6) + (160 * inP4) - (32 * inP2);
  effect += (chebyshev * eighth);
);
(ninth != 0.0) ?
(
  chebyshev = (256 * inP9) - (576 * inP7) + (432 * inP5) - (120 * inP3) + (9*inputSampleR);
  effect += (chebyshev * ninth);
);
(tenth != 0.0) ?
(
  chebyshev = (512 * inP10) - (1280 * inP8) + (1120 * inP6) - (400 * inP4) + (50 * inP2);
  effect += (chebyshev * tenth);
);

inputSampleR += (effect * amount);

spl0 = inputSampleL;
spl1 = inputSampleR;
Here are the types of plugins that might get me motivated to add another airwindows jsfx port to my repo: 1) Dithers (though difficult to beat those in Six-Dither Sid), 2) Updates to console/channel emulations and other related "analogifiers" 3) Reverbs (if they reach my rather high quality threshold).
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides

Last edited by chmaha; 03-26-2023 at 03:02 PM.
chmaha is offline   Reply With Quote
Old 04-03-2023, 01:51 PM   #159
chmaha
Human being with feelings
 
chmaha's Avatar
 
Join Date: Feb 2021
Posts: 2,261
Default

NEW: NW8 Plate Reverb

Here's the latest and greatest airwindows plate reverb ported to jsfx. I'm not including it in my repo because I don't think it meets my HQ reverb criteria. YMMV.

Code:
Version: 1.0
desc:NW8 Plate Reverb (chmaha)
author: chmaha
about:
  Uses DSP from airwindows "kPlateA" by Chris Johnson
  https://github.com/airwindows/airwindows/tree/master/plugins/LinuxVST/src/kPlateA (MIT License)
  JSFX version released under GPLv3 license

slider1:1<0,1,0.01>Input Pad
slider2:0.5<0,1,0.01>Damping
slider3:1<0,1,0.01>Low Cut
slider4:0<0,1,0.01>Predelay
slider5:0.25<0,1,0.01>Wetness

in_pin:left input
in_pin:right input
out_pin:left output
out_pin:right output

@init

earlyA = 61; earlyB = 499; earlyC = 107; earlyD = 127; earlyE = 607; 
earlyF = 313; earlyG = 563; earlyH = 47; earlyI = 409; predelay = 24010;
delayA = 631; delayB = 281; delayC = 97; delayD = 709; delayE = 307; 
delayF = 149; delayG = 313; delayH = 37; delayI = 659; delayJ = 701; 
delayK = 13; delayL = 733; delayM = 773; delayN = 23; delayO = 61;
delayP = 787; delayQ = 83; delayR = 691; delayS = 5; delayT = 587; 
delayU = 829; delayV = 449; delayW = 53; delayX = 503; delayY = 181;

freemem = 0;

eAL = freemem; freemem += earlyA+5;
eBL = freemem; freemem += earlyB+5;
eCL = freemem; freemem += earlyC+5;
eDL = freemem; freemem += earlyD+5;
eEL = freemem; freemem += earlyE+5; 
eFL = freemem; freemem += earlyF+5;
eGL = freemem; freemem += earlyG+5;
eHL = freemem; freemem += earlyH+5;
eIL = freemem; freemem += earlyI+5;

eAR = freemem; freemem += earlyA+5;
eBR = freemem; freemem += earlyB+5;
eCR = freemem; freemem += earlyC+5;
eDR = freemem; freemem += earlyD+5;
eER = freemem; freemem += earlyE+5;
eFR = freemem; freemem += earlyF+5;
eGR = freemem; freemem += earlyG+5;
eHR = freemem; freemem += earlyH+5;
eIR = freemem; freemem += earlyI+5;

aAL = freemem; freemem += delayA+5;
aBL = freemem; freemem += delayB+5;
aCL = freemem; freemem += delayC+5;
aDL = freemem; freemem += delayD+5;
aEL = freemem; freemem += delayE+5;
aFL = freemem; freemem += delayF+5;
aGL = freemem; freemem += delayG+5;
aHL = freemem; freemem += delayH+5;
aIL = freemem; freemem += delayI+5;
aJL = freemem; freemem += delayJ+5;
aKL = freemem; freemem += delayK+5;
aLL = freemem; freemem += delayL+5;
aML = freemem; freemem += delayM+5;
aNL = freemem; freemem += delayN+5;
aOL = freemem; freemem += delayO+5;
aPL = freemem; freemem += delayP+5;
aQL = freemem; freemem += delayQ+5;
aRL = freemem; freemem += delayR+5;
aSL = freemem; freemem += delayS+5;
aTL = freemem; freemem += delayT+5;
aUL = freemem; freemem += delayU+5;
aVL = freemem; freemem += delayV+5;
aWL = freemem; freemem += delayW+5;
aXL = freemem; freemem += delayX+5;
aYL = freemem; freemem += delayY+5;

aAR = freemem; freemem += delayA+5;
aBR = freemem; freemem += delayB+5;
aCR = freemem; freemem += delayC+5;
aDR = freemem; freemem += delayD+5;
aER = freemem; freemem += delayE+5;
aFR = freemem; freemem += delayF+5;
aGR = freemem; freemem += delayG+5;
aHR = freemem; freemem += delayH+5;
aIR = freemem; freemem += delayI+5;
aJR = freemem; freemem += delayJ+5;
aKR = freemem; freemem += delayK+5;
aLR = freemem; freemem += delayL+5;
aMR = freemem; freemem += delayM+5;
aNR = freemem; freemem += delayN+5;
aOR = freemem; freemem += delayO+5;
aPR = freemem; freemem += delayP+5;
aQR = freemem; freemem += delayQ+5;
aRR = freemem; freemem += delayR+5;
aSR = freemem; freemem += delayS+5;
aTR = freemem; freemem += delayT+5;
aUR = freemem; freemem += delayU+5;
aVR = freemem; freemem += delayV+5;
aWR = freemem; freemem += delayW+5;
aXR = freemem; freemem += delayX+5;
aYR = freemem; freemem += delayY+5;

aZL = freemem; freemem += predelay+5;
aZR = freemem; freemem += predelay+5;

lastRefL = freemem; freemem += 7;

lastRefR = freemem; freemem += 7;

fixA = freemem; freemem += 11;
fixB = freemem; freemem += 11;
fixC = freemem; freemem += 11;
fixD = freemem; freemem += 11;

gainIn = gainOutL = gainOutR = 1.0;

earlyAL = 1;
earlyBL = 1;
earlyCL = 1;
earlyDL = 1;
earlyEL = 1;
earlyFL = 1;
earlyGL = 1;
earlyHL = 1;
earlyIL = 1;

earlyAR = 1;
earlyBR = 1;
earlyCR = 1;
earlyDR = 1;
earlyER = 1;
earlyFR = 1;
earlyGR = 1;
earlyHR = 1;
earlyIR = 1;

countAL = 1;
countBL = 1;
countCL = 1;
countDL = 1;
countEL = 1;
countFL = 1;
countGL = 1;
countHL = 1;
countIL = 1;
countJL = 1;
countKL = 1;
countLL = 1;
countML = 1;
countNL = 1;
countOL = 1;
countPL = 1;
countQL = 1;
countRL = 1;
countSL = 1;
countTL = 1;
countUL = 1;
countVL = 1;
countWL = 1;
countXL = 1;
countYL = 1;

countAR = 1;
countBR = 1;
countCR = 1;
countDR = 1;  
countER = 1;
countFR = 1;
countGR = 1;
countHR = 1;
countIR = 1;
countJR = 1;
countKR = 1;
countLR = 1;
countMR = 1;
countNR = 1;
countOR = 1;
countPR = 1;
countQR = 1;
countRR = 1;
countSR = 1;
countTR = 1;
countUR = 1;
countVR = 1;
countWR = 1;
countXR = 1;
countYR = 1;

countZ = 1;

@slider

A = slider1;
B = slider2;
C = slider3;
D = slider4;
E = slider5;

@block
overallscale = 1.0;
overallscale /= 44100.0;
overallscale *= srate;

cycleEnd = floor(overallscale);
(cycleEnd < 1) ? cycleEnd = 1;
(cycleEnd > 4) ? cycleEnd = 4;
(cycle > cycleEnd-1) ? cycle = cycleEnd-1;

downRate = srate/cycleEnd;

inputPad = A;
regen = (B*0.415)+0.16;
regen = (regen*0.0001)+0.00024;
iirAmount = (C*0.3)+0.04;
iirAmount = (iirAmount*1000.0)/downRate;
earlyVolume = pow(D,2)*0.5;
adjPredelay = (downRate * earlyVolume) | 0;
wet = E*2.0;
dry = 2.0 - wet;
(wet > 1.0) ? wet = 1.0;
(wet < 0.0) ? wet = 0.0;
(dry > 1.0) ? dry = 1.0;
(dry < 0.0) ? dry = 0.0;

fixA[0] = 46.0/downRate;
fixA[1] = 0.0061504;  
fixD[0] = 22.0/downRate;
fixD[1] = 0.00144;
fixB[0] = (fixA[0] + fixA[0] + fixD[0]) / 3.0;
fixB[1] = 0.0045802;
fixC[0] = (fixA[0] + fixD[0] + fixD[0]) / 3.0;
fixC[1] = 0.0030101;
K = tan($pi * fixA[0]);
norm = 1.0 / (1.0 + K / fixA[1] + K * K);
fixA[2] = K / fixA[1] * norm;
fixA[3] = 0.0;
fixA[4] = -fixA[2];
fixA[5] = 2.0 * (K * K - 1.0) * norm;
fixA[6] = (1.0 - K / fixA[1] + K * K) * norm;

K = tan($pi * fixB[0]);
norm = 1.0 / (1.0 + K / fixB[1] + K * K);
fixB[2] = K / fixB[1] * norm;
fixB[3] = 0.0;
fixB[4] = -fixB[2];
fixB[5] = 2.0 * (K * K - 1.0) * norm;
fixB[6] = (1.0 - K / fixB[1] + K * K) * norm;

K = tan($pi * fixC[0]);
norm = 1.0 / (1.0 + K / fixC[1] + K * K);
fixC[2] = K / fixC[1] * norm;
fixC[3] = 0.0;
fixC[4] = -fixC[2];
fixC[5] = 2.0 * (K * K - 1.0) * norm;
fixC[6] = (1.0 - K / fixC[1] + K * K) * norm;

K = tan($pi * fixD[0]);
norm = 1.0 / (1.0 + K / fixD[1] + K * K);
fixD[2] = K / fixD[1] * norm;
fixD[3] = 0.0;
fixD[4] = -fixD[2];
fixD[5] = 2.0 * (K * K - 1.0) * norm;
fixD[6] = (1.0 - K / fixD[1] + K * K) * norm;

@sample
inputSampleL = spl0;
inputSampleR = spl1;

drySampleL = inputSampleL;
drySampleR = inputSampleR;

cycle+=1;
(cycle == cycleEnd) ? ( //hit the end point and we do a reverb sample
  (inputPad < 1.0) ? (
    inputSampleL *= inputPad;
    inputSampleR *= inputPad;
  );
  outSample;
  outSample = (inputSampleL + prevInAL)*0.5;
  prevInAL = inputSampleL; inputSampleL = outSample;
  outSample = (inputSampleR + prevInAR)*0.5;
  prevInAR = inputSampleR; inputSampleR = outSample;
  //10k filter on input
  
  iirAL = (iirAL * (1.0 - iirAmount)) + (inputSampleL * iirAmount);
  inputSampleL = inputSampleL - iirAL;
  iirAR = (iirAR * (1.0 - iirAmount)) + (inputSampleR * iirAmount);
  inputSampleR = inputSampleR - iirAR;
  //600hz highpass on input
  
  inputSampleL *= 0.5; inputSampleR *= 0.5;
  (gainIn < 0.0078125) ? gainIn = 0.0078125; (gainIn > 1.0) ? gainIn = 1.0;

  inputSampleL *= gainIn; inputSampleR *= gainIn;
  gainIn += sin((abs(inputSampleL*4)>1)?4:abs(inputSampleL*4))*pow(inputSampleL,4);
  gainIn += sin((abs(inputSampleR*4)>1)?4:abs(inputSampleR*4))*pow(inputSampleR,4);

  //begin overdrive
  (inputSampleL > 1.4137166941154) ? inputSampleL = 1.4137166941154;
  (inputSampleL < -1.4137166941154) ? inputSampleL = -1.4137166941154;
  (inputSampleL > 0.0) ? inputSampleL = (inputSampleL/2.0)*(2.8274333882308-inputSampleL)
  : inputSampleL = -(inputSampleL/-2.0)*(2.8274333882308+inputSampleL);
  //BigFastSin channel stage
  (inputSampleR > 1.4137166941154) ? inputSampleR = 1.4137166941154;
  (inputSampleR < -1.4137166941154) ? inputSampleR = -1.4137166941154;
  (inputSampleR > 0.0) ? inputSampleR = (inputSampleR/2.0)*(2.8274333882308-inputSampleR)
  : inputSampleR = -(inputSampleR/-2.0)*(2.8274333882308+inputSampleR);
  //end overdrive
  
  iirBL = (iirBL * (1.0 - iirAmount)) + (inputSampleL * iirAmount);
  inputSampleL = inputSampleL - iirBL;
  iirBR = (iirBR * (1.0 - iirAmount)) + (inputSampleR * iirAmount);
  inputSampleR = inputSampleR - iirBR;
  //600hz highpass on input
  
  outSample = (inputSampleL + prevInBL)*0.5;
  prevInBL = inputSampleL; inputSampleL = outSample;
  outSample = (inputSampleR + prevInBR)*0.5;
  prevInBR = inputSampleR; inputSampleR = outSample;
  //10k filter on input
  
  //begin allpasses
  oeAL = inputSampleL - (eAL[(earlyAL+1)-((earlyAL+1 > earlyA)?earlyA+1:0)]*0.5);
  oeBL = inputSampleL - (eBL[(earlyBL+1)-((earlyBL+1 > earlyB)?earlyB+1:0)]*0.5);
  oeCL = inputSampleL - (eCL[(earlyCL+1)-((earlyCL+1 > earlyC)?earlyC+1:0)]*0.5);
  oeCR = inputSampleR - (eCR[(earlyCR+1)-((earlyCR+1 > earlyC)?earlyC+1:0)]*0.5);
  oeFR = inputSampleR - (eFR[(earlyFR+1)-((earlyFR+1 > earlyF)?earlyF+1:0)]*0.5);
  oeIR = inputSampleR - (eIR[(earlyIR+1)-((earlyIR+1 > earlyI)?earlyI+1:0)]*0.5);
  
  eAL[earlyAL] = oeAL; oeAL *= 0.5;
  eBL[earlyBL] = oeBL; oeBL *= 0.5;
  eCL[earlyCL] = oeCL; oeCL *= 0.5;
  eCR[earlyCR] = oeCR; oeCR *= 0.5;
  eFR[earlyFR] = oeFR; oeFR *= 0.5;
  eIR[earlyIR] = oeIR; oeIR *= 0.5;
  
  earlyAL+=1; (earlyAL < 0 || earlyAL > earlyA) ? earlyAL = 0;
  earlyBL+=1; (earlyBL < 0 || earlyBL > earlyB) ? earlyBL = 0;
  earlyCL+=1; (earlyCL < 0 || earlyCL > earlyC) ? earlyCL = 0;
  earlyCR+=1; (earlyCR < 0 || earlyCR > earlyC) ? earlyCR = 0;
  earlyFR+=1; (earlyFR < 0 || earlyFR > earlyF) ? earlyFR = 0;
  earlyIR+=1; (earlyIR < 0 || earlyIR > earlyI) ? earlyIR = 0;
  
  oeAL += eAL[earlyAL-((earlyAL > earlyA)?earlyA+1:0)];
  oeBL += eBL[earlyBL-((earlyBL > earlyB)?earlyB+1:0)];
  oeCL += eCL[earlyCL-((earlyCL > earlyC)?earlyC+1:0)];
  oeCR += eCR[earlyCR-((earlyCR > earlyC)?earlyC+1:0)];
  oeFR += eFR[earlyFR-((earlyFR > earlyF)?earlyF+1:0)];
  oeIR += eIR[earlyIR-((earlyIR > earlyI)?earlyI+1:0)];
  
  oeDL = ((oeBL+oeCL)-oeAL) - (eDL[(earlyDL+1)-((earlyDL+1 > earlyD)?earlyD+1:0)]*0.5);
  oeEL = ((oeAL+oeCL)-oeBL) - (eEL[(earlyEL+1)-((earlyEL+1 > earlyE)?earlyE+1:0)]*0.5);
  oeFL = ((oeAL+oeBL)-oeCL) - (eFL[(earlyFL+1)-((earlyFL+1 > earlyF)?earlyF+1:0)]*0.5);
  oeBR = ((oeFR+oeIR)-oeCR) - (eBR[(earlyBR+1)-((earlyBR+1 > earlyB)?earlyB+1:0)]*0.5);
  oeER = ((oeCR+oeIR)-oeFR) - (eER[(earlyER+1)-((earlyER+1 > earlyE)?earlyE+1:0)]*0.5);
  oeHR = ((oeCR+oeFR)-oeIR) - (eHR[(earlyHR+1)-((earlyHR+1 > earlyH)?earlyH+1:0)]*0.5);
  
  eDL[earlyDL] = oeDL; oeDL *= 0.5;
  eEL[earlyEL] = oeEL; oeEL *= 0.5;
  eFL[earlyFL] = oeFL; oeFL *= 0.5;
  eBR[earlyBR] = oeBR; oeBR *= 0.5;
  eER[earlyER] = oeER; oeER *= 0.5;
  eHR[earlyHR] = oeHR; oeHR *= 0.5;
  
  earlyDL+=1; (earlyDL < 0 || earlyDL > earlyD) ? earlyDL = 0;
  earlyEL+=1; (earlyEL < 0 || earlyEL > earlyE) ? earlyEL = 0;
  earlyFL+=1; (earlyFL < 0 || earlyFL > earlyF) ? earlyFL = 0;
  earlyBR+=1; (earlyBR < 0 || earlyBR > earlyB) ? earlyBR = 0;
  earlyER+=1; (earlyER < 0 || earlyER > earlyE) ? earlyER = 0;
  earlyHR+=1; (earlyHR < 0 || earlyHR > earlyH) ? earlyHR = 0;
  
  oeDL += eDL[earlyDL-((earlyDL > earlyD)?earlyD+1:0)];
  oeEL += eEL[earlyEL-((earlyEL > earlyE)?earlyE+1:0)];
  oeFL += eFL[earlyFL-((earlyFL > earlyF)?earlyF+1:0)];
  oeBR += eBR[earlyBR-((earlyBR > earlyB)?earlyB+1:0)];
  oeER += eER[earlyER-((earlyER > earlyE)?earlyE+1:0)];
  oeHR += eHR[earlyHR-((earlyHR > earlyH)?earlyH+1:0)];
  
  oeGL = ((oeEL + oeFL) - oeDL) - (eGL[(earlyGL+1)-((earlyGL+1 > earlyG)?earlyG+1:0)]*0.5);
  oeHL = ((oeDL + oeFL) - oeEL) - (eHL[(earlyHL+1)-((earlyHL+1 > earlyH)?earlyH+1:0)]*0.5);
  oeIL = ((oeDL + oeEL) - oeFL) - (eIL[(earlyIL+1)-((earlyIL+1 > earlyI)?earlyI+1:0)]*0.5);
  oeAR = ((oeER + oeHR) - oeBR) - (eAR[(earlyAR+1)-((earlyAR+1 > earlyA)?earlyA+1:0)]*0.5);
  oeDR = ((oeBR + oeHR) - oeER) - (eDR[(earlyDR+1)-((earlyDR+1 > earlyD)?earlyD+1:0)]*0.5);
  oeGR = ((oeBR + oeER) - oeHR) - (eGR[(earlyGR+1)-((earlyGR+1 > earlyG)?earlyG+1:0)]*0.5);
  
  eGL[earlyGL] = oeGL; oeGL *= 0.5;
  eHL[earlyHL] = oeHL; oeHL *= 0.5;
  eIL[earlyIL] = oeIL; oeIL *= 0.5;
  eAR[earlyAR] = oeAR; oeAR *= 0.5;
  eDR[earlyDR] = oeDR; oeDR *= 0.5;
  eGR[earlyGR] = oeGR; oeGR *= 0.5;
  
  earlyGL+=1; (earlyGL < 0 || earlyGL > earlyG) ? earlyGL = 0;
  earlyHL+=1; (earlyHL < 0 || earlyHL > earlyH) ? earlyHL = 0;
  earlyIL+=1; (earlyIL < 0 || earlyIL > earlyI) ? earlyIL = 0;
  earlyAR+=1; (earlyAR < 0 || earlyAR > earlyA) ? earlyAR = 0;
  earlyDR+=1; (earlyDR < 0 || earlyDR > earlyD) ? earlyDR = 0;
  earlyGR+=1; (earlyGR < 0 || earlyGR > earlyG) ? earlyGR = 0;
  
  oeGL += eGL[earlyGL-((earlyGL > earlyG)?earlyG+1:0)];
  oeHL += eHL[earlyHL-((earlyHL > earlyH)?earlyH+1:0)];
  oeIL += eIL[earlyIL-((earlyIL > earlyI)?earlyI+1:0)];
  oeAR += eAR[earlyAR-((earlyAR > earlyA)?earlyA+1:0)];
  oeDR += eDR[earlyDR-((earlyDR > earlyD)?earlyD+1:0)];
  oeGR += eGR[earlyGR-((earlyGR > earlyG)?earlyG+1:0)];
  
  //allpasses predelay
  aZL[countZ] = (oeGL + oeHL + oeIL)*0.25;
  aZR[countZ] = (oeAR + oeDR + oeGR)*0.25;
  countZ+=1; (countZ < 0 || countZ > adjPredelay) ? countZ = 0;
  inputSampleL = aZL[countZ-((countZ > adjPredelay)?adjPredelay+1:0)];
  inputSampleR = aZR[countZ-((countZ > adjPredelay)?adjPredelay+1:0)];
  //end allpasses
  
  aAL[countAL] = inputSampleL + (feedbackAL * regen);
  aBL[countBL] = inputSampleL + (feedbackBL * regen);
  aCL[countCL] = inputSampleL + (feedbackCL * regen);
  aDL[countDL] = inputSampleL + (feedbackDL * regen);
  aEL[countEL] = inputSampleL + (feedbackEL * regen);
  
  aER[countER] = inputSampleR + (feedbackER * regen);
  aJR[countJR] = inputSampleR + (feedbackJR * regen);
  aOR[countOR] = inputSampleR + (feedbackOR * regen);
  aTR[countTR] = inputSampleR + (feedbackTR * regen);
  aYR[countYR] = inputSampleR + (feedbackYR * regen);
  
  countAL+=1; (countAL < 0 || countAL > delayA) ? countAL = 0;
  countBL+=1; (countBL < 0 || countBL > delayB) ? countBL = 0;
  countCL+=1; (countCL < 0 || countCL > delayC) ? countCL = 0;
  countDL+=1; (countDL < 0 || countDL > delayD) ? countDL = 0;
  countEL+=1; (countEL < 0 || countEL > delayE) ? countEL = 0;
  
  countER+=1; (countER < 0 || countER > delayE) ? countER = 0;
  countJR+=1; (countJR < 0 || countJR > delayJ) ? countJR = 0;
  countOR+=1; (countOR < 0 || countOR > delayO) ? countOR = 0;
  countTR+=1; (countTR < 0 || countTR > delayT) ? countTR = 0;
  countYR+=1; (countYR < 0 || countYR > delayY) ? countYR = 0;
  
  outAL = aAL[countAL-((countAL > delayA)?delayA+1:0)];
  outBL = aBL[countBL-((countBL > delayB)?delayB+1:0)];
  outCL = aCL[countCL-((countCL > delayC)?delayC+1:0)];
  outDL = aDL[countDL-((countDL > delayD)?delayD+1:0)];
  outEL = aEL[countEL-((countEL > delayE)?delayE+1:0)];
  
  outER = aER[countER-((countER > delayE)?delayE+1:0)];
  outJR = aJR[countJR-((countJR > delayJ)?delayJ+1:0)];
  outOR = aOR[countOR-((countOR > delayO)?delayO+1:0)];
  outTR = aTR[countTR-((countTR > delayT)?delayT+1:0)];
  outYR = aYR[countYR-((countYR > delayY)?delayY+1:0)];
  
  //-------- one
  
  outSample = (outAL * fixA[2]) + fixA[7];
  fixA[7] = (outAL * fixA[3]) - (outSample * fixA[5]) + fixA[8];
  fixA[8] = (outAL * fixA[4]) - (outSample * fixA[6]);
  outAL = outSample; //fixed biquad
  
  outSample = (outER * fixA[2]) + fixA[9];
  fixA[9] = (outER * fixA[3]) - (outSample * fixA[5]) + fixA[10];
  fixA[10] = (outER * fixA[4]) - (outSample * fixA[6]);
  outER = outSample; //fixed biquad
  
  //-------- mulch
  outSample = (outBL + prevMulchAL)*0.5;
  prevMulchAL = outBL; outBL = outSample;
  outSample = (outJR + prevMulchAR)*0.5;
  prevMulchAR = outJR; outJR = outSample;
  //-------- filtered (one path in five, feeding the rest of the matrix
  
  aFL[countFL] = ((outAL*3.0) - ((outBL + outCL + outDL + outEL)*2.0));
  aGL[countGL] = ((outBL*3.0) - ((outAL + outCL + outDL + outEL)*2.0));
  aHL[countHL] = ((outCL*3.0) - ((outAL + outBL + outDL + outEL)*2.0));
  aIL[countIL] = ((outDL*3.0) - ((outAL + outBL + outCL + outEL)*2.0));
  aJL[countJL] = ((outEL*3.0) - ((outAL + outBL + outCL + outDL)*2.0));
  
  aDR[countDR] = ((outER*3.0) - ((outJR + outOR + outTR + outYR)*2.0));
  aIR[countIR] = ((outJR*3.0) - ((outER + outOR + outTR + outYR)*2.0));
  aNR[countNR] = ((outOR*3.0) - ((outER + outJR + outTR + outYR)*2.0));
  aSR[countSR] = ((outTR*3.0) - ((outER + outJR + outOR + outYR)*2.0));
  aXR[countXR] = ((outYR*3.0) - ((outER + outJR + outOR + outTR)*2.0));
  
  countFL+=1; (countFL < 0 || countFL > delayF) ? countFL = 0;
  countGL+=1; (countGL < 0 || countGL > delayG) ? countGL = 0;
  countHL+=1; (countHL < 0 || countHL > delayH) ? countHL = 0;
  countIL+=1; (countIL < 0 || countIL > delayI) ? countIL = 0;
  countJL+=1; (countJL < 0 || countJL > delayJ) ? countJL = 0;
  
  countDR+=1; (countDR < 0 || countDR > delayD) ? countDR = 0;
  countIR+=1; (countIR < 0 || countIR > delayI) ? countIR = 0;
  countNR+=1; (countNR < 0 || countNR > delayN) ? countNR = 0;
  countSR+=1; (countSR < 0 || countSR > delayS) ? countSR = 0;
  countXR+=1; (countXR < 0 || countXR > delayX) ? countXR = 0;
  
  outFL = aFL[countFL-((countFL > delayF)?delayF+1:0)];
  outGL = aGL[countGL-((countGL > delayG)?delayG+1:0)];
  outHL = aHL[countHL-((countHL > delayH)?delayH+1:0)];
  outIL = aIL[countIL-((countIL > delayI)?delayI+1:0)];
  outJL = aJL[countJL-((countJL > delayJ)?delayJ+1:0)];
  
  outDR = aDR[countDR-((countDR > delayD)?delayD+1:0)];
  outIR = aIR[countIR-((countIR > delayI)?delayI+1:0)];
  outNR = aNR[countNR-((countNR > delayN)?delayN+1:0)];
  outSR = aSR[countSR-((countSR > delayS)?delayS+1:0)];
  outXR = aXR[countXR-((countXR > delayX)?delayX+1:0)];
  
  //-------- mulch
  
  outSample = (outFL * fixB[2]) + fixB[7];
  fixB[7] = (outFL * fixB[3]) - (outSample * fixB[5]) + fixB[8];
  fixB[8] = (outFL * fixB[4]) - (outSample * fixB[6]);
  outFL = outSample; //fixed biquad
  
  outSample = (outDR * fixB[2]) + fixB[9];
  fixB[9] = (outDR * fixB[3]) - (outSample * fixB[5]) + fixB[10];
  fixB[10] = (outDR * fixB[4]) - (outSample * fixB[6]);
  outDR = outSample; //fixed biquad      
  
  outSample = (outGL + prevMulchBL)*0.5;
  prevMulchBL = outGL; outGL = outSample;
  outSample = (outIR + prevMulchBR)*0.5;
  prevMulchBR = outIR; outIR = outSample;
  
  //-------- two
  
  aKL[countKL] = ((outFL*3.0) - ((outGL + outHL + outIL + outJL)*2.0));
  aLL[countLL] = ((outGL*3.0) - ((outFL + outHL + outIL + outJL)*2.0));
  aML[countML] = ((outHL*3.0) - ((outFL + outGL + outIL + outJL)*2.0));
  aNL[countNL] = ((outIL*3.0) - ((outFL + outGL + outHL + outJL)*2.0));
  aOL[countOL] = ((outJL*3.0) - ((outFL + outGL + outHL + outIL)*2.0));
  
  aCR[countCR] = ((outDR*3.0) - ((outIR + outNR + outSR + outXR)*2.0));
  aHR[countHR] = ((outIR*3.0) - ((outDR + outNR + outSR + outXR)*2.0));
  aMR[countMR] = ((outNR*3.0) - ((outDR + outIR + outSR + outXR)*2.0));
  aRR[countRR] = ((outSR*3.0) - ((outDR + outIR + outNR + outXR)*2.0));
  aWR[countWR] = ((outXR*3.0) - ((outDR + outIR + outNR + outSR)*2.0));
  
  countKL+=1; (countKL < 0 || countKL > delayK) ? countKL = 0;
  countLL+=1; (countLL < 0 || countLL > delayL) ? countLL = 0;
  countML+=1; (countML < 0 || countML > delayM) ? countML = 0;
  countNL+=1; (countNL < 0 || countNL > delayN) ? countNL = 0;
  countOL+=1; (countOL < 0 || countOL > delayO) ? countOL = 0;
  
  countCR+=1; (countCR < 0 || countCR > delayC) ? countCR = 0;
  countHR+=1; (countHR < 0 || countHR > delayH) ? countHR = 0;
  countMR+=1; (countMR < 0 || countMR > delayM) ? countMR = 0;
  countRR+=1; (countRR < 0 || countRR > delayR) ? countRR = 0;
  countWR+=1; (countWR < 0 || countWR > delayW) ? countWR = 0;
  
  outKL = aKL[countKL-((countKL > delayK)?delayK+1:0)];
  outLL = aLL[countLL-((countLL > delayL)?delayL+1:0)];
  outML = aML[countML-((countML > delayM)?delayM+1:0)];
  outNL = aNL[countNL-((countNL > delayN)?delayN+1:0)];
  outOL = aOL[countOL-((countOL > delayO)?delayO+1:0)];
  
  outCR = aCR[countCR-((countCR > delayC)?delayC+1:0)];
  outHR = aHR[countHR-((countHR > delayH)?delayH+1:0)];
  outMR = aMR[countMR-((countMR > delayM)?delayM+1:0)];
  outRR = aRR[countRR-((countRR > delayR)?delayR+1:0)];
  outWR = aWR[countWR-((countWR > delayW)?delayW+1:0)];
  
  //-------- mulch
  
  outSample = (outKL * fixC[2]) + fixC[7];
  fixC[7] = (outKL * fixC[3]) - (outSample * fixC[5]) + fixC[8];
  fixC[8] = (outKL * fixC[4]) - (outSample * fixC[6]);
  outKL = outSample; //fixed biquad
  
  outSample = (outCR * fixC[2]) + fixC[9];
  fixC[9] = (outCR * fixC[3]) - (outSample * fixC[5]) + fixC[10];
  fixC[10] = (outCR * fixC[4]) - (outSample * fixC[6]);
  outCR = outSample; //fixed biquad      
  
  outSample = (outLL + prevMulchCL)*0.5;
  prevMulchCL = outLL; outLL = outSample;
  outSample = (outHR + prevMulchCR)*0.5;
  prevMulchCR = outHR; outHR = outSample;
  
  //-------- three
  
  aPL[countPL] = ((outKL*3.0) - ((outLL + outML + outNL + outOL)*2.0));
  aQL[countQL] = ((outLL*3.0) - ((outKL + outML + outNL + outOL)*2.0));
  aRL[countRL] = ((outML*3.0) - ((outKL + outLL + outNL + outOL)*2.0));
  aSL[countSL] = ((outNL*3.0) - ((outKL + outLL + outML + outOL)*2.0));
  aTL[countTL] = ((outOL*3.0) - ((outKL + outLL + outML + outNL)*2.0));
  
  aBR[countBR] = ((outCR*3.0) - ((outHR + outMR + outRR + outWR)*2.0));
  aGR[countGR] = ((outHR*3.0) - ((outCR + outMR + outRR + outWR)*2.0));
  aLR[countLR] = ((outMR*3.0) - ((outCR + outHR + outRR + outWR)*2.0));
  aQR[countQR] = ((outRR*3.0) - ((outCR + outHR + outMR + outWR)*2.0));
  aVR[countVR] = ((outWR*3.0) - ((outCR + outHR + outMR + outRR)*2.0));
  
  countPL+=1; (countPL < 0 || countPL > delayP) ? countPL = 0;
  countQL+=1; (countQL < 0 || countQL > delayQ) ? countQL = 0;
  countRL+=1; (countRL < 0 || countRL > delayR) ? countRL = 0;
  countSL+=1; (countSL < 0 || countSL > delayS) ? countSL = 0;
  countTL+=1; (countTL < 0 || countTL > delayT) ? countTL = 0;
  
  countBR+=1; (countBR < 0 || countBR > delayB) ? countBR = 0;
  countGR+=1; (countGR < 0 || countGR > delayG) ? countGR = 0;
  countLR+=1; (countLR < 0 || countLR > delayL) ? countLR = 0;
  countQR+=1; (countQR < 0 || countQR > delayQ) ? countQR = 0;
  countVR+=1; (countVR < 0 || countVR > delayV) ? countVR = 0;
  
  outPL = aPL[countPL-((countPL > delayP)?delayP+1:0)];
  outQL = aQL[countQL-((countQL > delayQ)?delayQ+1:0)];
  outRL = aRL[countRL-((countRL > delayR)?delayR+1:0)];
  outSL = aSL[countSL-((countSL > delayS)?delayS+1:0)];
  outTL = aTL[countTL-((countTL > delayT)?delayT+1:0)];
  
  outBR = aBR[countBR-((countBR > delayB)?delayB+1:0)];
  outGR = aGR[countGR-((countGR > delayG)?delayG+1:0)];
  outLR = aLR[countLR-((countLR > delayL)?delayL+1:0)];
  outQR = aQR[countQR-((countQR > delayQ)?delayQ+1:0)];
  outVR = aVR[countVR-((countVR > delayV)?delayV+1:0)];
  
  //-------- mulch
  
  outSample = (outPL * fixD[2]) + fixD[7];
  fixD[7] = (outPL * fixD[3]) - (outSample * fixD[5]) + fixD[8];
  fixD[8] = (outPL * fixD[4]) - (outSample * fixD[6]);
  outPL = outSample; //fixed biquad
  
  outSample = (outBR * fixD[2]) + fixD[9];
  fixD[9] = (outBR * fixD[3]) - (outSample * fixD[5]) + fixD[10];
  fixD[10] = (outBR * fixD[4]) - (outSample * fixD[6]);
  outBR = outSample; //fixed biquad      
  
  outSample = (outQL + prevMulchDL)*0.5;
  prevMulchDL = outQL; outQL = outSample;
  outSample = (outGR + prevMulchDR)*0.5;
  prevMulchDR = outGR; outGR = outSample;
  
  //-------- four
  
  aUL[countUL] = ((outPL*3.0) - ((outQL + outRL + outSL + outTL)*2.0));
  aVL[countVL] = ((outQL*3.0) - ((outPL + outRL + outSL + outTL)*2.0));
  aWL[countWL] = ((outRL*3.0) - ((outPL + outQL + outSL + outTL)*2.0));
  aXL[countXL] = ((outSL*3.0) - ((outPL + outQL + outRL + outTL)*2.0));
  aYL[countYL] = ((outTL*3.0) - ((outPL + outQL + outRL + outSL)*2.0));
  
  aAR[countAR] = ((outBR*3.0) - ((outGR + outLR + outQR + outVR)*2.0));
  aFR[countFR] = ((outGR*3.0) - ((outBR + outLR + outQR + outVR)*2.0));
  aKR[countKR] = ((outLR*3.0) - ((outBR + outGR + outQR + outVR)*2.0));
  aPR[countPR] = ((outQR*3.0) - ((outBR + outGR + outLR + outVR)*2.0));
  aUR[countUR] = ((outVR*3.0) - ((outBR + outGR + outLR + outQR)*2.0));
  
  countUL+=1; (countUL < 0 || countUL > delayU) ? countUL = 0;
  countVL+=1; (countVL < 0 || countVL > delayV) ? countVL = 0;
  countWL+=1; (countWL < 0 || countWL > delayW) ? countWL = 0;
  countXL+=1; (countXL < 0 || countXL > delayX) ? countXL = 0;
  countYL+=1; (countYL < 0 || countYL > delayY) ? countYL = 0;
  
  countAR+=1; (countAR < 0 || countAR > delayA) ? countAR = 0;
  countFR+=1; (countFR < 0 || countFR > delayF) ? countFR = 0;
  countKR+=1; (countKR < 0 || countKR > delayK) ? countKR = 0;
  countPR+=1; (countPR < 0 || countPR > delayP) ? countPR = 0;
  countUR+=1; (countUR < 0 || countUR > delayU) ? countUR = 0;
  
  outUL = aUL[countUL-((countUL > delayU)?delayU+1:0)];
  outVL = aVL[countVL-((countVL > delayV)?delayV+1:0)];
  outWL = aWL[countWL-((countWL > delayW)?delayW+1:0)];
  outXL = aXL[countXL-((countXL > delayX)?delayX+1:0)];
  outYL = aYL[countYL-((countYL > delayY)?delayY+1:0)];
  
  outAR = aAR[countAR-((countAR > delayA)?delayA+1:0)];
  outFR = aFR[countFR-((countFR > delayF)?delayF+1:0)];
  outKR = aKR[countKR-((countKR > delayK)?delayK+1:0)];
  outPR = aPR[countPR-((countPR > delayP)?delayP+1:0)];
  outUR = aUR[countUR-((countUR > delayU)?delayU+1:0)];
  
  //-------- mulch
  outSample = (outVL + prevMulchEL)*0.5;
  prevMulchEL = outVL; outVL = outSample;
  outSample = (outFR + prevMulchER)*0.5;
  prevMulchER = outFR; outFR = outSample;
  //-------- five
  
  feedbackER = ((outUL*3.0) - ((outVL + outWL + outXL + outYL)*2.0));
  feedbackAL = ((outAR*3.0) - ((outFR + outKR + outPR + outUR)*2.0));
  feedbackJR = ((outVL*3.0) - ((outUL + outWL + outXL + outYL)*2.0));
  feedbackBL = ((outFR*3.0) - ((outAR + outKR + outPR + outUR)*2.0));
  feedbackOR = ((outWL*3.0) - ((outUL + outVL + outXL + outYL)*2.0));
  feedbackCL = ((outKR*3.0) - ((outAR + outFR + outPR + outUR)*2.0));
  feedbackDL = ((outXL*3.0) - ((outUL + outVL + outWL + outYL)*2.0));
  feedbackTR = ((outPR*3.0) - ((outAR + outFR + outKR + outUR)*2.0));
  feedbackEL = ((outYL*3.0) - ((outUL + outVL + outWL + outXL)*2.0));
  feedbackYR = ((outUR*3.0) - ((outAR + outFR + outKR + outPR)*2.0));
  //which we need to feed back into the input again, a bit
  
  inputSampleL = (outUL + outVL + outWL + outXL + outYL)*0.0016;
  inputSampleR = (outAR + outFR + outKR + outPR + outUR)*0.0016;
  //and take the final combined sum of outputs, corrected for Householder gain
  
  inputSampleL *= 0.5; inputSampleR *= 0.5;
  (gainOutL < 0.0078125) ? gainOutL = 0.0078125; (gainOutL > 1.0) ? gainOutL = 1.0;
  (gainOutR < 0.0078125) ? gainOutR = 0.0078125; (gainOutR > 1.0) ? gainOutR = 1.0;
  //gain of 1,0 gives you a super-clean one, gain of 2 is obviously compressing
  //smaller number is maximum clamping, if too small it'll take a while to bounce back
  inputSampleL *= gainOutL; inputSampleR *= gainOutR;
  gainOutL += sin((abs(inputSampleL*4)>1)?4:abs(inputSampleL*4))*pow(inputSampleL,4);
  gainOutR += sin((abs(inputSampleR*4)>1)?4:abs(inputSampleR*4))*pow(inputSampleR,4);
  //4.71239 radians sined will turn to -1 which is the maximum gain reduction speed
  inputSampleL *= 2.0; inputSampleR *= 2.0;
  //curve! To get a compressed effect that matches a certain other plugin
  //that is too overprocessed for its own good :)      
  
  outSample = (inputSampleL + prevOutAL)*0.5;
  prevOutAL = inputSampleL; inputSampleL = outSample;
  outSample = (inputSampleR + prevOutAR)*0.5;
  prevOutAR = inputSampleR; inputSampleR = outSample;
  
  (cycleEnd == 4) ? (
    lastRefL[0] = lastRefL[4]; //start from previous last
    lastRefL[2] = (lastRefL[0] + inputSampleL)/2; //half
    lastRefL[1] = (lastRefL[0] + lastRefL[2])/2; //one quarter
    lastRefL[3] = (lastRefL[2] + inputSampleL)/2; //three quarters
    lastRefL[4] = inputSampleL; //full
    lastRefR[0] = lastRefR[4]; //start from previous last
    lastRefR[2] = (lastRefR[0] + inputSampleR)/2; //half
    lastRefR[1] = (lastRefR[0] + lastRefR[2])/2; //one quarter
    lastRefR[3] = (lastRefR[2] + inputSampleR)/2; //three quarters
    lastRefR[4] = inputSampleR; //full
  );
  (cycleEnd == 3) ? (
    lastRefL[0] = lastRefL[3]; //start from previous last
    lastRefL[2] = (lastRefL[0]+lastRefL[0]+inputSampleL)/3; //third
    lastRefL[1] = (lastRefL[0]+inputSampleL+inputSampleL)/3; //two thirds
    lastRefL[3] = inputSampleL; //full
    lastRefR[0] = lastRefR[3]; //start from previous last
    lastRefR[2] = (lastRefR[0]+lastRefR[0]+inputSampleR)/3; //third
    lastRefR[1] = (lastRefR[0]+inputSampleR+inputSampleR)/3; //two thirds
    lastRefR[3] = inputSampleR; //full
  );
  (cycleEnd == 2) ? (
    lastRefL[0] = lastRefL[2];
    lastRefL[1] = (lastRefL[0] + inputSampleL)/2;
    lastRefL[2] = inputSampleL;
    lastRefR[0] = lastRefR[2]; 
    lastRefR[1] = (lastRefR[0] + inputSampleR)/2;
    lastRefR[2] = inputSampleR; 
  );
  (cycleEnd == 1) ? (
    lastRefL[0] = inputSampleL;
    lastRefR[0] = inputSampleR;
  );
  cycle = 0;
  inputSampleL = lastRefL[cycle];
  inputSampleR = lastRefR[cycle];
) : (
  inputSampleL = lastRefL[cycle];
  inputSampleR = lastRefR[cycle];
);

(inputSampleL > 2.8) ? inputSampleL = 2.8;
(inputSampleL < -2.8) ? inputSampleL = -2.8;
(inputSampleR > 2.8) ? inputSampleR = 2.8;
(inputSampleR < -2.8) ? inputSampleR = -2.8;
(inputSampleL > 0.0) ? inputSampleL = (inputSampleL*2.0)/(2.8274333882308-inputSampleL)
: inputSampleL = -(inputSampleL*-2.0)/(2.8274333882308+inputSampleL);
(inputSampleR > 0.0) ? inputSampleR = (inputSampleR*2.0)/(2.8274333882308-inputSampleR)
: inputSampleR = -(inputSampleR*-2.0)/(2.8274333882308+inputSampleR);

(wet < 1.0) ? (inputSampleL *= wet; inputSampleR *= wet;);
(dry < 1.0) ? (drySampleL *= dry; drySampleR *= dry;);
inputSampleL += drySampleL; inputSampleR += drySampleR;

spl0 = inputSampleL;
spl1 = inputSampleR;
__________________
ReaClassical -- Open Source Classical Music Editing Tools for REAPER | Donate via PayPal, Liberapay or Stripe
airwindows JSFX ports | Debian & Arch Pro Audio Guides
chmaha is offline   Reply With Quote
Old 04-03-2023, 08:02 PM   #160
Soli Deo Gloria
Human being with feelings
 
Soli Deo Gloria's Avatar
 
Join Date: Oct 2013
Location: Argentina
Posts: 1,303
Default

Thanks for all, as usual! I'm sticking to your RCVerb and the TAL Reverb 4 for everyday tasks, while these Airwindows ones are different colors to try out in different contexts.
Soli Deo Gloria is offline   Reply With Quote
Reply

Thread Tools
Display Modes

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off

Forum Jump


All times are GMT -7. The time now is 08:40 AM.


Powered by vBulletin® Version 3.8.11
Copyright ©2000 - 2024, vBulletin Solutions Inc.