mirror of
https://github.com/airwindows/airwindows.git
synced 2026-05-15 14:16:00 -06:00
VerbTiny
This commit is contained in:
Christopher Johnson
parent
79ac5b3c34
commit
fd5cfae098
26 changed files with 2467 additions and 298 deletions
|
|
@ -5957,6 +5957,36 @@ Just short of 12 MILLION echoes, even without regen. And they both have regen.
|
|||
|
||||
I'll give you more reverbs based on this technique, but enjoy the new bigger-than-Cosmos space :)
|
||||
|
||||
############ VerbTiny is a classic artificial reverb that expands reverb shape.
|
||||
|
||||
So, why this much simpler reverb? Instead of the more elaborate ones I'm developing starting with the letter k?
|
||||
|
||||
Because those ones (like kStation, kGuitarHall2 etc) are meant to simulate an acoustic space of various sorts. And that's interesting, and usually what I want if I'm using reverb for things. And there'll be more of those (for instance, kWoodRoom).
|
||||
|
||||
But VerbTiny's made for different purposes. Rather than place sounds in a convincing acoustic environment, it's about merging itself with sounds to alter their texture. I was listening to some old dub techno and noticed that the reverb was… naive. Much like in the 80s and 90s, I was hearing a lot of fake reverb run without any predelay or anything sophisticated, just the 'tssshhhh' of an early reverb device.
|
||||
|
||||
Then, experimenting with 4x4 matrices, I hit on one that was kind of special.
|
||||
|
||||
It was just another 4x4 matrix, but run through my testing, it made a sound that was weirdly intense with peak energy, beyond anything else I'd ever created. Just a lucky break (through spending days and weeks and months using genetic algorithm to evolve millions and billions of possible reverb matrices, so it's not like it was only an accident). And that's what's in VerbTiny: that one algorithm for making a simple reverb.
|
||||
|
||||
Twice.
|
||||
|
||||
Because I'd had another idea: yes, it was gonna be 'VerbTiny' because it could sound good but the code would be way simpler than the main ones I'm developing. An example of super-low-CPU digital reverb, complete with my Bezier undersampling so it'd work on all sample rates, and also a Bezier filter so you could make it darker. But what if I ran another copy of it (since it's so simple) and made that one dual-mono?
|
||||
|
||||
That would mean a wideness control, because it started out seeming kind of narrow (I can't control this, it's part of the algorithm). If there was a dual mono instance, each side would just feed back into the same side, meaning that stereo would stay as VERY wide stereo, at the cost of destroying the normal stereo image the reverb would have. And running two 4x4 reverbs isn't that demanding.
|
||||
|
||||
And then, since the 'normal' stereo reverb was so narrow, that means it had a lot of energy in the mid channel even though it's two stereo channels. So, what if the wideness went from 'normal' to the dual mono one at the center (0.5) and then as you went beyond that, you brought in the original revverb again, but with one channel phase flipped? Then it'd all be side channel energy, against the dual mono.
|
||||
|
||||
And so I did.
|
||||
|
||||
So most of this reverb acts normally (the regeneration control is a Galactic-style 'replace', the Derez and Filter controls are strictly 'good sounding' Bezier filtering, and the dry wet is as you'd expect). It's designed to be largely an 'old school' reverb, and is in my Basic category in Consolidated because of how simple that is.
|
||||
|
||||
And then the Wider control is still easy, but contains subtleties. If you have it exactly at 0, 0.5, or 1, you're wasting half the reverb (of course, you can do that if you want, I'm just saying). But adjust it, and listen to the shape of the 'space'. You'll find 0 is a normal stereo reverb, and then as you bring in the dual-mono version (set up so it blends nicely), the texture changes and becomes richer and it's like turning up a 'stereo wide' control. At 0.5 you have a weird wideness effect done in reverb alone. It's unnatural, but can be neat-sounding. And then as you continue to turn up Wider, you get into a HYPER-wide effect that also produces that richer tone, and it'll really accentuate the stereo space like nothing I've made (short of the Srsly plugins, which you could put on the end of this just for overkill).
|
||||
|
||||
I'm looking at making one of these which is the opposite tone: dense, thick, and soupy, for adding body to the sound, rather than depth and spaciousness. This one is for artificial depth and space, but in a way that's more retro and less realistic.
|
||||
|
||||
Hope you like it! Again, I would look for 'blends' of normal and dual-mono, either between 0 and 0.5, or between 0.5 and 1. That way you're using both of the reverbs inside. But any way you use this is fine. I'm looking forward to playing with it myself once I've finished some more plugins, perhaps on my Bastl Kastle-based jams. It's intentionally not like my other reverbs, but for some things it is just what I need :)
|
||||
|
||||
############ Vibrato lets you vibrato, chorus, flange, and make odd FM noises.
|
||||
|
||||
The heart of Vibrato is the Airwindows moving-delay-tap interpolation code also found in Chorus and Flanger, but here there’s some extra functionality plus ways to partially simulate those other plugins: while you can make the full-wet sound do a nice vibrato (automate to taste), there are other fun things to do. You can use the dry/wet to get a chorusing effect, or with less depth, a flange: or set it to ‘inverse’ to get the same but with a through-zero flange that’ll cancel almost totally to silence. This can also be used as an interesting sort of highpass (or of course, using normal wet, as a sort of lowpassy effect). That’s all with the main vibrato control, which has an extremely wide speed range.
|
||||
|
|
|
|||
|
|
@ -15,7 +15,8 @@ VerbTiny::VerbTiny(audioMasterCallback audioMaster) :
|
|||
A = 0.5;
|
||||
B = 1.0;
|
||||
C = 1.0;
|
||||
D = 1.0;
|
||||
D = 0.0;
|
||||
E = 1.0;
|
||||
|
||||
for(int x = 0; x < d4A+2; x++) {a4AL[x] = 0.0; a4AR[x] = 0.0;}
|
||||
for(int x = 0; x < d4B+2; x++) {a4BL[x] = 0.0; a4BR[x] = 0.0;}
|
||||
|
|
@ -40,6 +41,29 @@ VerbTiny::VerbTiny(audioMasterCallback audioMaster) :
|
|||
f4AL = f4BL = f4CL = f4DL = 0.0;
|
||||
f4DR = f4HR = f4LR = f4PR = 0.0;
|
||||
|
||||
for(int x = 0; x < d4A+2; x++) {b4AL[x] = 0.0; b4AR[x] = 0.0;}
|
||||
for(int x = 0; x < d4B+2; x++) {b4BL[x] = 0.0; b4BR[x] = 0.0;}
|
||||
for(int x = 0; x < d4C+2; x++) {b4CL[x] = 0.0; b4CR[x] = 0.0;}
|
||||
for(int x = 0; x < d4D+2; x++) {b4DL[x] = 0.0; b4DR[x] = 0.0;}
|
||||
for(int x = 0; x < d4E+2; x++) {b4EL[x] = 0.0; b4ER[x] = 0.0;}
|
||||
for(int x = 0; x < d4F+2; x++) {b4FL[x] = 0.0; b4FR[x] = 0.0;}
|
||||
for(int x = 0; x < d4G+2; x++) {b4GL[x] = 0.0; b4GR[x] = 0.0;}
|
||||
for(int x = 0; x < d4H+2; x++) {b4HL[x] = 0.0; b4HR[x] = 0.0;}
|
||||
for(int x = 0; x < d4I+2; x++) {b4IL[x] = 0.0; b4IR[x] = 0.0;}
|
||||
for(int x = 0; x < d4J+2; x++) {b4JL[x] = 0.0; b4JR[x] = 0.0;}
|
||||
for(int x = 0; x < d4K+2; x++) {b4KL[x] = 0.0; b4KR[x] = 0.0;}
|
||||
for(int x = 0; x < d4L+2; x++) {b4LL[x] = 0.0; b4LR[x] = 0.0;}
|
||||
for(int x = 0; x < d4M+2; x++) {b4ML[x] = 0.0; b4MR[x] = 0.0;}
|
||||
for(int x = 0; x < d4N+2; x++) {b4NL[x] = 0.0; b4NR[x] = 0.0;}
|
||||
for(int x = 0; x < d4O+2; x++) {b4OL[x] = 0.0; b4OR[x] = 0.0;}
|
||||
for(int x = 0; x < d4P+2; x++) {b4PL[x] = 0.0; b4PR[x] = 0.0;}
|
||||
e4AL = e4BL = e4CL = e4DL = e4EL = e4FL = e4GL = e4HL = 1;
|
||||
e4IL = e4JL = e4KL = e4LL = e4ML = e4NL = e4OL = e4PL = 1;
|
||||
e4AR = e4BR = e4CR = e4DR = e4ER = e4FR = e4GR = e4HR = 1;
|
||||
e4IR = e4JR = e4KR = e4LR = e4MR = e4NR = e4OR = e4PR = 1;
|
||||
g4AL = g4BL = g4CL = g4DL = 0.0;
|
||||
g4DR = g4HR = g4LR = g4PR = 0.0;
|
||||
|
||||
for (int x = 0; x < bez_total; x++) {
|
||||
bez[x] = 0.0;
|
||||
bezF[x] = 0.0;
|
||||
|
|
@ -84,6 +108,7 @@ VstInt32 VerbTiny::getChunk (void** data, bool isPreset)
|
|||
chunkData[1] = B;
|
||||
chunkData[2] = C;
|
||||
chunkData[3] = D;
|
||||
chunkData[4] = E;
|
||||
/* Note: The way this is set up, it will break if you manage to save settings on an Intel
|
||||
machine and load them on a PPC Mac. However, it's fine if you stick to the machine you
|
||||
started with. */
|
||||
|
|
@ -99,6 +124,7 @@ VstInt32 VerbTiny::setChunk (void* data, VstInt32 byteSize, bool isPreset)
|
|||
B = pinParameter(chunkData[1]);
|
||||
C = pinParameter(chunkData[2]);
|
||||
D = pinParameter(chunkData[3]);
|
||||
E = pinParameter(chunkData[4]);
|
||||
/* We're ignoring byteSize as we found it to be a filthy liar */
|
||||
|
||||
/* calculate any other fields you need here - you could copy in
|
||||
|
|
@ -112,6 +138,7 @@ void VerbTiny::setParameter(VstInt32 index, float value) {
|
|||
case kParamB: B = value; break;
|
||||
case kParamC: C = value; break;
|
||||
case kParamD: D = value; break;
|
||||
case kParamE: E = value; break;
|
||||
default: throw; // unknown parameter, shouldn't happen!
|
||||
}
|
||||
}
|
||||
|
|
@ -122,6 +149,7 @@ float VerbTiny::getParameter(VstInt32 index) {
|
|||
case kParamB: return B; break;
|
||||
case kParamC: return C; break;
|
||||
case kParamD: return D; break;
|
||||
case kParamE: return E; break;
|
||||
default: break; // unknown parameter, shouldn't happen!
|
||||
} return 0.0; //we only need to update the relevant name, this is simple to manage
|
||||
}
|
||||
|
|
@ -131,7 +159,8 @@ void VerbTiny::getParameterName(VstInt32 index, char *text) {
|
|||
case kParamA: vst_strncpy (text, "Replace", kVstMaxParamStrLen); break;
|
||||
case kParamB: vst_strncpy (text, "Derez", kVstMaxParamStrLen); break;
|
||||
case kParamC: vst_strncpy (text, "Filter", kVstMaxParamStrLen); break;
|
||||
case kParamD: vst_strncpy (text, "Dry/Wet", kVstMaxParamStrLen); break;
|
||||
case kParamD: vst_strncpy (text, "Wider", kVstMaxParamStrLen); break;
|
||||
case kParamE: vst_strncpy (text, "Dry/Wet", kVstMaxParamStrLen); break;
|
||||
default: break; // unknown parameter, shouldn't happen!
|
||||
} //this is our labels for displaying in the VST host
|
||||
}
|
||||
|
|
@ -142,6 +171,7 @@ void VerbTiny::getParameterDisplay(VstInt32 index, char *text) {
|
|||
case kParamB: float2string (B, text, kVstMaxParamStrLen); break;
|
||||
case kParamC: float2string (C, text, kVstMaxParamStrLen); break;
|
||||
case kParamD: float2string (D, text, kVstMaxParamStrLen); break;
|
||||
case kParamE: float2string (E, text, kVstMaxParamStrLen); break;
|
||||
default: break; // unknown parameter, shouldn't happen!
|
||||
} //this displays the values and handles 'popups' where it's discrete choices
|
||||
}
|
||||
|
|
@ -152,6 +182,7 @@ void VerbTiny::getParameterLabel(VstInt32 index, char *text) {
|
|||
case kParamB: vst_strncpy (text, "", kVstMaxParamStrLen); break;
|
||||
case kParamC: vst_strncpy (text, "", kVstMaxParamStrLen); break;
|
||||
case kParamD: vst_strncpy (text, "", kVstMaxParamStrLen); break;
|
||||
case kParamE: vst_strncpy (text, "", kVstMaxParamStrLen); break;
|
||||
default: break; // unknown parameter, shouldn't happen!
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,7 +20,8 @@ enum {
|
|||
kParamB =1,
|
||||
kParamC =2,
|
||||
kParamD =3,
|
||||
kNumParameters = 4
|
||||
kParamE =4,
|
||||
kNumParameters =5
|
||||
}; //
|
||||
|
||||
const int kNumPrograms = 0;
|
||||
|
|
@ -62,6 +63,7 @@ private:
|
|||
float B;
|
||||
float C;
|
||||
float D;
|
||||
float E;
|
||||
|
||||
double a4AL[d4A+5];
|
||||
double a4BL[d4B+5];
|
||||
|
|
@ -100,6 +102,45 @@ private:
|
|||
int c4AR,c4BR,c4CR,c4DR,c4ER,c4FR,c4GR,c4HR;
|
||||
int c4IR,c4JR,c4KR,c4LR,c4MR,c4NR,c4OR,c4PR;
|
||||
double f4AL,f4BL,f4CL,f4DL,f4DR,f4HR,f4LR,f4PR;
|
||||
//base stereo reverb
|
||||
double b4AL[d4A+5];
|
||||
double b4BL[d4B+5];
|
||||
double b4CL[d4C+5];
|
||||
double b4DL[d4D+5];
|
||||
double b4EL[d4E+5];
|
||||
double b4FL[d4F+5];
|
||||
double b4GL[d4G+5];
|
||||
double b4HL[d4H+5];
|
||||
double b4IL[d4I+5];
|
||||
double b4JL[d4J+5];
|
||||
double b4KL[d4K+5];
|
||||
double b4LL[d4L+5];
|
||||
double b4ML[d4M+5];
|
||||
double b4NL[d4N+5];
|
||||
double b4OL[d4O+5];
|
||||
double b4PL[d4P+5];
|
||||
double b4AR[d4A+5];
|
||||
double b4BR[d4B+5];
|
||||
double b4CR[d4C+5];
|
||||
double b4DR[d4D+5];
|
||||
double b4ER[d4E+5];
|
||||
double b4FR[d4F+5];
|
||||
double b4GR[d4G+5];
|
||||
double b4HR[d4H+5];
|
||||
double b4IR[d4I+5];
|
||||
double b4JR[d4J+5];
|
||||
double b4KR[d4K+5];
|
||||
double b4LR[d4L+5];
|
||||
double b4MR[d4M+5];
|
||||
double b4NR[d4N+5];
|
||||
double b4OR[d4O+5];
|
||||
double b4PR[d4P+5];
|
||||
int e4AL,e4BL,e4CL,e4DL,e4EL,e4FL,e4GL,e4HL;
|
||||
int e4IL,e4JL,e4KL,e4LL,e4ML,e4NL,e4OL,e4PL;
|
||||
int e4AR,e4BR,e4CR,e4DR,e4ER,e4FR,e4GR,e4HR;
|
||||
int e4IR,e4JR,e4KR,e4LR,e4MR,e4NR,e4OR,e4PR;
|
||||
double g4AL,g4BL,g4CL,g4DL,g4DR,g4HR,g4LR,g4PR;
|
||||
//changed letter is the dual mono, with rearranged grid
|
||||
|
||||
enum {
|
||||
bez_AL,
|
||||
|
|
@ -108,8 +149,6 @@ private:
|
|||
bez_BR,
|
||||
bez_CL,
|
||||
bez_CR,
|
||||
bez_InL,
|
||||
bez_InR,
|
||||
bez_SampL,
|
||||
bez_SampR,
|
||||
bez_cycle,
|
||||
|
|
|
|||
|
|
@ -34,7 +34,8 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
derezFreq = 1.0 / bezFreqFraction;
|
||||
bezFreqTrim = 1.0-(derezFreq*bezFreqTrim);
|
||||
//the revision more accurately connects the bezier curves
|
||||
double wet = D;
|
||||
double wider = D*2.0;
|
||||
double wet = E;
|
||||
|
||||
while (--sampleFrames >= 0)
|
||||
{
|
||||
|
|
@ -50,13 +51,13 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
bez[bez_SampR] += (inputSampleR*attenuate*derez);
|
||||
if (bez[bez_cycle] > 1.0) { //hit the end point and we do a reverb sample
|
||||
bez[bez_cycle] = 0.0;
|
||||
inputSampleL = bez[bez_SampL];
|
||||
inputSampleR = bez[bez_SampR];
|
||||
double mainSampleL = bez[bez_SampL];
|
||||
double mainSampleR = bez[bez_SampR]; //begin primary reverb
|
||||
|
||||
a4AL[c4AL] = inputSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = inputSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = inputSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = inputSampleL + (f4DL * reg4n);
|
||||
a4AL[c4AL] = mainSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = mainSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = mainSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = mainSampleL + (f4DL * reg4n);
|
||||
|
||||
c4AL++; if (c4AL < 0 || c4AL > d4A) c4AL = 0;
|
||||
c4BL++; if (c4BL < 0 || c4BL > d4B) c4BL = 0;
|
||||
|
|
@ -68,10 +69,10 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
double o4CL = a4CL[c4CL-((c4CL > d4C)?d4C+1:0)];
|
||||
double o4DL = a4DL[c4DL-((c4DL > d4D)?d4D+1:0)];
|
||||
|
||||
a4DR[c4DR] = inputSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = inputSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = inputSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = inputSampleR + (f4PR * reg4n);
|
||||
a4DR[c4DR] = mainSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = mainSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = mainSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = mainSampleR + (f4PR * reg4n);
|
||||
|
||||
c4DR++; if (c4DR < 0 || c4DR > d4D) c4DR = 0;
|
||||
c4HR++; if (c4HR < 0 || c4HR > d4H) c4HR = 0;
|
||||
|
|
@ -191,8 +192,173 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
f4LR = o4OL - (o4ML + o4NL + o4PL);
|
||||
f4PR = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
inputSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
inputSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
mainSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
mainSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
|
||||
//we still have an untouched inputsample, turn it into dual mono
|
||||
//won't need to redeclare any of the o4 temp variables, just re-use
|
||||
|
||||
double dualmonoSampleL = bez[bez_SampR];
|
||||
double dualmonoSampleR = bez[bez_SampL];
|
||||
//workaround involves keeping the cross-matrix system,
|
||||
//but for initial layering, each side gets each version
|
||||
//making blends never quite line up as exactly the same.
|
||||
|
||||
b4AL[e4AL] = dualmonoSampleL + (g4AL * reg4n);
|
||||
b4BL[e4BL] = dualmonoSampleL + (g4BL * reg4n);
|
||||
b4CL[e4CL] = dualmonoSampleL + (g4CL * reg4n);
|
||||
b4DL[e4DL] = dualmonoSampleL + (g4DL * reg4n);
|
||||
|
||||
e4AL++; if (e4AL < 0 || e4AL > d4A) e4AL = 0;
|
||||
e4BL++; if (e4BL < 0 || e4BL > d4B) e4BL = 0;
|
||||
e4CL++; if (e4CL < 0 || e4CL > d4C) e4CL = 0;
|
||||
e4DL++; if (e4DL < 0 || e4DL > d4D) e4DL = 0;
|
||||
|
||||
o4AL = b4AL[e4AL-((e4AL > d4A)?d4A+1:0)];
|
||||
o4BL = b4BL[e4BL-((e4BL > d4B)?d4B+1:0)];
|
||||
o4CL = b4CL[e4CL-((e4CL > d4C)?d4C+1:0)];
|
||||
o4DL = b4DL[e4DL-((e4DL > d4D)?d4D+1:0)];
|
||||
|
||||
b4DR[e4DR] = dualmonoSampleR + (g4DR * reg4n);
|
||||
b4HR[e4HR] = dualmonoSampleR + (g4HR * reg4n);
|
||||
b4LR[e4LR] = dualmonoSampleR + (g4LR * reg4n);
|
||||
b4PR[e4PR] = dualmonoSampleR + (g4PR * reg4n);
|
||||
|
||||
e4DR++; if (e4DR < 0 || e4DR > d4D) e4DR = 0;
|
||||
e4HR++; if (e4HR < 0 || e4HR > d4H) e4HR = 0;
|
||||
e4LR++; if (e4LR < 0 || e4LR > d4L) e4LR = 0;
|
||||
e4PR++; if (e4PR < 0 || e4PR > d4P) e4PR = 0;
|
||||
|
||||
o4DR = b4DR[e4DR-((e4DR > d4D)?d4D+1:0)];
|
||||
o4HR = b4HR[e4HR-((e4HR > d4H)?d4H+1:0)];
|
||||
o4LR = b4LR[e4LR-((e4LR > d4L)?d4L+1:0)];
|
||||
o4PR = b4PR[e4PR-((e4PR > d4P)?d4P+1:0)];
|
||||
|
||||
//-------- one
|
||||
|
||||
b4EL[e4EL] = o4AL - (o4BL + o4CL + o4DL);
|
||||
b4FL[e4FL] = o4BL - (o4AL + o4CL + o4DL);
|
||||
b4GL[e4GL] = o4CL - (o4AL + o4BL + o4DL);
|
||||
b4HL[e4HL] = o4DL - (o4AL + o4BL + o4CL);
|
||||
|
||||
e4EL++; if (e4EL < 0 || e4EL > d4E) e4EL = 0;
|
||||
e4FL++; if (e4FL < 0 || e4FL > d4F) e4FL = 0;
|
||||
e4GL++; if (e4GL < 0 || e4GL > d4G) e4GL = 0;
|
||||
e4HL++; if (e4HL < 0 || e4HL > d4H) e4HL = 0;
|
||||
|
||||
o4EL = b4EL[e4EL-((e4EL > d4E)?d4E+1:0)];
|
||||
o4FL = b4FL[e4FL-((e4FL > d4F)?d4F+1:0)];
|
||||
o4GL = b4GL[e4GL-((e4GL > d4G)?d4G+1:0)];
|
||||
o4HL = b4HL[e4HL-((e4HL > d4H)?d4H+1:0)];
|
||||
|
||||
b4CR[e4CR] = o4DR - (o4HR + o4LR + o4PR);
|
||||
b4GR[e4GR] = o4HR - (o4DR + o4LR + o4PR);
|
||||
b4KR[e4KR] = o4LR - (o4DR + o4HR + o4PR);
|
||||
b4OR[e4OR] = o4PR - (o4DR + o4HR + o4LR);
|
||||
|
||||
e4CR++; if (e4CR < 0 || e4CR > d4C) e4CR = 0;
|
||||
e4GR++; if (e4GR < 0 || e4GR > d4G) e4GR = 0;
|
||||
e4KR++; if (e4KR < 0 || e4KR > d4K) e4KR = 0;
|
||||
e4OR++; if (e4OR < 0 || e4OR > d4O) e4OR = 0;
|
||||
|
||||
o4CR = b4CR[e4CR-((e4CR > d4C)?d4C+1:0)];
|
||||
o4GR = b4GR[e4GR-((e4GR > d4G)?d4G+1:0)];
|
||||
o4KR = b4KR[e4KR-((e4KR > d4K)?d4K+1:0)];
|
||||
o4OR = b4OR[e4OR-((e4OR > d4O)?d4O+1:0)];
|
||||
|
||||
//-------- two
|
||||
|
||||
b4IL[e4IL] = o4EL - (o4FL + o4GL + o4HL);
|
||||
b4JL[e4JL] = o4FL - (o4EL + o4GL + o4HL);
|
||||
b4KL[e4KL] = o4GL - (o4EL + o4FL + o4HL);
|
||||
b4LL[e4LL] = o4HL - (o4EL + o4FL + o4GL);
|
||||
|
||||
e4IL++; if (e4IL < 0 || e4IL > d4I) e4IL = 0;
|
||||
e4JL++; if (e4JL < 0 || e4JL > d4J) e4JL = 0;
|
||||
e4KL++; if (e4KL < 0 || e4KL > d4K) e4KL = 0;
|
||||
e4LL++; if (e4LL < 0 || e4LL > d4L) e4LL = 0;
|
||||
|
||||
o4IL = b4IL[e4IL-((e4IL > d4I)?d4I+1:0)];
|
||||
o4JL = b4JL[e4JL-((e4JL > d4J)?d4J+1:0)];
|
||||
o4KL = b4KL[e4KL-((e4KL > d4K)?d4K+1:0)];
|
||||
o4LL = b4LL[e4LL-((e4LL > d4L)?d4L+1:0)];
|
||||
|
||||
b4BR[e4BR] = o4CR - (o4GR + o4KR + o4OR);
|
||||
b4FR[e4FR] = o4GR - (o4CR + o4KR + o4OR);
|
||||
b4JR[e4JR] = o4KR - (o4CR + o4GR + o4OR);
|
||||
b4NR[e4NR] = o4OR - (o4CR + o4GR + o4KR);
|
||||
|
||||
e4BR++; if (e4BR < 0 || e4BR > d4B) e4BR = 0;
|
||||
e4FR++; if (e4FR < 0 || e4FR > d4F) e4FR = 0;
|
||||
e4JR++; if (e4JR < 0 || e4JR > d4J) e4JR = 0;
|
||||
e4NR++; if (e4NR < 0 || e4NR > d4N) e4NR = 0;
|
||||
|
||||
o4BR = b4BR[e4BR-((e4BR > d4B)?d4B+1:0)];
|
||||
o4FR = b4FR[e4FR-((e4FR > d4F)?d4F+1:0)];
|
||||
o4JR = b4JR[e4JR-((e4JR > d4J)?d4J+1:0)];
|
||||
o4NR = b4NR[e4NR-((e4NR > d4N)?d4N+1:0)];
|
||||
|
||||
//-------- three
|
||||
|
||||
b4ML[e4ML] = o4IL - (o4JL + o4KL + o4LL);
|
||||
b4NL[e4NL] = o4JL - (o4IL + o4KL + o4LL);
|
||||
b4OL[e4OL] = o4KL - (o4IL + o4JL + o4LL);
|
||||
b4PL[e4PL] = o4LL - (o4IL + o4JL + o4KL);
|
||||
|
||||
e4ML++; if (e4ML < 0 || e4ML > d4M) e4ML = 0;
|
||||
e4NL++; if (e4NL < 0 || e4NL > d4N) e4NL = 0;
|
||||
e4OL++; if (e4OL < 0 || e4OL > d4O) e4OL = 0;
|
||||
e4PL++; if (e4PL < 0 || e4PL > d4P) e4PL = 0;
|
||||
|
||||
o4ML = b4ML[e4ML-((e4ML > d4M)?d4M+1:0)];
|
||||
o4NL = b4NL[e4NL-((e4NL > d4N)?d4N+1:0)];
|
||||
o4OL = b4OL[e4OL-((e4OL > d4O)?d4O+1:0)];
|
||||
o4PL = b4PL[e4PL-((e4PL > d4P)?d4P+1:0)];
|
||||
|
||||
b4AR[e4AR] = o4BR - (o4FR + o4JR + o4NR);
|
||||
b4ER[e4ER] = o4FR - (o4BR + o4JR + o4NR);
|
||||
b4IR[e4IR] = o4JR - (o4BR + o4FR + o4NR);
|
||||
b4MR[e4MR] = o4NR - (o4BR + o4FR + o4JR);
|
||||
|
||||
e4AR++; if (e4AR < 0 || e4AR > d4A) e4AR = 0;
|
||||
e4ER++; if (e4ER < 0 || e4ER > d4E) e4ER = 0;
|
||||
e4IR++; if (e4IR < 0 || e4IR > d4I) e4IR = 0;
|
||||
e4MR++; if (e4MR < 0 || e4MR > d4M) e4MR = 0;
|
||||
|
||||
o4AR = b4AR[e4AR-((e4AR > d4A)?d4A+1:0)];
|
||||
o4ER = b4ER[e4ER-((e4ER > d4E)?d4E+1:0)];
|
||||
o4IR = b4IR[e4IR-((e4IR > d4I)?d4I+1:0)];
|
||||
o4MR = b4MR[e4MR-((e4MR > d4M)?d4M+1:0)];
|
||||
|
||||
//-------- four
|
||||
|
||||
g4DR = o4AR - (o4ER + o4IR + o4MR);
|
||||
g4HR = o4ER - (o4AR + o4IR + o4MR);
|
||||
g4LR = o4IR - (o4AR + o4ER + o4MR);
|
||||
g4PR = o4MR - (o4AR + o4ER + o4IR);
|
||||
|
||||
g4AL = o4ML - (o4NL + o4OL + o4PL);
|
||||
g4BL = o4NL - (o4ML + o4OL + o4PL);
|
||||
g4CL = o4OL - (o4ML + o4NL + o4PL);
|
||||
g4DL = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
dualmonoSampleR = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
dualmonoSampleL = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
//dual mono version is wider = 1.0 at the center
|
||||
//with mainsample 0.0 and 2.0 (only at the edges)
|
||||
//with mainsample out of phase when over 1.0
|
||||
//couldn't re-do the arrays perfectly, so instead
|
||||
//we keep exactly the same cross-matrix,
|
||||
//but we flip the sides we're using for initial reverb.
|
||||
//then, dualmono remains totally dualmono, and blend a bit in for wideness.
|
||||
|
||||
if (wider < 1.0) {
|
||||
inputSampleL = (dualmonoSampleL*wider) + (mainSampleL*(1.0-wider));
|
||||
inputSampleR = (dualmonoSampleR*wider) + (mainSampleR*(1.0-wider));
|
||||
} else {
|
||||
inputSampleL = (dualmonoSampleL*(2.0-wider)) + (mainSampleL*(wider-1.0));
|
||||
inputSampleR = (dualmonoSampleR*(2.0-wider)) + (-mainSampleR*(wider-1.0));
|
||||
}
|
||||
|
||||
bez[bez_CL] = bez[bez_BL];
|
||||
bez[bez_BL] = bez[bez_AL];
|
||||
|
|
@ -213,9 +379,8 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
inputSampleR = (bez[bez_BR]+(CBR*(1.0-X))+(BAR*X))*-0.25;
|
||||
|
||||
bezF[bez_cycle] += derezFreq;
|
||||
bezF[bez_SampL] += ((inputSampleL+bezF[bez_InL]) * derezFreq);
|
||||
bezF[bez_SampR] += ((inputSampleL+bezF[bez_InR]) * derezFreq);
|
||||
bezF[bez_InL] = inputSampleL; bezF[bez_InR] = inputSampleR;
|
||||
bezF[bez_SampL] += (inputSampleL * derezFreq);
|
||||
bezF[bez_SampR] += (inputSampleR * derezFreq);
|
||||
if (bezF[bez_cycle] > 1.0) { //hit the end point and we do a filter sample
|
||||
bezF[bez_cycle] = 0.0;
|
||||
bezF[bez_CL] = bezF[bez_BL];
|
||||
|
|
@ -230,10 +395,10 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
X = bezF[bez_cycle]*bezFreqTrim;
|
||||
double CBLfreq = (bezF[bez_CL]*(1.0-X))+(bezF[bez_BL]*X);
|
||||
double BALfreq = (bezF[bez_BL]*(1.0-X))+(bezF[bez_AL]*X);
|
||||
inputSampleL = (bezF[bez_BL]+(CBLfreq*(1.0-X))+(BALfreq*X))*0.25;
|
||||
inputSampleL = (bezF[bez_BL]+(CBLfreq*(1.0-X))+(BALfreq*X))*0.5;
|
||||
double CBRfreq = (bezF[bez_CR]*(1.0-X))+(bezF[bez_BR]*X);
|
||||
double BARfreq = (bezF[bez_BR]*(1.0-X))+(bezF[bez_AR]*X);
|
||||
inputSampleR = (bezF[bez_BR]+(CBRfreq*(1.0-X))+(BARfreq*X))*0.25;
|
||||
inputSampleR = (bezF[bez_BR]+(CBRfreq*(1.0-X))+(BARfreq*X))*0.5;
|
||||
//filtering the reverb separately, after making it
|
||||
|
||||
inputSampleL = (inputSampleL * wet)+(drySampleL * (1.0-wet));
|
||||
|
|
@ -285,7 +450,8 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
derezFreq = 1.0 / bezFreqFraction;
|
||||
bezFreqTrim = 1.0-(derezFreq*bezFreqTrim);
|
||||
//the revision more accurately connects the bezier curves
|
||||
double wet = D;
|
||||
double wider = D*2.0;
|
||||
double wet = E;
|
||||
|
||||
while (--sampleFrames >= 0)
|
||||
{
|
||||
|
|
@ -301,13 +467,13 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
bez[bez_SampR] += (inputSampleR*attenuate*derez);
|
||||
if (bez[bez_cycle] > 1.0) { //hit the end point and we do a reverb sample
|
||||
bez[bez_cycle] = 0.0;
|
||||
inputSampleL = bez[bez_SampL];
|
||||
inputSampleR = bez[bez_SampR];
|
||||
double mainSampleL = bez[bez_SampL];
|
||||
double mainSampleR = bez[bez_SampR]; //begin primary reverb
|
||||
|
||||
a4AL[c4AL] = inputSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = inputSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = inputSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = inputSampleL + (f4DL * reg4n);
|
||||
a4AL[c4AL] = mainSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = mainSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = mainSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = mainSampleL + (f4DL * reg4n);
|
||||
|
||||
c4AL++; if (c4AL < 0 || c4AL > d4A) c4AL = 0;
|
||||
c4BL++; if (c4BL < 0 || c4BL > d4B) c4BL = 0;
|
||||
|
|
@ -319,10 +485,10 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
double o4CL = a4CL[c4CL-((c4CL > d4C)?d4C+1:0)];
|
||||
double o4DL = a4DL[c4DL-((c4DL > d4D)?d4D+1:0)];
|
||||
|
||||
a4DR[c4DR] = inputSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = inputSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = inputSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = inputSampleR + (f4PR * reg4n);
|
||||
a4DR[c4DR] = mainSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = mainSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = mainSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = mainSampleR + (f4PR * reg4n);
|
||||
|
||||
c4DR++; if (c4DR < 0 || c4DR > d4D) c4DR = 0;
|
||||
c4HR++; if (c4HR < 0 || c4HR > d4H) c4HR = 0;
|
||||
|
|
@ -442,8 +608,173 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
f4LR = o4OL - (o4ML + o4NL + o4PL);
|
||||
f4PR = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
inputSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
inputSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
mainSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
mainSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
|
||||
//we still have an untouched inputsample, turn it into dual mono
|
||||
//won't need to redeclare any of the o4 temp variables, just re-use
|
||||
|
||||
double dualmonoSampleL = bez[bez_SampR];
|
||||
double dualmonoSampleR = bez[bez_SampL];
|
||||
//workaround involves keeping the cross-matrix system,
|
||||
//but for initial layering, each side gets each version
|
||||
//making blends never quite line up as exactly the same.
|
||||
|
||||
b4AL[e4AL] = dualmonoSampleL + (g4AL * reg4n);
|
||||
b4BL[e4BL] = dualmonoSampleL + (g4BL * reg4n);
|
||||
b4CL[e4CL] = dualmonoSampleL + (g4CL * reg4n);
|
||||
b4DL[e4DL] = dualmonoSampleL + (g4DL * reg4n);
|
||||
|
||||
e4AL++; if (e4AL < 0 || e4AL > d4A) e4AL = 0;
|
||||
e4BL++; if (e4BL < 0 || e4BL > d4B) e4BL = 0;
|
||||
e4CL++; if (e4CL < 0 || e4CL > d4C) e4CL = 0;
|
||||
e4DL++; if (e4DL < 0 || e4DL > d4D) e4DL = 0;
|
||||
|
||||
o4AL = b4AL[e4AL-((e4AL > d4A)?d4A+1:0)];
|
||||
o4BL = b4BL[e4BL-((e4BL > d4B)?d4B+1:0)];
|
||||
o4CL = b4CL[e4CL-((e4CL > d4C)?d4C+1:0)];
|
||||
o4DL = b4DL[e4DL-((e4DL > d4D)?d4D+1:0)];
|
||||
|
||||
b4DR[e4DR] = dualmonoSampleR + (g4DR * reg4n);
|
||||
b4HR[e4HR] = dualmonoSampleR + (g4HR * reg4n);
|
||||
b4LR[e4LR] = dualmonoSampleR + (g4LR * reg4n);
|
||||
b4PR[e4PR] = dualmonoSampleR + (g4PR * reg4n);
|
||||
|
||||
e4DR++; if (e4DR < 0 || e4DR > d4D) e4DR = 0;
|
||||
e4HR++; if (e4HR < 0 || e4HR > d4H) e4HR = 0;
|
||||
e4LR++; if (e4LR < 0 || e4LR > d4L) e4LR = 0;
|
||||
e4PR++; if (e4PR < 0 || e4PR > d4P) e4PR = 0;
|
||||
|
||||
o4DR = b4DR[e4DR-((e4DR > d4D)?d4D+1:0)];
|
||||
o4HR = b4HR[e4HR-((e4HR > d4H)?d4H+1:0)];
|
||||
o4LR = b4LR[e4LR-((e4LR > d4L)?d4L+1:0)];
|
||||
o4PR = b4PR[e4PR-((e4PR > d4P)?d4P+1:0)];
|
||||
|
||||
//-------- one
|
||||
|
||||
b4EL[e4EL] = o4AL - (o4BL + o4CL + o4DL);
|
||||
b4FL[e4FL] = o4BL - (o4AL + o4CL + o4DL);
|
||||
b4GL[e4GL] = o4CL - (o4AL + o4BL + o4DL);
|
||||
b4HL[e4HL] = o4DL - (o4AL + o4BL + o4CL);
|
||||
|
||||
e4EL++; if (e4EL < 0 || e4EL > d4E) e4EL = 0;
|
||||
e4FL++; if (e4FL < 0 || e4FL > d4F) e4FL = 0;
|
||||
e4GL++; if (e4GL < 0 || e4GL > d4G) e4GL = 0;
|
||||
e4HL++; if (e4HL < 0 || e4HL > d4H) e4HL = 0;
|
||||
|
||||
o4EL = b4EL[e4EL-((e4EL > d4E)?d4E+1:0)];
|
||||
o4FL = b4FL[e4FL-((e4FL > d4F)?d4F+1:0)];
|
||||
o4GL = b4GL[e4GL-((e4GL > d4G)?d4G+1:0)];
|
||||
o4HL = b4HL[e4HL-((e4HL > d4H)?d4H+1:0)];
|
||||
|
||||
b4CR[e4CR] = o4DR - (o4HR + o4LR + o4PR);
|
||||
b4GR[e4GR] = o4HR - (o4DR + o4LR + o4PR);
|
||||
b4KR[e4KR] = o4LR - (o4DR + o4HR + o4PR);
|
||||
b4OR[e4OR] = o4PR - (o4DR + o4HR + o4LR);
|
||||
|
||||
e4CR++; if (e4CR < 0 || e4CR > d4C) e4CR = 0;
|
||||
e4GR++; if (e4GR < 0 || e4GR > d4G) e4GR = 0;
|
||||
e4KR++; if (e4KR < 0 || e4KR > d4K) e4KR = 0;
|
||||
e4OR++; if (e4OR < 0 || e4OR > d4O) e4OR = 0;
|
||||
|
||||
o4CR = b4CR[e4CR-((e4CR > d4C)?d4C+1:0)];
|
||||
o4GR = b4GR[e4GR-((e4GR > d4G)?d4G+1:0)];
|
||||
o4KR = b4KR[e4KR-((e4KR > d4K)?d4K+1:0)];
|
||||
o4OR = b4OR[e4OR-((e4OR > d4O)?d4O+1:0)];
|
||||
|
||||
//-------- two
|
||||
|
||||
b4IL[e4IL] = o4EL - (o4FL + o4GL + o4HL);
|
||||
b4JL[e4JL] = o4FL - (o4EL + o4GL + o4HL);
|
||||
b4KL[e4KL] = o4GL - (o4EL + o4FL + o4HL);
|
||||
b4LL[e4LL] = o4HL - (o4EL + o4FL + o4GL);
|
||||
|
||||
e4IL++; if (e4IL < 0 || e4IL > d4I) e4IL = 0;
|
||||
e4JL++; if (e4JL < 0 || e4JL > d4J) e4JL = 0;
|
||||
e4KL++; if (e4KL < 0 || e4KL > d4K) e4KL = 0;
|
||||
e4LL++; if (e4LL < 0 || e4LL > d4L) e4LL = 0;
|
||||
|
||||
o4IL = b4IL[e4IL-((e4IL > d4I)?d4I+1:0)];
|
||||
o4JL = b4JL[e4JL-((e4JL > d4J)?d4J+1:0)];
|
||||
o4KL = b4KL[e4KL-((e4KL > d4K)?d4K+1:0)];
|
||||
o4LL = b4LL[e4LL-((e4LL > d4L)?d4L+1:0)];
|
||||
|
||||
b4BR[e4BR] = o4CR - (o4GR + o4KR + o4OR);
|
||||
b4FR[e4FR] = o4GR - (o4CR + o4KR + o4OR);
|
||||
b4JR[e4JR] = o4KR - (o4CR + o4GR + o4OR);
|
||||
b4NR[e4NR] = o4OR - (o4CR + o4GR + o4KR);
|
||||
|
||||
e4BR++; if (e4BR < 0 || e4BR > d4B) e4BR = 0;
|
||||
e4FR++; if (e4FR < 0 || e4FR > d4F) e4FR = 0;
|
||||
e4JR++; if (e4JR < 0 || e4JR > d4J) e4JR = 0;
|
||||
e4NR++; if (e4NR < 0 || e4NR > d4N) e4NR = 0;
|
||||
|
||||
o4BR = b4BR[e4BR-((e4BR > d4B)?d4B+1:0)];
|
||||
o4FR = b4FR[e4FR-((e4FR > d4F)?d4F+1:0)];
|
||||
o4JR = b4JR[e4JR-((e4JR > d4J)?d4J+1:0)];
|
||||
o4NR = b4NR[e4NR-((e4NR > d4N)?d4N+1:0)];
|
||||
|
||||
//-------- three
|
||||
|
||||
b4ML[e4ML] = o4IL - (o4JL + o4KL + o4LL);
|
||||
b4NL[e4NL] = o4JL - (o4IL + o4KL + o4LL);
|
||||
b4OL[e4OL] = o4KL - (o4IL + o4JL + o4LL);
|
||||
b4PL[e4PL] = o4LL - (o4IL + o4JL + o4KL);
|
||||
|
||||
e4ML++; if (e4ML < 0 || e4ML > d4M) e4ML = 0;
|
||||
e4NL++; if (e4NL < 0 || e4NL > d4N) e4NL = 0;
|
||||
e4OL++; if (e4OL < 0 || e4OL > d4O) e4OL = 0;
|
||||
e4PL++; if (e4PL < 0 || e4PL > d4P) e4PL = 0;
|
||||
|
||||
o4ML = b4ML[e4ML-((e4ML > d4M)?d4M+1:0)];
|
||||
o4NL = b4NL[e4NL-((e4NL > d4N)?d4N+1:0)];
|
||||
o4OL = b4OL[e4OL-((e4OL > d4O)?d4O+1:0)];
|
||||
o4PL = b4PL[e4PL-((e4PL > d4P)?d4P+1:0)];
|
||||
|
||||
b4AR[e4AR] = o4BR - (o4FR + o4JR + o4NR);
|
||||
b4ER[e4ER] = o4FR - (o4BR + o4JR + o4NR);
|
||||
b4IR[e4IR] = o4JR - (o4BR + o4FR + o4NR);
|
||||
b4MR[e4MR] = o4NR - (o4BR + o4FR + o4JR);
|
||||
|
||||
e4AR++; if (e4AR < 0 || e4AR > d4A) e4AR = 0;
|
||||
e4ER++; if (e4ER < 0 || e4ER > d4E) e4ER = 0;
|
||||
e4IR++; if (e4IR < 0 || e4IR > d4I) e4IR = 0;
|
||||
e4MR++; if (e4MR < 0 || e4MR > d4M) e4MR = 0;
|
||||
|
||||
o4AR = b4AR[e4AR-((e4AR > d4A)?d4A+1:0)];
|
||||
o4ER = b4ER[e4ER-((e4ER > d4E)?d4E+1:0)];
|
||||
o4IR = b4IR[e4IR-((e4IR > d4I)?d4I+1:0)];
|
||||
o4MR = b4MR[e4MR-((e4MR > d4M)?d4M+1:0)];
|
||||
|
||||
//-------- four
|
||||
|
||||
g4DR = o4AR - (o4ER + o4IR + o4MR);
|
||||
g4HR = o4ER - (o4AR + o4IR + o4MR);
|
||||
g4LR = o4IR - (o4AR + o4ER + o4MR);
|
||||
g4PR = o4MR - (o4AR + o4ER + o4IR);
|
||||
|
||||
g4AL = o4ML - (o4NL + o4OL + o4PL);
|
||||
g4BL = o4NL - (o4ML + o4OL + o4PL);
|
||||
g4CL = o4OL - (o4ML + o4NL + o4PL);
|
||||
g4DL = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
dualmonoSampleR = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
dualmonoSampleL = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
//dual mono version is wider = 1.0 at the center
|
||||
//with mainsample 0.0 and 2.0 (only at the edges)
|
||||
//with mainsample out of phase when over 1.0
|
||||
//couldn't re-do the arrays perfectly, so instead
|
||||
//we keep exactly the same cross-matrix,
|
||||
//but we flip the sides we're using for initial reverb.
|
||||
//then, dualmono remains totally dualmono, and blend a bit in for wideness.
|
||||
|
||||
if (wider < 1.0) {
|
||||
inputSampleL = (dualmonoSampleL*wider) + (mainSampleL*(1.0-wider));
|
||||
inputSampleR = (dualmonoSampleR*wider) + (mainSampleR*(1.0-wider));
|
||||
} else {
|
||||
inputSampleL = (dualmonoSampleL*(2.0-wider)) + (mainSampleL*(wider-1.0));
|
||||
inputSampleR = (dualmonoSampleR*(2.0-wider)) + (-mainSampleR*(wider-1.0));
|
||||
}
|
||||
|
||||
bez[bez_CL] = bez[bez_BL];
|
||||
bez[bez_BL] = bez[bez_AL];
|
||||
|
|
@ -464,9 +795,8 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
inputSampleR = (bez[bez_BR]+(CBR*(1.0-X))+(BAR*X))*-0.25;
|
||||
|
||||
bezF[bez_cycle] += derezFreq;
|
||||
bezF[bez_SampL] += ((inputSampleL+bezF[bez_InL]) * derezFreq);
|
||||
bezF[bez_SampR] += ((inputSampleL+bezF[bez_InR]) * derezFreq);
|
||||
bezF[bez_InL] = inputSampleL; bezF[bez_InR] = inputSampleR;
|
||||
bezF[bez_SampL] += (inputSampleL * derezFreq);
|
||||
bezF[bez_SampR] += (inputSampleR * derezFreq);
|
||||
if (bezF[bez_cycle] > 1.0) { //hit the end point and we do a filter sample
|
||||
bezF[bez_cycle] = 0.0;
|
||||
bezF[bez_CL] = bezF[bez_BL];
|
||||
|
|
|
|||
|
|
@ -63,6 +63,7 @@ VerbTiny::VerbTiny(AudioUnit component)
|
|||
SetParameter(kParam_B, kDefaultValue_ParamB );
|
||||
SetParameter(kParam_C, kDefaultValue_ParamC );
|
||||
SetParameter(kParam_D, kDefaultValue_ParamD );
|
||||
SetParameter(kParam_E, kDefaultValue_ParamE );
|
||||
|
||||
#if AU_DEBUG_DISPATCHER
|
||||
mDebugDispatcher = new AUDebugDispatcher (this);
|
||||
|
|
@ -127,7 +128,14 @@ ComponentResult VerbTiny::GetParameterInfo(AudioUnitScope inScope,
|
|||
outParameterInfo.maxValue = 1.0;
|
||||
outParameterInfo.defaultValue = kDefaultValue_ParamD;
|
||||
break;
|
||||
default:
|
||||
case kParam_E:
|
||||
AUBase::FillInParameterName (outParameterInfo, kParameterEName, false);
|
||||
outParameterInfo.unit = kAudioUnitParameterUnit_Generic;
|
||||
outParameterInfo.minValue = 0.0;
|
||||
outParameterInfo.maxValue = 1.0;
|
||||
outParameterInfo.defaultValue = kDefaultValue_ParamE;
|
||||
break;
|
||||
default:
|
||||
result = kAudioUnitErr_InvalidParameter;
|
||||
break;
|
||||
}
|
||||
|
|
@ -220,6 +228,29 @@ ComponentResult VerbTiny::Reset(AudioUnitScope inScope, AudioUnitElement inElem
|
|||
f4AL = f4BL = f4CL = f4DL = 0.0;
|
||||
f4DR = f4HR = f4LR = f4PR = 0.0;
|
||||
|
||||
for(int x = 0; x < d4A+2; x++) {b4AL[x] = 0.0; b4AR[x] = 0.0;}
|
||||
for(int x = 0; x < d4B+2; x++) {b4BL[x] = 0.0; b4BR[x] = 0.0;}
|
||||
for(int x = 0; x < d4C+2; x++) {b4CL[x] = 0.0; b4CR[x] = 0.0;}
|
||||
for(int x = 0; x < d4D+2; x++) {b4DL[x] = 0.0; b4DR[x] = 0.0;}
|
||||
for(int x = 0; x < d4E+2; x++) {b4EL[x] = 0.0; b4ER[x] = 0.0;}
|
||||
for(int x = 0; x < d4F+2; x++) {b4FL[x] = 0.0; b4FR[x] = 0.0;}
|
||||
for(int x = 0; x < d4G+2; x++) {b4GL[x] = 0.0; b4GR[x] = 0.0;}
|
||||
for(int x = 0; x < d4H+2; x++) {b4HL[x] = 0.0; b4HR[x] = 0.0;}
|
||||
for(int x = 0; x < d4I+2; x++) {b4IL[x] = 0.0; b4IR[x] = 0.0;}
|
||||
for(int x = 0; x < d4J+2; x++) {b4JL[x] = 0.0; b4JR[x] = 0.0;}
|
||||
for(int x = 0; x < d4K+2; x++) {b4KL[x] = 0.0; b4KR[x] = 0.0;}
|
||||
for(int x = 0; x < d4L+2; x++) {b4LL[x] = 0.0; b4LR[x] = 0.0;}
|
||||
for(int x = 0; x < d4M+2; x++) {b4ML[x] = 0.0; b4MR[x] = 0.0;}
|
||||
for(int x = 0; x < d4N+2; x++) {b4NL[x] = 0.0; b4NR[x] = 0.0;}
|
||||
for(int x = 0; x < d4O+2; x++) {b4OL[x] = 0.0; b4OR[x] = 0.0;}
|
||||
for(int x = 0; x < d4P+2; x++) {b4PL[x] = 0.0; b4PR[x] = 0.0;}
|
||||
e4AL = e4BL = e4CL = e4DL = e4EL = e4FL = e4GL = e4HL = 1;
|
||||
e4IL = e4JL = e4KL = e4LL = e4ML = e4NL = e4OL = e4PL = 1;
|
||||
e4AR = e4BR = e4CR = e4DR = e4ER = e4FR = e4GR = e4HR = 1;
|
||||
e4IR = e4JR = e4KR = e4LR = e4MR = e4NR = e4OR = e4PR = 1;
|
||||
g4AL = g4BL = g4CL = g4DL = 0.0;
|
||||
g4DR = g4HR = g4LR = g4PR = 0.0;
|
||||
|
||||
for (int x = 0; x < bez_total; x++) {
|
||||
bez[x] = 0.0;
|
||||
bezF[x] = 0.0;
|
||||
|
|
@ -265,7 +296,8 @@ OSStatus VerbTiny::ProcessBufferLists(AudioUnitRenderActionFlags & ioActionFlag
|
|||
derezFreq = 1.0 / bezFreqFraction;
|
||||
bezFreqTrim = 1.0-(derezFreq*bezFreqTrim);
|
||||
//the revision more accurately connects the bezier curves
|
||||
double wet = GetParameter( kParam_D );
|
||||
double wider = GetParameter( kParam_D )*2.0;
|
||||
double wet = GetParameter( kParam_E );
|
||||
|
||||
while (nSampleFrames-- > 0) {
|
||||
double inputSampleL = *inputL;
|
||||
|
|
@ -280,13 +312,13 @@ OSStatus VerbTiny::ProcessBufferLists(AudioUnitRenderActionFlags & ioActionFlag
|
|||
bez[bez_SampR] += (inputSampleR*attenuate*derez);
|
||||
if (bez[bez_cycle] > 1.0) { //hit the end point and we do a reverb sample
|
||||
bez[bez_cycle] = 0.0;
|
||||
inputSampleL = bez[bez_SampL];
|
||||
inputSampleR = bez[bez_SampR];
|
||||
double mainSampleL = bez[bez_SampL];
|
||||
double mainSampleR = bez[bez_SampR]; //begin primary reverb
|
||||
|
||||
a4AL[c4AL] = inputSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = inputSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = inputSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = inputSampleL + (f4DL * reg4n);
|
||||
a4AL[c4AL] = mainSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = mainSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = mainSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = mainSampleL + (f4DL * reg4n);
|
||||
|
||||
c4AL++; if (c4AL < 0 || c4AL > d4A) c4AL = 0;
|
||||
c4BL++; if (c4BL < 0 || c4BL > d4B) c4BL = 0;
|
||||
|
|
@ -298,10 +330,10 @@ OSStatus VerbTiny::ProcessBufferLists(AudioUnitRenderActionFlags & ioActionFlag
|
|||
double o4CL = a4CL[c4CL-((c4CL > d4C)?d4C+1:0)];
|
||||
double o4DL = a4DL[c4DL-((c4DL > d4D)?d4D+1:0)];
|
||||
|
||||
a4DR[c4DR] = inputSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = inputSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = inputSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = inputSampleR + (f4PR * reg4n);
|
||||
a4DR[c4DR] = mainSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = mainSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = mainSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = mainSampleR + (f4PR * reg4n);
|
||||
|
||||
c4DR++; if (c4DR < 0 || c4DR > d4D) c4DR = 0;
|
||||
c4HR++; if (c4HR < 0 || c4HR > d4H) c4HR = 0;
|
||||
|
|
@ -421,8 +453,173 @@ OSStatus VerbTiny::ProcessBufferLists(AudioUnitRenderActionFlags & ioActionFlag
|
|||
f4LR = o4OL - (o4ML + o4NL + o4PL);
|
||||
f4PR = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
inputSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
inputSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
mainSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
mainSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
|
||||
//we still have an untouched inputsample, turn it into dual mono
|
||||
//won't need to redeclare any of the o4 temp variables, just re-use
|
||||
|
||||
double dualmonoSampleL = bez[bez_SampR];
|
||||
double dualmonoSampleR = bez[bez_SampL];
|
||||
//workaround involves keeping the cross-matrix system,
|
||||
//but for initial layering, each side gets each version
|
||||
//making blends never quite line up as exactly the same.
|
||||
|
||||
b4AL[e4AL] = dualmonoSampleL + (g4AL * reg4n);
|
||||
b4BL[e4BL] = dualmonoSampleL + (g4BL * reg4n);
|
||||
b4CL[e4CL] = dualmonoSampleL + (g4CL * reg4n);
|
||||
b4DL[e4DL] = dualmonoSampleL + (g4DL * reg4n);
|
||||
|
||||
e4AL++; if (e4AL < 0 || e4AL > d4A) e4AL = 0;
|
||||
e4BL++; if (e4BL < 0 || e4BL > d4B) e4BL = 0;
|
||||
e4CL++; if (e4CL < 0 || e4CL > d4C) e4CL = 0;
|
||||
e4DL++; if (e4DL < 0 || e4DL > d4D) e4DL = 0;
|
||||
|
||||
o4AL = b4AL[e4AL-((e4AL > d4A)?d4A+1:0)];
|
||||
o4BL = b4BL[e4BL-((e4BL > d4B)?d4B+1:0)];
|
||||
o4CL = b4CL[e4CL-((e4CL > d4C)?d4C+1:0)];
|
||||
o4DL = b4DL[e4DL-((e4DL > d4D)?d4D+1:0)];
|
||||
|
||||
b4DR[e4DR] = dualmonoSampleR + (g4DR * reg4n);
|
||||
b4HR[e4HR] = dualmonoSampleR + (g4HR * reg4n);
|
||||
b4LR[e4LR] = dualmonoSampleR + (g4LR * reg4n);
|
||||
b4PR[e4PR] = dualmonoSampleR + (g4PR * reg4n);
|
||||
|
||||
e4DR++; if (e4DR < 0 || e4DR > d4D) e4DR = 0;
|
||||
e4HR++; if (e4HR < 0 || e4HR > d4H) e4HR = 0;
|
||||
e4LR++; if (e4LR < 0 || e4LR > d4L) e4LR = 0;
|
||||
e4PR++; if (e4PR < 0 || e4PR > d4P) e4PR = 0;
|
||||
|
||||
o4DR = b4DR[e4DR-((e4DR > d4D)?d4D+1:0)];
|
||||
o4HR = b4HR[e4HR-((e4HR > d4H)?d4H+1:0)];
|
||||
o4LR = b4LR[e4LR-((e4LR > d4L)?d4L+1:0)];
|
||||
o4PR = b4PR[e4PR-((e4PR > d4P)?d4P+1:0)];
|
||||
|
||||
//-------- one
|
||||
|
||||
b4EL[e4EL] = o4AL - (o4BL + o4CL + o4DL);
|
||||
b4FL[e4FL] = o4BL - (o4AL + o4CL + o4DL);
|
||||
b4GL[e4GL] = o4CL - (o4AL + o4BL + o4DL);
|
||||
b4HL[e4HL] = o4DL - (o4AL + o4BL + o4CL);
|
||||
|
||||
e4EL++; if (e4EL < 0 || e4EL > d4E) e4EL = 0;
|
||||
e4FL++; if (e4FL < 0 || e4FL > d4F) e4FL = 0;
|
||||
e4GL++; if (e4GL < 0 || e4GL > d4G) e4GL = 0;
|
||||
e4HL++; if (e4HL < 0 || e4HL > d4H) e4HL = 0;
|
||||
|
||||
o4EL = b4EL[e4EL-((e4EL > d4E)?d4E+1:0)];
|
||||
o4FL = b4FL[e4FL-((e4FL > d4F)?d4F+1:0)];
|
||||
o4GL = b4GL[e4GL-((e4GL > d4G)?d4G+1:0)];
|
||||
o4HL = b4HL[e4HL-((e4HL > d4H)?d4H+1:0)];
|
||||
|
||||
b4CR[e4CR] = o4DR - (o4HR + o4LR + o4PR);
|
||||
b4GR[e4GR] = o4HR - (o4DR + o4LR + o4PR);
|
||||
b4KR[e4KR] = o4LR - (o4DR + o4HR + o4PR);
|
||||
b4OR[e4OR] = o4PR - (o4DR + o4HR + o4LR);
|
||||
|
||||
e4CR++; if (e4CR < 0 || e4CR > d4C) e4CR = 0;
|
||||
e4GR++; if (e4GR < 0 || e4GR > d4G) e4GR = 0;
|
||||
e4KR++; if (e4KR < 0 || e4KR > d4K) e4KR = 0;
|
||||
e4OR++; if (e4OR < 0 || e4OR > d4O) e4OR = 0;
|
||||
|
||||
o4CR = b4CR[e4CR-((e4CR > d4C)?d4C+1:0)];
|
||||
o4GR = b4GR[e4GR-((e4GR > d4G)?d4G+1:0)];
|
||||
o4KR = b4KR[e4KR-((e4KR > d4K)?d4K+1:0)];
|
||||
o4OR = b4OR[e4OR-((e4OR > d4O)?d4O+1:0)];
|
||||
|
||||
//-------- two
|
||||
|
||||
b4IL[e4IL] = o4EL - (o4FL + o4GL + o4HL);
|
||||
b4JL[e4JL] = o4FL - (o4EL + o4GL + o4HL);
|
||||
b4KL[e4KL] = o4GL - (o4EL + o4FL + o4HL);
|
||||
b4LL[e4LL] = o4HL - (o4EL + o4FL + o4GL);
|
||||
|
||||
e4IL++; if (e4IL < 0 || e4IL > d4I) e4IL = 0;
|
||||
e4JL++; if (e4JL < 0 || e4JL > d4J) e4JL = 0;
|
||||
e4KL++; if (e4KL < 0 || e4KL > d4K) e4KL = 0;
|
||||
e4LL++; if (e4LL < 0 || e4LL > d4L) e4LL = 0;
|
||||
|
||||
o4IL = b4IL[e4IL-((e4IL > d4I)?d4I+1:0)];
|
||||
o4JL = b4JL[e4JL-((e4JL > d4J)?d4J+1:0)];
|
||||
o4KL = b4KL[e4KL-((e4KL > d4K)?d4K+1:0)];
|
||||
o4LL = b4LL[e4LL-((e4LL > d4L)?d4L+1:0)];
|
||||
|
||||
b4BR[e4BR] = o4CR - (o4GR + o4KR + o4OR);
|
||||
b4FR[e4FR] = o4GR - (o4CR + o4KR + o4OR);
|
||||
b4JR[e4JR] = o4KR - (o4CR + o4GR + o4OR);
|
||||
b4NR[e4NR] = o4OR - (o4CR + o4GR + o4KR);
|
||||
|
||||
e4BR++; if (e4BR < 0 || e4BR > d4B) e4BR = 0;
|
||||
e4FR++; if (e4FR < 0 || e4FR > d4F) e4FR = 0;
|
||||
e4JR++; if (e4JR < 0 || e4JR > d4J) e4JR = 0;
|
||||
e4NR++; if (e4NR < 0 || e4NR > d4N) e4NR = 0;
|
||||
|
||||
o4BR = b4BR[e4BR-((e4BR > d4B)?d4B+1:0)];
|
||||
o4FR = b4FR[e4FR-((e4FR > d4F)?d4F+1:0)];
|
||||
o4JR = b4JR[e4JR-((e4JR > d4J)?d4J+1:0)];
|
||||
o4NR = b4NR[e4NR-((e4NR > d4N)?d4N+1:0)];
|
||||
|
||||
//-------- three
|
||||
|
||||
b4ML[e4ML] = o4IL - (o4JL + o4KL + o4LL);
|
||||
b4NL[e4NL] = o4JL - (o4IL + o4KL + o4LL);
|
||||
b4OL[e4OL] = o4KL - (o4IL + o4JL + o4LL);
|
||||
b4PL[e4PL] = o4LL - (o4IL + o4JL + o4KL);
|
||||
|
||||
e4ML++; if (e4ML < 0 || e4ML > d4M) e4ML = 0;
|
||||
e4NL++; if (e4NL < 0 || e4NL > d4N) e4NL = 0;
|
||||
e4OL++; if (e4OL < 0 || e4OL > d4O) e4OL = 0;
|
||||
e4PL++; if (e4PL < 0 || e4PL > d4P) e4PL = 0;
|
||||
|
||||
o4ML = b4ML[e4ML-((e4ML > d4M)?d4M+1:0)];
|
||||
o4NL = b4NL[e4NL-((e4NL > d4N)?d4N+1:0)];
|
||||
o4OL = b4OL[e4OL-((e4OL > d4O)?d4O+1:0)];
|
||||
o4PL = b4PL[e4PL-((e4PL > d4P)?d4P+1:0)];
|
||||
|
||||
b4AR[e4AR] = o4BR - (o4FR + o4JR + o4NR);
|
||||
b4ER[e4ER] = o4FR - (o4BR + o4JR + o4NR);
|
||||
b4IR[e4IR] = o4JR - (o4BR + o4FR + o4NR);
|
||||
b4MR[e4MR] = o4NR - (o4BR + o4FR + o4JR);
|
||||
|
||||
e4AR++; if (e4AR < 0 || e4AR > d4A) e4AR = 0;
|
||||
e4ER++; if (e4ER < 0 || e4ER > d4E) e4ER = 0;
|
||||
e4IR++; if (e4IR < 0 || e4IR > d4I) e4IR = 0;
|
||||
e4MR++; if (e4MR < 0 || e4MR > d4M) e4MR = 0;
|
||||
|
||||
o4AR = b4AR[e4AR-((e4AR > d4A)?d4A+1:0)];
|
||||
o4ER = b4ER[e4ER-((e4ER > d4E)?d4E+1:0)];
|
||||
o4IR = b4IR[e4IR-((e4IR > d4I)?d4I+1:0)];
|
||||
o4MR = b4MR[e4MR-((e4MR > d4M)?d4M+1:0)];
|
||||
|
||||
//-------- four
|
||||
|
||||
g4DR = o4AR - (o4ER + o4IR + o4MR);
|
||||
g4HR = o4ER - (o4AR + o4IR + o4MR);
|
||||
g4LR = o4IR - (o4AR + o4ER + o4MR);
|
||||
g4PR = o4MR - (o4AR + o4ER + o4IR);
|
||||
|
||||
g4AL = o4ML - (o4NL + o4OL + o4PL);
|
||||
g4BL = o4NL - (o4ML + o4OL + o4PL);
|
||||
g4CL = o4OL - (o4ML + o4NL + o4PL);
|
||||
g4DL = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
dualmonoSampleR = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
dualmonoSampleL = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
//dual mono version is wider = 1.0 at the center
|
||||
//with mainsample 0.0 and 2.0 (only at the edges)
|
||||
//with mainsample out of phase when over 1.0
|
||||
//couldn't re-do the arrays perfectly, so instead
|
||||
//we keep exactly the same cross-matrix,
|
||||
//but we flip the sides we're using for initial reverb.
|
||||
//then, dualmono remains totally dualmono, and blend a bit in for wideness.
|
||||
|
||||
if (wider < 1.0) {
|
||||
inputSampleL = (dualmonoSampleL*wider) + (mainSampleL*(1.0-wider));
|
||||
inputSampleR = (dualmonoSampleR*wider) + (mainSampleR*(1.0-wider));
|
||||
} else {
|
||||
inputSampleL = (dualmonoSampleL*(2.0-wider)) + (mainSampleL*(wider-1.0));
|
||||
inputSampleR = (dualmonoSampleR*(2.0-wider)) + (-mainSampleR*(wider-1.0));
|
||||
}
|
||||
|
||||
bez[bez_CL] = bez[bez_BL];
|
||||
bez[bez_BL] = bez[bez_AL];
|
||||
|
|
@ -443,9 +640,8 @@ OSStatus VerbTiny::ProcessBufferLists(AudioUnitRenderActionFlags & ioActionFlag
|
|||
inputSampleR = (bez[bez_BR]+(CBR*(1.0-X))+(BAR*X))*-0.25;
|
||||
|
||||
bezF[bez_cycle] += derezFreq;
|
||||
bezF[bez_SampL] += ((inputSampleL+bezF[bez_InL]) * derezFreq);
|
||||
bezF[bez_SampR] += ((inputSampleL+bezF[bez_InR]) * derezFreq);
|
||||
bezF[bez_InL] = inputSampleL; bezF[bez_InR] = inputSampleR;
|
||||
bezF[bez_SampL] += (inputSampleL * derezFreq);
|
||||
bezF[bez_SampR] += (inputSampleR * derezFreq);
|
||||
if (bezF[bez_cycle] > 1.0) { //hit the end point and we do a filter sample
|
||||
bezF[bez_cycle] = 0.0;
|
||||
bezF[bez_CL] = bezF[bez_BL];
|
||||
|
|
@ -460,10 +656,10 @@ OSStatus VerbTiny::ProcessBufferLists(AudioUnitRenderActionFlags & ioActionFlag
|
|||
X = bezF[bez_cycle]*bezFreqTrim;
|
||||
double CBLfreq = (bezF[bez_CL]*(1.0-X))+(bezF[bez_BL]*X);
|
||||
double BALfreq = (bezF[bez_BL]*(1.0-X))+(bezF[bez_AL]*X);
|
||||
inputSampleL = (bezF[bez_BL]+(CBLfreq*(1.0-X))+(BALfreq*X))*0.25;
|
||||
inputSampleL = (bezF[bez_BL]+(CBLfreq*(1.0-X))+(BALfreq*X))*0.5;
|
||||
double CBRfreq = (bezF[bez_CR]*(1.0-X))+(bezF[bez_BR]*X);
|
||||
double BARfreq = (bezF[bez_BR]*(1.0-X))+(bezF[bez_AR]*X);
|
||||
inputSampleR = (bezF[bez_BR]+(CBRfreq*(1.0-X))+(BARfreq*X))*0.25;
|
||||
inputSampleR = (bezF[bez_BR]+(CBRfreq*(1.0-X))+(BARfreq*X))*0.5;
|
||||
//filtering the reverb separately, after making it
|
||||
|
||||
inputSampleL = (inputSampleL * wet)+(drySampleL * (1.0-wet));
|
||||
|
|
|
|||
|
|
@ -57,23 +57,30 @@
|
|||
static const float kDefaultValue_ParamA = 0.5;
|
||||
static const float kDefaultValue_ParamB = 1.0;
|
||||
static const float kDefaultValue_ParamC = 1.0;
|
||||
static const float kDefaultValue_ParamD = 1.0;
|
||||
static const float kDefaultValue_ParamD = 0.0;
|
||||
static const float kDefaultValue_ParamE = 1.0;
|
||||
|
||||
static CFStringRef kParameterAName = CFSTR("Replace");
|
||||
static CFStringRef kParameterBName = CFSTR("Derez");
|
||||
static CFStringRef kParameterCName = CFSTR("Filter");
|
||||
static CFStringRef kParameterDName = CFSTR("Dry/Wet");
|
||||
static CFStringRef kParameterDName = CFSTR("Wider");
|
||||
static CFStringRef kParameterEName = CFSTR("Dry/Wet");
|
||||
|
||||
enum {
|
||||
kParam_A =0,
|
||||
kParam_B =1,
|
||||
kParam_C =2,
|
||||
kParam_D =3,
|
||||
kParam_E =4,
|
||||
//Add your parameters here...
|
||||
kNumberOfParameters=4
|
||||
kNumberOfParameters=5
|
||||
};
|
||||
|
||||
const int d4A = 136; const int d4B = 52; const int d4C = 53; const int d4D = 1261; const int d4E = 209; const int d4F = 473; const int d4G = 549; const int d4H = 29; const int d4I = 92; const int d4J = 1137; const int d4K = 1406; const int d4L = 994; const int d4M = 1314; const int d4N = 191; const int d4O = 1263; const int d4P = 103; //5 to 116 ms, 436 seat theater
|
||||
const int d4A = 136; const int d4B = 52; const int d4C = 53; const int d4D = 1261;
|
||||
const int d4E = 209; const int d4F = 473; const int d4G = 549; const int d4H = 29;
|
||||
const int d4I = 92; const int d4J = 1137; const int d4K = 1406; const int d4L = 994;
|
||||
const int d4M = 1314; const int d4N = 191; const int d4O = 1263; const int d4P = 103;
|
||||
//5 to 116 ms, 436 seat theater
|
||||
#define FOURBYFOUR true // 436seat1365253x4 on 2025-11-09 VerbTiny
|
||||
|
||||
#pragma mark ____VerbTiny
|
||||
|
|
@ -157,6 +164,45 @@ public:
|
|||
int c4AR,c4BR,c4CR,c4DR,c4ER,c4FR,c4GR,c4HR;
|
||||
int c4IR,c4JR,c4KR,c4LR,c4MR,c4NR,c4OR,c4PR;
|
||||
double f4AL,f4BL,f4CL,f4DL,f4DR,f4HR,f4LR,f4PR;
|
||||
//base stereo reverb
|
||||
double b4AL[d4A+5];
|
||||
double b4BL[d4B+5];
|
||||
double b4CL[d4C+5];
|
||||
double b4DL[d4D+5];
|
||||
double b4EL[d4E+5];
|
||||
double b4FL[d4F+5];
|
||||
double b4GL[d4G+5];
|
||||
double b4HL[d4H+5];
|
||||
double b4IL[d4I+5];
|
||||
double b4JL[d4J+5];
|
||||
double b4KL[d4K+5];
|
||||
double b4LL[d4L+5];
|
||||
double b4ML[d4M+5];
|
||||
double b4NL[d4N+5];
|
||||
double b4OL[d4O+5];
|
||||
double b4PL[d4P+5];
|
||||
double b4AR[d4A+5];
|
||||
double b4BR[d4B+5];
|
||||
double b4CR[d4C+5];
|
||||
double b4DR[d4D+5];
|
||||
double b4ER[d4E+5];
|
||||
double b4FR[d4F+5];
|
||||
double b4GR[d4G+5];
|
||||
double b4HR[d4H+5];
|
||||
double b4IR[d4I+5];
|
||||
double b4JR[d4J+5];
|
||||
double b4KR[d4K+5];
|
||||
double b4LR[d4L+5];
|
||||
double b4MR[d4M+5];
|
||||
double b4NR[d4N+5];
|
||||
double b4OR[d4O+5];
|
||||
double b4PR[d4P+5];
|
||||
int e4AL,e4BL,e4CL,e4DL,e4EL,e4FL,e4GL,e4HL;
|
||||
int e4IL,e4JL,e4KL,e4LL,e4ML,e4NL,e4OL,e4PL;
|
||||
int e4AR,e4BR,e4CR,e4DR,e4ER,e4FR,e4GR,e4HR;
|
||||
int e4IR,e4JR,e4KR,e4LR,e4MR,e4NR,e4OR,e4PR;
|
||||
double g4AL,g4BL,g4CL,g4DL,g4DR,g4HR,g4LR,g4PR;
|
||||
//changed letter is the dual mono, with rearranged grid
|
||||
|
||||
enum {
|
||||
bez_AL,
|
||||
|
|
@ -165,8 +211,6 @@ public:
|
|||
bez_BR,
|
||||
bez_CL,
|
||||
bez_CR,
|
||||
bez_InL,
|
||||
bez_InR,
|
||||
bez_SampL,
|
||||
bez_SampR,
|
||||
bez_cycle,
|
||||
|
|
|
|||
|
|
@ -3,6 +3,8 @@
|
|||
089C1669FE841209C02AAC07 /* Project object */ = {
|
||||
activeBuildConfigurationName = Release;
|
||||
activeTarget = 8D01CCC60486CAD60068D4B7 /* VerbTiny */;
|
||||
breakpoints = (
|
||||
);
|
||||
codeSenseManager = 8BD3CCB9148830B20062E48C /* Code sense */;
|
||||
perUserDictionary = {
|
||||
PBXConfiguration.PBXFileTableDataSource3.PBXFileTableDataSource = {
|
||||
|
|
@ -49,13 +51,13 @@
|
|||
PBXFileDataSource_Warnings_ColumnID,
|
||||
);
|
||||
};
|
||||
PBXPerProjectTemplateStateSaveDate = 784510043;
|
||||
PBXWorkspaceStateSaveDate = 784510043;
|
||||
PBXPerProjectTemplateStateSaveDate = 785500090;
|
||||
PBXWorkspaceStateSaveDate = 785500090;
|
||||
};
|
||||
perUserProjectItems = {
|
||||
8B8C63E12EC2B04A008CA66C /* PBXTextBookmark */ = 8B8C63E12EC2B04A008CA66C /* PBXTextBookmark */;
|
||||
8B8C63E22EC2B04A008CA66C /* PBXTextBookmark */ = 8B8C63E22EC2B04A008CA66C /* PBXTextBookmark */;
|
||||
8B8C63E32EC2B04A008CA66C /* PBXTextBookmark */ = 8B8C63E32EC2B04A008CA66C /* PBXTextBookmark */;
|
||||
8BFFBC6C2ED133D400188089 /* PBXTextBookmark */ = 8BFFBC6C2ED133D400188089 /* PBXTextBookmark */;
|
||||
8BFFBCBA2ED1D18A00188089 /* PBXTextBookmark */ = 8BFFBCBA2ED1D18A00188089 /* PBXTextBookmark */;
|
||||
};
|
||||
sourceControlManager = 8BD3CCB8148830B20062E48C /* Source Control */;
|
||||
userBuildSettings = {
|
||||
|
|
@ -66,37 +68,17 @@
|
|||
fRef = 8BC6025B073B072D006C4272 /* VerbTiny.h */;
|
||||
name = "VerbTiny.h: 169";
|
||||
rLen = 0;
|
||||
rLoc = 6502;
|
||||
rLoc = 7585;
|
||||
rType = 0;
|
||||
vrLen = 35;
|
||||
vrLoc = 6481;
|
||||
};
|
||||
8B8C63E22EC2B04A008CA66C /* PBXTextBookmark */ = {
|
||||
isa = PBXTextBookmark;
|
||||
fRef = 8BA05A660720730100365D66 /* VerbTiny.cpp */;
|
||||
name = "VerbTiny.cpp: 450";
|
||||
rLen = 0;
|
||||
rLoc = 19076;
|
||||
rType = 0;
|
||||
vrLen = 47;
|
||||
vrLoc = 20524;
|
||||
};
|
||||
8B8C63E32EC2B04A008CA66C /* PBXTextBookmark */ = {
|
||||
isa = PBXTextBookmark;
|
||||
fRef = 8BA05A660720730100365D66 /* VerbTiny.cpp */;
|
||||
name = "VerbTiny.cpp: 450";
|
||||
rLen = 0;
|
||||
rLoc = 19076;
|
||||
rType = 0;
|
||||
vrLen = 47;
|
||||
vrLoc = 20524;
|
||||
};
|
||||
8BA05A660720730100365D66 /* VerbTiny.cpp */ = {
|
||||
uiCtxt = {
|
||||
sepNavIntBoundsRect = "{{0, 0}, {831, 9036}}";
|
||||
sepNavSelRange = "{19076, 0}";
|
||||
sepNavVisRange = "{20524, 47}";
|
||||
sepNavWindowFrame = "{{106, 139}, {840, 739}}";
|
||||
sepNavIntBoundsRect = "{{0, 0}, {554, 12276}}";
|
||||
sepNavSelRange = "{27066, 0}";
|
||||
sepNavVisRange = "{0, 0}";
|
||||
sepNavWindowFrame = "{{439, 105}, {999, 764}}";
|
||||
};
|
||||
};
|
||||
8BA05A690720730100365D66 /* VerbTinyVersion.h */ = {
|
||||
|
|
@ -116,10 +98,10 @@
|
|||
};
|
||||
8BC6025B073B072D006C4272 /* VerbTiny.h */ = {
|
||||
uiCtxt = {
|
||||
sepNavIntBoundsRect = "{{0, 0}, {705, 3744}}";
|
||||
sepNavSelRange = "{6502, 0}";
|
||||
sepNavVisRange = "{6481, 35}";
|
||||
sepNavWindowFrame = "{{15, 38}, {843, 840}}";
|
||||
sepNavIntBoundsRect = "{{0, 0}, {1146, 4698}}";
|
||||
sepNavSelRange = "{7585, 0}";
|
||||
sepNavVisRange = "{7012, 883}";
|
||||
sepNavWindowFrame = "{{597, 38}, {843, 840}}";
|
||||
};
|
||||
};
|
||||
8BD3CCB8148830B20062E48C /* Source Control */ = {
|
||||
|
|
@ -136,6 +118,26 @@
|
|||
isa = PBXCodeSenseManager;
|
||||
indexTemplatePath = "";
|
||||
};
|
||||
8BFFBC6C2ED133D400188089 /* PBXTextBookmark */ = {
|
||||
isa = PBXTextBookmark;
|
||||
fRef = 8BA05A660720730100365D66 /* VerbTiny.cpp */;
|
||||
name = "VerbTiny.cpp: 647";
|
||||
rLen = 0;
|
||||
rLoc = 27066;
|
||||
rType = 0;
|
||||
vrLen = 49;
|
||||
vrLoc = 20936;
|
||||
};
|
||||
8BFFBCBA2ED1D18A00188089 /* PBXTextBookmark */ = {
|
||||
isa = PBXTextBookmark;
|
||||
fRef = 8BA05A660720730100365D66 /* VerbTiny.cpp */;
|
||||
name = "VerbTiny.cpp: 646";
|
||||
rLen = 0;
|
||||
rLoc = 27066;
|
||||
rType = 0;
|
||||
vrLen = 0;
|
||||
vrLoc = 0;
|
||||
};
|
||||
8D01CCC60486CAD60068D4B7 /* VerbTiny */ = {
|
||||
activeExec = 0;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -324,7 +324,7 @@
|
|||
<real>185</real>
|
||||
</array>
|
||||
<key>RubberWindowFrame</key>
|
||||
<string>4 341 810 487 0 0 1440 878 </string>
|
||||
<string>638 168 810 487 0 0 1440 878 </string>
|
||||
</dict>
|
||||
<key>Module</key>
|
||||
<string>PBXSmartGroupTreeModule</string>
|
||||
|
|
@ -352,11 +352,11 @@
|
|||
<key>_historyCapacity</key>
|
||||
<integer>0</integer>
|
||||
<key>bookmark</key>
|
||||
<string>8B8C63E32EC2B04A008CA66C</string>
|
||||
<string>8BFFBCBA2ED1D18A00188089</string>
|
||||
<key>history</key>
|
||||
<array>
|
||||
<string>8B8C63E12EC2B04A008CA66C</string>
|
||||
<string>8B8C63E22EC2B04A008CA66C</string>
|
||||
<string>8BFFBC6C2ED133D400188089</string>
|
||||
</array>
|
||||
</dict>
|
||||
<key>SplitCount</key>
|
||||
|
|
@ -370,18 +370,18 @@
|
|||
<key>GeometryConfiguration</key>
|
||||
<dict>
|
||||
<key>Frame</key>
|
||||
<string>{{0, 0}, {603, 86}}</string>
|
||||
<string>{{0, 0}, {603, 32}}</string>
|
||||
<key>RubberWindowFrame</key>
|
||||
<string>4 341 810 487 0 0 1440 878 </string>
|
||||
<string>638 168 810 487 0 0 1440 878 </string>
|
||||
</dict>
|
||||
<key>Module</key>
|
||||
<string>PBXNavigatorGroup</string>
|
||||
<key>Proportion</key>
|
||||
<string>86pt</string>
|
||||
<string>32pt</string>
|
||||
</dict>
|
||||
<dict>
|
||||
<key>Proportion</key>
|
||||
<string>355pt</string>
|
||||
<string>409pt</string>
|
||||
<key>Tabs</key>
|
||||
<array>
|
||||
<dict>
|
||||
|
|
@ -395,9 +395,9 @@
|
|||
<key>GeometryConfiguration</key>
|
||||
<dict>
|
||||
<key>Frame</key>
|
||||
<string>{{10, 27}, {603, 328}}</string>
|
||||
<string>{{10, 27}, {603, 382}}</string>
|
||||
<key>RubberWindowFrame</key>
|
||||
<string>4 341 810 487 0 0 1440 878 </string>
|
||||
<string>638 168 810 487 0 0 1440 878 </string>
|
||||
</dict>
|
||||
<key>Module</key>
|
||||
<string>XCDetailModule</string>
|
||||
|
|
@ -451,7 +451,7 @@
|
|||
<key>GeometryConfiguration</key>
|
||||
<dict>
|
||||
<key>Frame</key>
|
||||
<string>{{10, 27}, {603, 297}}</string>
|
||||
<string>{{10, 27}, {603, 345}}</string>
|
||||
</dict>
|
||||
<key>Module</key>
|
||||
<string>PBXBuildResultsModule</string>
|
||||
|
|
@ -479,11 +479,11 @@
|
|||
</array>
|
||||
<key>TableOfContents</key>
|
||||
<array>
|
||||
<string>8B8C63E42EC2B04A008CA66C</string>
|
||||
<string>8BFFBC792ED1C7BE00188089</string>
|
||||
<string>1CA23ED40692098700951B8B</string>
|
||||
<string>8B8C63E52EC2B04A008CA66C</string>
|
||||
<string>8BFFBC7A2ED1C7BE00188089</string>
|
||||
<string>8B7264FA2EC29D270065D50D</string>
|
||||
<string>8B8C63E62EC2B04A008CA66C</string>
|
||||
<string>8BFFBC7B2ED1C7BE00188089</string>
|
||||
<string>1CA23EDF0692099D00951B8B</string>
|
||||
<string>1CA23EE00692099D00951B8B</string>
|
||||
<string>1CA23EE10692099D00951B8B</string>
|
||||
|
|
@ -520,7 +520,7 @@
|
|||
<key>Identifier</key>
|
||||
<string>perspective.debug</string>
|
||||
<key>IsVertical</key>
|
||||
<integer>1</integer>
|
||||
<true/>
|
||||
<key>Layout</key>
|
||||
<array>
|
||||
<dict>
|
||||
|
|
@ -534,12 +534,12 @@
|
|||
<key>GeometryConfiguration</key>
|
||||
<dict>
|
||||
<key>Frame</key>
|
||||
<string>{{0, 0}, {810, 0}}</string>
|
||||
<string>{{0, 0}, {424, 270}}</string>
|
||||
</dict>
|
||||
<key>Module</key>
|
||||
<string>PBXDebugCLIModule</string>
|
||||
<key>Proportion</key>
|
||||
<string>0%</string>
|
||||
<string>270pt</string>
|
||||
</dict>
|
||||
<dict>
|
||||
<key>ContentConfiguration</key>
|
||||
|
|
@ -588,8 +588,6 @@
|
|||
</dict>
|
||||
<key>GeometryConfiguration</key>
|
||||
<dict>
|
||||
<key>DebugConsoleDrawerSize</key>
|
||||
<string>{100, 120}</string>
|
||||
<key>DebugConsoleVisible</key>
|
||||
<string>None</string>
|
||||
<key>DebugConsoleWindowFrame</key>
|
||||
|
|
@ -598,31 +596,53 @@
|
|||
<string>{{200, 200}, {500, 300}}</string>
|
||||
<key>Frame</key>
|
||||
<string>{{0, 7}, {810, 438}}</string>
|
||||
<key>PBXDebugSessionStackFrameViewKey</key>
|
||||
<dict>
|
||||
<key>DebugVariablesTableConfiguration</key>
|
||||
<array>
|
||||
<string>Name</string>
|
||||
<real>120</real>
|
||||
<string>Value</string>
|
||||
<real>85</real>
|
||||
<string>Summary</string>
|
||||
<real>185</real>
|
||||
</array>
|
||||
<key>Frame</key>
|
||||
<string>{{395, 0}, {415, 213}}</string>
|
||||
</dict>
|
||||
</dict>
|
||||
<key>Module</key>
|
||||
<string>PBXDebugSessionModule</string>
|
||||
<key>Proportion</key>
|
||||
<string>443pt</string>
|
||||
<string>438pt</string>
|
||||
</dict>
|
||||
</array>
|
||||
<key>Name</key>
|
||||
<string>Debug</string>
|
||||
<key>ServiceClasses</key>
|
||||
<array>
|
||||
<string>XCModuleDock</string>
|
||||
<string>XCModuleDock</string>
|
||||
<string>PBXDebugCLIModule</string>
|
||||
<string>PBXDebugSessionModule</string>
|
||||
<string>XCConsole</string>
|
||||
<string>PBXDebugProcessAndThreadModule</string>
|
||||
<string>PBXDebugProcessViewModule</string>
|
||||
<string>PBXDebugThreadViewModule</string>
|
||||
<string>PBXDebugStackFrameViewModule</string>
|
||||
<string>PBXNavigatorGroup</string>
|
||||
</array>
|
||||
<key>TableOfContents</key>
|
||||
<array>
|
||||
<string>1CC8E6A5069209BD00BB180A</string>
|
||||
<string>1CC8E6A6069209BD00BB180A</string>
|
||||
<string>8BFFBC422ED127DE00188089</string>
|
||||
<string>1CCC7628064C1048000F2A68</string>
|
||||
<string>1CCC7629064C1048000F2A68</string>
|
||||
<string>1CC8E6A7069209BD00BB180A</string>
|
||||
<string>8BFFBC432ED127DE00188089</string>
|
||||
<string>8BFFBC442ED127DE00188089</string>
|
||||
<string>8BFFBC452ED127DE00188089</string>
|
||||
<string>8BFFBC462ED127DE00188089</string>
|
||||
<string>8BFFBC472ED127DE00188089</string>
|
||||
</array>
|
||||
<key>ToolbarConfigUserDefaultsMinorVersion</key>
|
||||
<string>2</string>
|
||||
<key>ToolbarConfiguration</key>
|
||||
<string>xcode.toolbar.config.debugV3</string>
|
||||
</dict>
|
||||
|
|
@ -636,7 +656,7 @@
|
|||
<key>StatusbarIsVisible</key>
|
||||
<true/>
|
||||
<key>TimeStamp</key>
|
||||
<real>784511050.533252</real>
|
||||
<real>785502602.92543697</real>
|
||||
<key>ToolbarConfigUserDefaultsMinorVersion</key>
|
||||
<string>2</string>
|
||||
<key>ToolbarDisplayMode</key>
|
||||
|
|
@ -653,11 +673,10 @@
|
|||
<integer>5</integer>
|
||||
<key>WindowOrderList</key>
|
||||
<array>
|
||||
<string>8B8C63E72EC2B04A008CA66C</string>
|
||||
<string>/Users/christopherjohnson/Desktop/airwindows/plugins/MacAU/VerbTiny/VerbTiny.xcodeproj</string>
|
||||
</array>
|
||||
<key>WindowString</key>
|
||||
<string>4 341 810 487 0 0 1440 878 </string>
|
||||
<string>638 168 810 487 0 0 1440 878 </string>
|
||||
<key>WindowToolsV3</key>
|
||||
<array>
|
||||
<dict>
|
||||
|
|
|
|||
|
|
@ -63,6 +63,7 @@ VerbTiny::VerbTiny(AudioUnit component)
|
|||
SetParameter(kParam_B, kDefaultValue_ParamB );
|
||||
SetParameter(kParam_C, kDefaultValue_ParamC );
|
||||
SetParameter(kParam_D, kDefaultValue_ParamD );
|
||||
SetParameter(kParam_E, kDefaultValue_ParamE );
|
||||
|
||||
#if AU_DEBUG_DISPATCHER
|
||||
mDebugDispatcher = new AUDebugDispatcher (this);
|
||||
|
|
@ -127,7 +128,14 @@ ComponentResult VerbTiny::GetParameterInfo(AudioUnitScope inScope,
|
|||
outParameterInfo.maxValue = 1.0;
|
||||
outParameterInfo.defaultValue = kDefaultValue_ParamD;
|
||||
break;
|
||||
default:
|
||||
case kParam_E:
|
||||
AUBase::FillInParameterName (outParameterInfo, kParameterEName, false);
|
||||
outParameterInfo.unit = kAudioUnitParameterUnit_Generic;
|
||||
outParameterInfo.minValue = 0.0;
|
||||
outParameterInfo.maxValue = 1.0;
|
||||
outParameterInfo.defaultValue = kDefaultValue_ParamE;
|
||||
break;
|
||||
default:
|
||||
result = kAudioUnitErr_InvalidParameter;
|
||||
break;
|
||||
}
|
||||
|
|
@ -220,6 +228,29 @@ ComponentResult VerbTiny::Reset(AudioUnitScope inScope, AudioUnitElement inElem
|
|||
f4AL = f4BL = f4CL = f4DL = 0.0;
|
||||
f4DR = f4HR = f4LR = f4PR = 0.0;
|
||||
|
||||
for(int x = 0; x < d4A+2; x++) {b4AL[x] = 0.0; b4AR[x] = 0.0;}
|
||||
for(int x = 0; x < d4B+2; x++) {b4BL[x] = 0.0; b4BR[x] = 0.0;}
|
||||
for(int x = 0; x < d4C+2; x++) {b4CL[x] = 0.0; b4CR[x] = 0.0;}
|
||||
for(int x = 0; x < d4D+2; x++) {b4DL[x] = 0.0; b4DR[x] = 0.0;}
|
||||
for(int x = 0; x < d4E+2; x++) {b4EL[x] = 0.0; b4ER[x] = 0.0;}
|
||||
for(int x = 0; x < d4F+2; x++) {b4FL[x] = 0.0; b4FR[x] = 0.0;}
|
||||
for(int x = 0; x < d4G+2; x++) {b4GL[x] = 0.0; b4GR[x] = 0.0;}
|
||||
for(int x = 0; x < d4H+2; x++) {b4HL[x] = 0.0; b4HR[x] = 0.0;}
|
||||
for(int x = 0; x < d4I+2; x++) {b4IL[x] = 0.0; b4IR[x] = 0.0;}
|
||||
for(int x = 0; x < d4J+2; x++) {b4JL[x] = 0.0; b4JR[x] = 0.0;}
|
||||
for(int x = 0; x < d4K+2; x++) {b4KL[x] = 0.0; b4KR[x] = 0.0;}
|
||||
for(int x = 0; x < d4L+2; x++) {b4LL[x] = 0.0; b4LR[x] = 0.0;}
|
||||
for(int x = 0; x < d4M+2; x++) {b4ML[x] = 0.0; b4MR[x] = 0.0;}
|
||||
for(int x = 0; x < d4N+2; x++) {b4NL[x] = 0.0; b4NR[x] = 0.0;}
|
||||
for(int x = 0; x < d4O+2; x++) {b4OL[x] = 0.0; b4OR[x] = 0.0;}
|
||||
for(int x = 0; x < d4P+2; x++) {b4PL[x] = 0.0; b4PR[x] = 0.0;}
|
||||
e4AL = e4BL = e4CL = e4DL = e4EL = e4FL = e4GL = e4HL = 1;
|
||||
e4IL = e4JL = e4KL = e4LL = e4ML = e4NL = e4OL = e4PL = 1;
|
||||
e4AR = e4BR = e4CR = e4DR = e4ER = e4FR = e4GR = e4HR = 1;
|
||||
e4IR = e4JR = e4KR = e4LR = e4MR = e4NR = e4OR = e4PR = 1;
|
||||
g4AL = g4BL = g4CL = g4DL = 0.0;
|
||||
g4DR = g4HR = g4LR = g4PR = 0.0;
|
||||
|
||||
for (int x = 0; x < bez_total; x++) {
|
||||
bez[x] = 0.0;
|
||||
bezF[x] = 0.0;
|
||||
|
|
@ -265,7 +296,8 @@ OSStatus VerbTiny::ProcessBufferLists(AudioUnitRenderActionFlags & ioActionFlag
|
|||
derezFreq = 1.0 / bezFreqFraction;
|
||||
bezFreqTrim = 1.0-(derezFreq*bezFreqTrim);
|
||||
//the revision more accurately connects the bezier curves
|
||||
double wet = GetParameter( kParam_D );
|
||||
double wider = GetParameter( kParam_D )*2.0;
|
||||
double wet = GetParameter( kParam_E );
|
||||
|
||||
while (nSampleFrames-- > 0) {
|
||||
double inputSampleL = *inputL;
|
||||
|
|
@ -280,13 +312,13 @@ OSStatus VerbTiny::ProcessBufferLists(AudioUnitRenderActionFlags & ioActionFlag
|
|||
bez[bez_SampR] += (inputSampleR*attenuate*derez);
|
||||
if (bez[bez_cycle] > 1.0) { //hit the end point and we do a reverb sample
|
||||
bez[bez_cycle] = 0.0;
|
||||
inputSampleL = bez[bez_SampL];
|
||||
inputSampleR = bez[bez_SampR];
|
||||
double mainSampleL = bez[bez_SampL];
|
||||
double mainSampleR = bez[bez_SampR]; //begin primary reverb
|
||||
|
||||
a4AL[c4AL] = inputSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = inputSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = inputSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = inputSampleL + (f4DL * reg4n);
|
||||
a4AL[c4AL] = mainSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = mainSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = mainSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = mainSampleL + (f4DL * reg4n);
|
||||
|
||||
c4AL++; if (c4AL < 0 || c4AL > d4A) c4AL = 0;
|
||||
c4BL++; if (c4BL < 0 || c4BL > d4B) c4BL = 0;
|
||||
|
|
@ -298,10 +330,10 @@ OSStatus VerbTiny::ProcessBufferLists(AudioUnitRenderActionFlags & ioActionFlag
|
|||
double o4CL = a4CL[c4CL-((c4CL > d4C)?d4C+1:0)];
|
||||
double o4DL = a4DL[c4DL-((c4DL > d4D)?d4D+1:0)];
|
||||
|
||||
a4DR[c4DR] = inputSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = inputSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = inputSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = inputSampleR + (f4PR * reg4n);
|
||||
a4DR[c4DR] = mainSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = mainSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = mainSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = mainSampleR + (f4PR * reg4n);
|
||||
|
||||
c4DR++; if (c4DR < 0 || c4DR > d4D) c4DR = 0;
|
||||
c4HR++; if (c4HR < 0 || c4HR > d4H) c4HR = 0;
|
||||
|
|
@ -421,8 +453,173 @@ OSStatus VerbTiny::ProcessBufferLists(AudioUnitRenderActionFlags & ioActionFlag
|
|||
f4LR = o4OL - (o4ML + o4NL + o4PL);
|
||||
f4PR = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
inputSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
inputSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
mainSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
mainSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
|
||||
//we still have an untouched inputsample, turn it into dual mono
|
||||
//won't need to redeclare any of the o4 temp variables, just re-use
|
||||
|
||||
double dualmonoSampleL = bez[bez_SampR];
|
||||
double dualmonoSampleR = bez[bez_SampL];
|
||||
//workaround involves keeping the cross-matrix system,
|
||||
//but for initial layering, each side gets each version
|
||||
//making blends never quite line up as exactly the same.
|
||||
|
||||
b4AL[e4AL] = dualmonoSampleL + (g4AL * reg4n);
|
||||
b4BL[e4BL] = dualmonoSampleL + (g4BL * reg4n);
|
||||
b4CL[e4CL] = dualmonoSampleL + (g4CL * reg4n);
|
||||
b4DL[e4DL] = dualmonoSampleL + (g4DL * reg4n);
|
||||
|
||||
e4AL++; if (e4AL < 0 || e4AL > d4A) e4AL = 0;
|
||||
e4BL++; if (e4BL < 0 || e4BL > d4B) e4BL = 0;
|
||||
e4CL++; if (e4CL < 0 || e4CL > d4C) e4CL = 0;
|
||||
e4DL++; if (e4DL < 0 || e4DL > d4D) e4DL = 0;
|
||||
|
||||
o4AL = b4AL[e4AL-((e4AL > d4A)?d4A+1:0)];
|
||||
o4BL = b4BL[e4BL-((e4BL > d4B)?d4B+1:0)];
|
||||
o4CL = b4CL[e4CL-((e4CL > d4C)?d4C+1:0)];
|
||||
o4DL = b4DL[e4DL-((e4DL > d4D)?d4D+1:0)];
|
||||
|
||||
b4DR[e4DR] = dualmonoSampleR + (g4DR * reg4n);
|
||||
b4HR[e4HR] = dualmonoSampleR + (g4HR * reg4n);
|
||||
b4LR[e4LR] = dualmonoSampleR + (g4LR * reg4n);
|
||||
b4PR[e4PR] = dualmonoSampleR + (g4PR * reg4n);
|
||||
|
||||
e4DR++; if (e4DR < 0 || e4DR > d4D) e4DR = 0;
|
||||
e4HR++; if (e4HR < 0 || e4HR > d4H) e4HR = 0;
|
||||
e4LR++; if (e4LR < 0 || e4LR > d4L) e4LR = 0;
|
||||
e4PR++; if (e4PR < 0 || e4PR > d4P) e4PR = 0;
|
||||
|
||||
o4DR = b4DR[e4DR-((e4DR > d4D)?d4D+1:0)];
|
||||
o4HR = b4HR[e4HR-((e4HR > d4H)?d4H+1:0)];
|
||||
o4LR = b4LR[e4LR-((e4LR > d4L)?d4L+1:0)];
|
||||
o4PR = b4PR[e4PR-((e4PR > d4P)?d4P+1:0)];
|
||||
|
||||
//-------- one
|
||||
|
||||
b4EL[e4EL] = o4AL - (o4BL + o4CL + o4DL);
|
||||
b4FL[e4FL] = o4BL - (o4AL + o4CL + o4DL);
|
||||
b4GL[e4GL] = o4CL - (o4AL + o4BL + o4DL);
|
||||
b4HL[e4HL] = o4DL - (o4AL + o4BL + o4CL);
|
||||
|
||||
e4EL++; if (e4EL < 0 || e4EL > d4E) e4EL = 0;
|
||||
e4FL++; if (e4FL < 0 || e4FL > d4F) e4FL = 0;
|
||||
e4GL++; if (e4GL < 0 || e4GL > d4G) e4GL = 0;
|
||||
e4HL++; if (e4HL < 0 || e4HL > d4H) e4HL = 0;
|
||||
|
||||
o4EL = b4EL[e4EL-((e4EL > d4E)?d4E+1:0)];
|
||||
o4FL = b4FL[e4FL-((e4FL > d4F)?d4F+1:0)];
|
||||
o4GL = b4GL[e4GL-((e4GL > d4G)?d4G+1:0)];
|
||||
o4HL = b4HL[e4HL-((e4HL > d4H)?d4H+1:0)];
|
||||
|
||||
b4CR[e4CR] = o4DR - (o4HR + o4LR + o4PR);
|
||||
b4GR[e4GR] = o4HR - (o4DR + o4LR + o4PR);
|
||||
b4KR[e4KR] = o4LR - (o4DR + o4HR + o4PR);
|
||||
b4OR[e4OR] = o4PR - (o4DR + o4HR + o4LR);
|
||||
|
||||
e4CR++; if (e4CR < 0 || e4CR > d4C) e4CR = 0;
|
||||
e4GR++; if (e4GR < 0 || e4GR > d4G) e4GR = 0;
|
||||
e4KR++; if (e4KR < 0 || e4KR > d4K) e4KR = 0;
|
||||
e4OR++; if (e4OR < 0 || e4OR > d4O) e4OR = 0;
|
||||
|
||||
o4CR = b4CR[e4CR-((e4CR > d4C)?d4C+1:0)];
|
||||
o4GR = b4GR[e4GR-((e4GR > d4G)?d4G+1:0)];
|
||||
o4KR = b4KR[e4KR-((e4KR > d4K)?d4K+1:0)];
|
||||
o4OR = b4OR[e4OR-((e4OR > d4O)?d4O+1:0)];
|
||||
|
||||
//-------- two
|
||||
|
||||
b4IL[e4IL] = o4EL - (o4FL + o4GL + o4HL);
|
||||
b4JL[e4JL] = o4FL - (o4EL + o4GL + o4HL);
|
||||
b4KL[e4KL] = o4GL - (o4EL + o4FL + o4HL);
|
||||
b4LL[e4LL] = o4HL - (o4EL + o4FL + o4GL);
|
||||
|
||||
e4IL++; if (e4IL < 0 || e4IL > d4I) e4IL = 0;
|
||||
e4JL++; if (e4JL < 0 || e4JL > d4J) e4JL = 0;
|
||||
e4KL++; if (e4KL < 0 || e4KL > d4K) e4KL = 0;
|
||||
e4LL++; if (e4LL < 0 || e4LL > d4L) e4LL = 0;
|
||||
|
||||
o4IL = b4IL[e4IL-((e4IL > d4I)?d4I+1:0)];
|
||||
o4JL = b4JL[e4JL-((e4JL > d4J)?d4J+1:0)];
|
||||
o4KL = b4KL[e4KL-((e4KL > d4K)?d4K+1:0)];
|
||||
o4LL = b4LL[e4LL-((e4LL > d4L)?d4L+1:0)];
|
||||
|
||||
b4BR[e4BR] = o4CR - (o4GR + o4KR + o4OR);
|
||||
b4FR[e4FR] = o4GR - (o4CR + o4KR + o4OR);
|
||||
b4JR[e4JR] = o4KR - (o4CR + o4GR + o4OR);
|
||||
b4NR[e4NR] = o4OR - (o4CR + o4GR + o4KR);
|
||||
|
||||
e4BR++; if (e4BR < 0 || e4BR > d4B) e4BR = 0;
|
||||
e4FR++; if (e4FR < 0 || e4FR > d4F) e4FR = 0;
|
||||
e4JR++; if (e4JR < 0 || e4JR > d4J) e4JR = 0;
|
||||
e4NR++; if (e4NR < 0 || e4NR > d4N) e4NR = 0;
|
||||
|
||||
o4BR = b4BR[e4BR-((e4BR > d4B)?d4B+1:0)];
|
||||
o4FR = b4FR[e4FR-((e4FR > d4F)?d4F+1:0)];
|
||||
o4JR = b4JR[e4JR-((e4JR > d4J)?d4J+1:0)];
|
||||
o4NR = b4NR[e4NR-((e4NR > d4N)?d4N+1:0)];
|
||||
|
||||
//-------- three
|
||||
|
||||
b4ML[e4ML] = o4IL - (o4JL + o4KL + o4LL);
|
||||
b4NL[e4NL] = o4JL - (o4IL + o4KL + o4LL);
|
||||
b4OL[e4OL] = o4KL - (o4IL + o4JL + o4LL);
|
||||
b4PL[e4PL] = o4LL - (o4IL + o4JL + o4KL);
|
||||
|
||||
e4ML++; if (e4ML < 0 || e4ML > d4M) e4ML = 0;
|
||||
e4NL++; if (e4NL < 0 || e4NL > d4N) e4NL = 0;
|
||||
e4OL++; if (e4OL < 0 || e4OL > d4O) e4OL = 0;
|
||||
e4PL++; if (e4PL < 0 || e4PL > d4P) e4PL = 0;
|
||||
|
||||
o4ML = b4ML[e4ML-((e4ML > d4M)?d4M+1:0)];
|
||||
o4NL = b4NL[e4NL-((e4NL > d4N)?d4N+1:0)];
|
||||
o4OL = b4OL[e4OL-((e4OL > d4O)?d4O+1:0)];
|
||||
o4PL = b4PL[e4PL-((e4PL > d4P)?d4P+1:0)];
|
||||
|
||||
b4AR[e4AR] = o4BR - (o4FR + o4JR + o4NR);
|
||||
b4ER[e4ER] = o4FR - (o4BR + o4JR + o4NR);
|
||||
b4IR[e4IR] = o4JR - (o4BR + o4FR + o4NR);
|
||||
b4MR[e4MR] = o4NR - (o4BR + o4FR + o4JR);
|
||||
|
||||
e4AR++; if (e4AR < 0 || e4AR > d4A) e4AR = 0;
|
||||
e4ER++; if (e4ER < 0 || e4ER > d4E) e4ER = 0;
|
||||
e4IR++; if (e4IR < 0 || e4IR > d4I) e4IR = 0;
|
||||
e4MR++; if (e4MR < 0 || e4MR > d4M) e4MR = 0;
|
||||
|
||||
o4AR = b4AR[e4AR-((e4AR > d4A)?d4A+1:0)];
|
||||
o4ER = b4ER[e4ER-((e4ER > d4E)?d4E+1:0)];
|
||||
o4IR = b4IR[e4IR-((e4IR > d4I)?d4I+1:0)];
|
||||
o4MR = b4MR[e4MR-((e4MR > d4M)?d4M+1:0)];
|
||||
|
||||
//-------- four
|
||||
|
||||
g4DR = o4AR - (o4ER + o4IR + o4MR);
|
||||
g4HR = o4ER - (o4AR + o4IR + o4MR);
|
||||
g4LR = o4IR - (o4AR + o4ER + o4MR);
|
||||
g4PR = o4MR - (o4AR + o4ER + o4IR);
|
||||
|
||||
g4AL = o4ML - (o4NL + o4OL + o4PL);
|
||||
g4BL = o4NL - (o4ML + o4OL + o4PL);
|
||||
g4CL = o4OL - (o4ML + o4NL + o4PL);
|
||||
g4DL = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
dualmonoSampleR = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
dualmonoSampleL = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
//dual mono version is wider = 1.0 at the center
|
||||
//with mainsample 0.0 and 2.0 (only at the edges)
|
||||
//with mainsample out of phase when over 1.0
|
||||
//couldn't re-do the arrays perfectly, so instead
|
||||
//we keep exactly the same cross-matrix,
|
||||
//but we flip the sides we're using for initial reverb.
|
||||
//then, dualmono remains totally dualmono, and blend a bit in for wideness.
|
||||
|
||||
if (wider < 1.0) {
|
||||
inputSampleL = (dualmonoSampleL*wider) + (mainSampleL*(1.0-wider));
|
||||
inputSampleR = (dualmonoSampleR*wider) + (mainSampleR*(1.0-wider));
|
||||
} else {
|
||||
inputSampleL = (dualmonoSampleL*(2.0-wider)) + (mainSampleL*(wider-1.0));
|
||||
inputSampleR = (dualmonoSampleR*(2.0-wider)) + (-mainSampleR*(wider-1.0));
|
||||
}
|
||||
|
||||
bez[bez_CL] = bez[bez_BL];
|
||||
bez[bez_BL] = bez[bez_AL];
|
||||
|
|
@ -443,9 +640,8 @@ OSStatus VerbTiny::ProcessBufferLists(AudioUnitRenderActionFlags & ioActionFlag
|
|||
inputSampleR = (bez[bez_BR]+(CBR*(1.0-X))+(BAR*X))*-0.25;
|
||||
|
||||
bezF[bez_cycle] += derezFreq;
|
||||
bezF[bez_SampL] += ((inputSampleL+bezF[bez_InL]) * derezFreq);
|
||||
bezF[bez_SampR] += ((inputSampleL+bezF[bez_InR]) * derezFreq);
|
||||
bezF[bez_InL] = inputSampleL; bezF[bez_InR] = inputSampleR;
|
||||
bezF[bez_SampL] += (inputSampleL * derezFreq);
|
||||
bezF[bez_SampR] += (inputSampleR * derezFreq);
|
||||
if (bezF[bez_cycle] > 1.0) { //hit the end point and we do a filter sample
|
||||
bezF[bez_cycle] = 0.0;
|
||||
bezF[bez_CL] = bezF[bez_BL];
|
||||
|
|
@ -460,10 +656,10 @@ OSStatus VerbTiny::ProcessBufferLists(AudioUnitRenderActionFlags & ioActionFlag
|
|||
X = bezF[bez_cycle]*bezFreqTrim;
|
||||
double CBLfreq = (bezF[bez_CL]*(1.0-X))+(bezF[bez_BL]*X);
|
||||
double BALfreq = (bezF[bez_BL]*(1.0-X))+(bezF[bez_AL]*X);
|
||||
inputSampleL = (bezF[bez_BL]+(CBLfreq*(1.0-X))+(BALfreq*X))*0.25;
|
||||
inputSampleL = (bezF[bez_BL]+(CBLfreq*(1.0-X))+(BALfreq*X))*0.5;
|
||||
double CBRfreq = (bezF[bez_CR]*(1.0-X))+(bezF[bez_BR]*X);
|
||||
double BARfreq = (bezF[bez_BR]*(1.0-X))+(bezF[bez_AR]*X);
|
||||
inputSampleR = (bezF[bez_BR]+(CBRfreq*(1.0-X))+(BARfreq*X))*0.25;
|
||||
inputSampleR = (bezF[bez_BR]+(CBRfreq*(1.0-X))+(BARfreq*X))*0.5;
|
||||
//filtering the reverb separately, after making it
|
||||
|
||||
inputSampleL = (inputSampleL * wet)+(drySampleL * (1.0-wet));
|
||||
|
|
|
|||
|
|
@ -57,23 +57,30 @@
|
|||
static const float kDefaultValue_ParamA = 0.5;
|
||||
static const float kDefaultValue_ParamB = 1.0;
|
||||
static const float kDefaultValue_ParamC = 1.0;
|
||||
static const float kDefaultValue_ParamD = 1.0;
|
||||
static const float kDefaultValue_ParamD = 0.0;
|
||||
static const float kDefaultValue_ParamE = 1.0;
|
||||
|
||||
static CFStringRef kParameterAName = CFSTR("Replace");
|
||||
static CFStringRef kParameterBName = CFSTR("Derez");
|
||||
static CFStringRef kParameterCName = CFSTR("Filter");
|
||||
static CFStringRef kParameterDName = CFSTR("Dry/Wet");
|
||||
static CFStringRef kParameterDName = CFSTR("Wider");
|
||||
static CFStringRef kParameterEName = CFSTR("Dry/Wet");
|
||||
|
||||
enum {
|
||||
kParam_A =0,
|
||||
kParam_B =1,
|
||||
kParam_C =2,
|
||||
kParam_D =3,
|
||||
kParam_E =4,
|
||||
//Add your parameters here...
|
||||
kNumberOfParameters=4
|
||||
kNumberOfParameters=5
|
||||
};
|
||||
|
||||
const int d4A = 136; const int d4B = 52; const int d4C = 53; const int d4D = 1261; const int d4E = 209; const int d4F = 473; const int d4G = 549; const int d4H = 29; const int d4I = 92; const int d4J = 1137; const int d4K = 1406; const int d4L = 994; const int d4M = 1314; const int d4N = 191; const int d4O = 1263; const int d4P = 103; //5 to 116 ms, 436 seat theater
|
||||
const int d4A = 136; const int d4B = 52; const int d4C = 53; const int d4D = 1261;
|
||||
const int d4E = 209; const int d4F = 473; const int d4G = 549; const int d4H = 29;
|
||||
const int d4I = 92; const int d4J = 1137; const int d4K = 1406; const int d4L = 994;
|
||||
const int d4M = 1314; const int d4N = 191; const int d4O = 1263; const int d4P = 103;
|
||||
//5 to 116 ms, 436 seat theater
|
||||
#define FOURBYFOUR true // 436seat1365253x4 on 2025-11-09 VerbTiny
|
||||
|
||||
#pragma mark ____VerbTiny
|
||||
|
|
@ -157,6 +164,45 @@ public:
|
|||
int c4AR,c4BR,c4CR,c4DR,c4ER,c4FR,c4GR,c4HR;
|
||||
int c4IR,c4JR,c4KR,c4LR,c4MR,c4NR,c4OR,c4PR;
|
||||
double f4AL,f4BL,f4CL,f4DL,f4DR,f4HR,f4LR,f4PR;
|
||||
//base stereo reverb
|
||||
double b4AL[d4A+5];
|
||||
double b4BL[d4B+5];
|
||||
double b4CL[d4C+5];
|
||||
double b4DL[d4D+5];
|
||||
double b4EL[d4E+5];
|
||||
double b4FL[d4F+5];
|
||||
double b4GL[d4G+5];
|
||||
double b4HL[d4H+5];
|
||||
double b4IL[d4I+5];
|
||||
double b4JL[d4J+5];
|
||||
double b4KL[d4K+5];
|
||||
double b4LL[d4L+5];
|
||||
double b4ML[d4M+5];
|
||||
double b4NL[d4N+5];
|
||||
double b4OL[d4O+5];
|
||||
double b4PL[d4P+5];
|
||||
double b4AR[d4A+5];
|
||||
double b4BR[d4B+5];
|
||||
double b4CR[d4C+5];
|
||||
double b4DR[d4D+5];
|
||||
double b4ER[d4E+5];
|
||||
double b4FR[d4F+5];
|
||||
double b4GR[d4G+5];
|
||||
double b4HR[d4H+5];
|
||||
double b4IR[d4I+5];
|
||||
double b4JR[d4J+5];
|
||||
double b4KR[d4K+5];
|
||||
double b4LR[d4L+5];
|
||||
double b4MR[d4M+5];
|
||||
double b4NR[d4N+5];
|
||||
double b4OR[d4O+5];
|
||||
double b4PR[d4P+5];
|
||||
int e4AL,e4BL,e4CL,e4DL,e4EL,e4FL,e4GL,e4HL;
|
||||
int e4IL,e4JL,e4KL,e4LL,e4ML,e4NL,e4OL,e4PL;
|
||||
int e4AR,e4BR,e4CR,e4DR,e4ER,e4FR,e4GR,e4HR;
|
||||
int e4IR,e4JR,e4KR,e4LR,e4MR,e4NR,e4OR,e4PR;
|
||||
double g4AL,g4BL,g4CL,g4DL,g4DR,g4HR,g4LR,g4PR;
|
||||
//changed letter is the dual mono, with rearranged grid
|
||||
|
||||
enum {
|
||||
bez_AL,
|
||||
|
|
@ -165,8 +211,6 @@ public:
|
|||
bez_BR,
|
||||
bez_CL,
|
||||
bez_CR,
|
||||
bez_InL,
|
||||
bez_InR,
|
||||
bez_SampL,
|
||||
bez_SampR,
|
||||
bez_cycle,
|
||||
|
|
|
|||
Binary file not shown.
Binary file not shown.
|
|
@ -15,7 +15,7 @@
|
|||
<BuildableReference
|
||||
BuildableIdentifier = "primary"
|
||||
BlueprintIdentifier = "8D01CCC60486CAD60068D4B7"
|
||||
BuildableName = "Gain.vst"
|
||||
BuildableName = "VerbTiny.vst"
|
||||
BlueprintName = "VerbTiny"
|
||||
ReferencedContainer = "container:VerbTiny.xcodeproj">
|
||||
</BuildableReference>
|
||||
|
|
@ -51,7 +51,7 @@
|
|||
<BuildableReference
|
||||
BuildableIdentifier = "primary"
|
||||
BlueprintIdentifier = "8D01CCC60486CAD60068D4B7"
|
||||
BuildableName = "Gain.vst"
|
||||
BuildableName = "VerbTiny.vst"
|
||||
BlueprintName = "VerbTiny"
|
||||
ReferencedContainer = "container:VerbTiny.xcodeproj">
|
||||
</BuildableReference>
|
||||
|
|
|
|||
|
|
@ -15,7 +15,8 @@ VerbTiny::VerbTiny(audioMasterCallback audioMaster) :
|
|||
A = 0.5;
|
||||
B = 1.0;
|
||||
C = 1.0;
|
||||
D = 1.0;
|
||||
D = 0.0;
|
||||
E = 1.0;
|
||||
|
||||
for(int x = 0; x < d4A+2; x++) {a4AL[x] = 0.0; a4AR[x] = 0.0;}
|
||||
for(int x = 0; x < d4B+2; x++) {a4BL[x] = 0.0; a4BR[x] = 0.0;}
|
||||
|
|
@ -40,6 +41,29 @@ VerbTiny::VerbTiny(audioMasterCallback audioMaster) :
|
|||
f4AL = f4BL = f4CL = f4DL = 0.0;
|
||||
f4DR = f4HR = f4LR = f4PR = 0.0;
|
||||
|
||||
for(int x = 0; x < d4A+2; x++) {b4AL[x] = 0.0; b4AR[x] = 0.0;}
|
||||
for(int x = 0; x < d4B+2; x++) {b4BL[x] = 0.0; b4BR[x] = 0.0;}
|
||||
for(int x = 0; x < d4C+2; x++) {b4CL[x] = 0.0; b4CR[x] = 0.0;}
|
||||
for(int x = 0; x < d4D+2; x++) {b4DL[x] = 0.0; b4DR[x] = 0.0;}
|
||||
for(int x = 0; x < d4E+2; x++) {b4EL[x] = 0.0; b4ER[x] = 0.0;}
|
||||
for(int x = 0; x < d4F+2; x++) {b4FL[x] = 0.0; b4FR[x] = 0.0;}
|
||||
for(int x = 0; x < d4G+2; x++) {b4GL[x] = 0.0; b4GR[x] = 0.0;}
|
||||
for(int x = 0; x < d4H+2; x++) {b4HL[x] = 0.0; b4HR[x] = 0.0;}
|
||||
for(int x = 0; x < d4I+2; x++) {b4IL[x] = 0.0; b4IR[x] = 0.0;}
|
||||
for(int x = 0; x < d4J+2; x++) {b4JL[x] = 0.0; b4JR[x] = 0.0;}
|
||||
for(int x = 0; x < d4K+2; x++) {b4KL[x] = 0.0; b4KR[x] = 0.0;}
|
||||
for(int x = 0; x < d4L+2; x++) {b4LL[x] = 0.0; b4LR[x] = 0.0;}
|
||||
for(int x = 0; x < d4M+2; x++) {b4ML[x] = 0.0; b4MR[x] = 0.0;}
|
||||
for(int x = 0; x < d4N+2; x++) {b4NL[x] = 0.0; b4NR[x] = 0.0;}
|
||||
for(int x = 0; x < d4O+2; x++) {b4OL[x] = 0.0; b4OR[x] = 0.0;}
|
||||
for(int x = 0; x < d4P+2; x++) {b4PL[x] = 0.0; b4PR[x] = 0.0;}
|
||||
e4AL = e4BL = e4CL = e4DL = e4EL = e4FL = e4GL = e4HL = 1;
|
||||
e4IL = e4JL = e4KL = e4LL = e4ML = e4NL = e4OL = e4PL = 1;
|
||||
e4AR = e4BR = e4CR = e4DR = e4ER = e4FR = e4GR = e4HR = 1;
|
||||
e4IR = e4JR = e4KR = e4LR = e4MR = e4NR = e4OR = e4PR = 1;
|
||||
g4AL = g4BL = g4CL = g4DL = 0.0;
|
||||
g4DR = g4HR = g4LR = g4PR = 0.0;
|
||||
|
||||
for (int x = 0; x < bez_total; x++) {
|
||||
bez[x] = 0.0;
|
||||
bezF[x] = 0.0;
|
||||
|
|
@ -84,6 +108,7 @@ VstInt32 VerbTiny::getChunk (void** data, bool isPreset)
|
|||
chunkData[1] = B;
|
||||
chunkData[2] = C;
|
||||
chunkData[3] = D;
|
||||
chunkData[4] = E;
|
||||
/* Note: The way this is set up, it will break if you manage to save settings on an Intel
|
||||
machine and load them on a PPC Mac. However, it's fine if you stick to the machine you
|
||||
started with. */
|
||||
|
|
@ -99,6 +124,7 @@ VstInt32 VerbTiny::setChunk (void* data, VstInt32 byteSize, bool isPreset)
|
|||
B = pinParameter(chunkData[1]);
|
||||
C = pinParameter(chunkData[2]);
|
||||
D = pinParameter(chunkData[3]);
|
||||
E = pinParameter(chunkData[4]);
|
||||
/* We're ignoring byteSize as we found it to be a filthy liar */
|
||||
|
||||
/* calculate any other fields you need here - you could copy in
|
||||
|
|
@ -112,6 +138,7 @@ void VerbTiny::setParameter(VstInt32 index, float value) {
|
|||
case kParamB: B = value; break;
|
||||
case kParamC: C = value; break;
|
||||
case kParamD: D = value; break;
|
||||
case kParamE: E = value; break;
|
||||
default: throw; // unknown parameter, shouldn't happen!
|
||||
}
|
||||
}
|
||||
|
|
@ -122,6 +149,7 @@ float VerbTiny::getParameter(VstInt32 index) {
|
|||
case kParamB: return B; break;
|
||||
case kParamC: return C; break;
|
||||
case kParamD: return D; break;
|
||||
case kParamE: return E; break;
|
||||
default: break; // unknown parameter, shouldn't happen!
|
||||
} return 0.0; //we only need to update the relevant name, this is simple to manage
|
||||
}
|
||||
|
|
@ -131,7 +159,8 @@ void VerbTiny::getParameterName(VstInt32 index, char *text) {
|
|||
case kParamA: vst_strncpy (text, "Replace", kVstMaxParamStrLen); break;
|
||||
case kParamB: vst_strncpy (text, "Derez", kVstMaxParamStrLen); break;
|
||||
case kParamC: vst_strncpy (text, "Filter", kVstMaxParamStrLen); break;
|
||||
case kParamD: vst_strncpy (text, "Dry/Wet", kVstMaxParamStrLen); break;
|
||||
case kParamD: vst_strncpy (text, "Wider", kVstMaxParamStrLen); break;
|
||||
case kParamE: vst_strncpy (text, "Dry/Wet", kVstMaxParamStrLen); break;
|
||||
default: break; // unknown parameter, shouldn't happen!
|
||||
} //this is our labels for displaying in the VST host
|
||||
}
|
||||
|
|
@ -142,6 +171,7 @@ void VerbTiny::getParameterDisplay(VstInt32 index, char *text) {
|
|||
case kParamB: float2string (B, text, kVstMaxParamStrLen); break;
|
||||
case kParamC: float2string (C, text, kVstMaxParamStrLen); break;
|
||||
case kParamD: float2string (D, text, kVstMaxParamStrLen); break;
|
||||
case kParamE: float2string (E, text, kVstMaxParamStrLen); break;
|
||||
default: break; // unknown parameter, shouldn't happen!
|
||||
} //this displays the values and handles 'popups' where it's discrete choices
|
||||
}
|
||||
|
|
@ -152,6 +182,7 @@ void VerbTiny::getParameterLabel(VstInt32 index, char *text) {
|
|||
case kParamB: vst_strncpy (text, "", kVstMaxParamStrLen); break;
|
||||
case kParamC: vst_strncpy (text, "", kVstMaxParamStrLen); break;
|
||||
case kParamD: vst_strncpy (text, "", kVstMaxParamStrLen); break;
|
||||
case kParamE: vst_strncpy (text, "", kVstMaxParamStrLen); break;
|
||||
default: break; // unknown parameter, shouldn't happen!
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,7 +20,8 @@ enum {
|
|||
kParamB =1,
|
||||
kParamC =2,
|
||||
kParamD =3,
|
||||
kNumParameters = 4
|
||||
kParamE =4,
|
||||
kNumParameters =5
|
||||
}; //
|
||||
|
||||
const int kNumPrograms = 0;
|
||||
|
|
@ -62,6 +63,7 @@ private:
|
|||
float B;
|
||||
float C;
|
||||
float D;
|
||||
float E;
|
||||
|
||||
double a4AL[d4A+5];
|
||||
double a4BL[d4B+5];
|
||||
|
|
@ -100,6 +102,45 @@ private:
|
|||
int c4AR,c4BR,c4CR,c4DR,c4ER,c4FR,c4GR,c4HR;
|
||||
int c4IR,c4JR,c4KR,c4LR,c4MR,c4NR,c4OR,c4PR;
|
||||
double f4AL,f4BL,f4CL,f4DL,f4DR,f4HR,f4LR,f4PR;
|
||||
//base stereo reverb
|
||||
double b4AL[d4A+5];
|
||||
double b4BL[d4B+5];
|
||||
double b4CL[d4C+5];
|
||||
double b4DL[d4D+5];
|
||||
double b4EL[d4E+5];
|
||||
double b4FL[d4F+5];
|
||||
double b4GL[d4G+5];
|
||||
double b4HL[d4H+5];
|
||||
double b4IL[d4I+5];
|
||||
double b4JL[d4J+5];
|
||||
double b4KL[d4K+5];
|
||||
double b4LL[d4L+5];
|
||||
double b4ML[d4M+5];
|
||||
double b4NL[d4N+5];
|
||||
double b4OL[d4O+5];
|
||||
double b4PL[d4P+5];
|
||||
double b4AR[d4A+5];
|
||||
double b4BR[d4B+5];
|
||||
double b4CR[d4C+5];
|
||||
double b4DR[d4D+5];
|
||||
double b4ER[d4E+5];
|
||||
double b4FR[d4F+5];
|
||||
double b4GR[d4G+5];
|
||||
double b4HR[d4H+5];
|
||||
double b4IR[d4I+5];
|
||||
double b4JR[d4J+5];
|
||||
double b4KR[d4K+5];
|
||||
double b4LR[d4L+5];
|
||||
double b4MR[d4M+5];
|
||||
double b4NR[d4N+5];
|
||||
double b4OR[d4O+5];
|
||||
double b4PR[d4P+5];
|
||||
int e4AL,e4BL,e4CL,e4DL,e4EL,e4FL,e4GL,e4HL;
|
||||
int e4IL,e4JL,e4KL,e4LL,e4ML,e4NL,e4OL,e4PL;
|
||||
int e4AR,e4BR,e4CR,e4DR,e4ER,e4FR,e4GR,e4HR;
|
||||
int e4IR,e4JR,e4KR,e4LR,e4MR,e4NR,e4OR,e4PR;
|
||||
double g4AL,g4BL,g4CL,g4DL,g4DR,g4HR,g4LR,g4PR;
|
||||
//changed letter is the dual mono, with rearranged grid
|
||||
|
||||
enum {
|
||||
bez_AL,
|
||||
|
|
@ -108,8 +149,6 @@ private:
|
|||
bez_BR,
|
||||
bez_CL,
|
||||
bez_CR,
|
||||
bez_InL,
|
||||
bez_InR,
|
||||
bez_SampL,
|
||||
bez_SampR,
|
||||
bez_cycle,
|
||||
|
|
|
|||
|
|
@ -34,7 +34,8 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
derezFreq = 1.0 / bezFreqFraction;
|
||||
bezFreqTrim = 1.0-(derezFreq*bezFreqTrim);
|
||||
//the revision more accurately connects the bezier curves
|
||||
double wet = D;
|
||||
double wider = D*2.0;
|
||||
double wet = E;
|
||||
|
||||
while (--sampleFrames >= 0)
|
||||
{
|
||||
|
|
@ -50,13 +51,13 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
bez[bez_SampR] += (inputSampleR*attenuate*derez);
|
||||
if (bez[bez_cycle] > 1.0) { //hit the end point and we do a reverb sample
|
||||
bez[bez_cycle] = 0.0;
|
||||
inputSampleL = bez[bez_SampL];
|
||||
inputSampleR = bez[bez_SampR];
|
||||
double mainSampleL = bez[bez_SampL];
|
||||
double mainSampleR = bez[bez_SampR]; //begin primary reverb
|
||||
|
||||
a4AL[c4AL] = inputSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = inputSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = inputSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = inputSampleL + (f4DL * reg4n);
|
||||
a4AL[c4AL] = mainSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = mainSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = mainSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = mainSampleL + (f4DL * reg4n);
|
||||
|
||||
c4AL++; if (c4AL < 0 || c4AL > d4A) c4AL = 0;
|
||||
c4BL++; if (c4BL < 0 || c4BL > d4B) c4BL = 0;
|
||||
|
|
@ -68,10 +69,10 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
double o4CL = a4CL[c4CL-((c4CL > d4C)?d4C+1:0)];
|
||||
double o4DL = a4DL[c4DL-((c4DL > d4D)?d4D+1:0)];
|
||||
|
||||
a4DR[c4DR] = inputSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = inputSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = inputSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = inputSampleR + (f4PR * reg4n);
|
||||
a4DR[c4DR] = mainSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = mainSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = mainSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = mainSampleR + (f4PR * reg4n);
|
||||
|
||||
c4DR++; if (c4DR < 0 || c4DR > d4D) c4DR = 0;
|
||||
c4HR++; if (c4HR < 0 || c4HR > d4H) c4HR = 0;
|
||||
|
|
@ -191,8 +192,173 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
f4LR = o4OL - (o4ML + o4NL + o4PL);
|
||||
f4PR = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
inputSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
inputSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
mainSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
mainSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
|
||||
//we still have an untouched inputsample, turn it into dual mono
|
||||
//won't need to redeclare any of the o4 temp variables, just re-use
|
||||
|
||||
double dualmonoSampleL = bez[bez_SampR];
|
||||
double dualmonoSampleR = bez[bez_SampL];
|
||||
//workaround involves keeping the cross-matrix system,
|
||||
//but for initial layering, each side gets each version
|
||||
//making blends never quite line up as exactly the same.
|
||||
|
||||
b4AL[e4AL] = dualmonoSampleL + (g4AL * reg4n);
|
||||
b4BL[e4BL] = dualmonoSampleL + (g4BL * reg4n);
|
||||
b4CL[e4CL] = dualmonoSampleL + (g4CL * reg4n);
|
||||
b4DL[e4DL] = dualmonoSampleL + (g4DL * reg4n);
|
||||
|
||||
e4AL++; if (e4AL < 0 || e4AL > d4A) e4AL = 0;
|
||||
e4BL++; if (e4BL < 0 || e4BL > d4B) e4BL = 0;
|
||||
e4CL++; if (e4CL < 0 || e4CL > d4C) e4CL = 0;
|
||||
e4DL++; if (e4DL < 0 || e4DL > d4D) e4DL = 0;
|
||||
|
||||
o4AL = b4AL[e4AL-((e4AL > d4A)?d4A+1:0)];
|
||||
o4BL = b4BL[e4BL-((e4BL > d4B)?d4B+1:0)];
|
||||
o4CL = b4CL[e4CL-((e4CL > d4C)?d4C+1:0)];
|
||||
o4DL = b4DL[e4DL-((e4DL > d4D)?d4D+1:0)];
|
||||
|
||||
b4DR[e4DR] = dualmonoSampleR + (g4DR * reg4n);
|
||||
b4HR[e4HR] = dualmonoSampleR + (g4HR * reg4n);
|
||||
b4LR[e4LR] = dualmonoSampleR + (g4LR * reg4n);
|
||||
b4PR[e4PR] = dualmonoSampleR + (g4PR * reg4n);
|
||||
|
||||
e4DR++; if (e4DR < 0 || e4DR > d4D) e4DR = 0;
|
||||
e4HR++; if (e4HR < 0 || e4HR > d4H) e4HR = 0;
|
||||
e4LR++; if (e4LR < 0 || e4LR > d4L) e4LR = 0;
|
||||
e4PR++; if (e4PR < 0 || e4PR > d4P) e4PR = 0;
|
||||
|
||||
o4DR = b4DR[e4DR-((e4DR > d4D)?d4D+1:0)];
|
||||
o4HR = b4HR[e4HR-((e4HR > d4H)?d4H+1:0)];
|
||||
o4LR = b4LR[e4LR-((e4LR > d4L)?d4L+1:0)];
|
||||
o4PR = b4PR[e4PR-((e4PR > d4P)?d4P+1:0)];
|
||||
|
||||
//-------- one
|
||||
|
||||
b4EL[e4EL] = o4AL - (o4BL + o4CL + o4DL);
|
||||
b4FL[e4FL] = o4BL - (o4AL + o4CL + o4DL);
|
||||
b4GL[e4GL] = o4CL - (o4AL + o4BL + o4DL);
|
||||
b4HL[e4HL] = o4DL - (o4AL + o4BL + o4CL);
|
||||
|
||||
e4EL++; if (e4EL < 0 || e4EL > d4E) e4EL = 0;
|
||||
e4FL++; if (e4FL < 0 || e4FL > d4F) e4FL = 0;
|
||||
e4GL++; if (e4GL < 0 || e4GL > d4G) e4GL = 0;
|
||||
e4HL++; if (e4HL < 0 || e4HL > d4H) e4HL = 0;
|
||||
|
||||
o4EL = b4EL[e4EL-((e4EL > d4E)?d4E+1:0)];
|
||||
o4FL = b4FL[e4FL-((e4FL > d4F)?d4F+1:0)];
|
||||
o4GL = b4GL[e4GL-((e4GL > d4G)?d4G+1:0)];
|
||||
o4HL = b4HL[e4HL-((e4HL > d4H)?d4H+1:0)];
|
||||
|
||||
b4CR[e4CR] = o4DR - (o4HR + o4LR + o4PR);
|
||||
b4GR[e4GR] = o4HR - (o4DR + o4LR + o4PR);
|
||||
b4KR[e4KR] = o4LR - (o4DR + o4HR + o4PR);
|
||||
b4OR[e4OR] = o4PR - (o4DR + o4HR + o4LR);
|
||||
|
||||
e4CR++; if (e4CR < 0 || e4CR > d4C) e4CR = 0;
|
||||
e4GR++; if (e4GR < 0 || e4GR > d4G) e4GR = 0;
|
||||
e4KR++; if (e4KR < 0 || e4KR > d4K) e4KR = 0;
|
||||
e4OR++; if (e4OR < 0 || e4OR > d4O) e4OR = 0;
|
||||
|
||||
o4CR = b4CR[e4CR-((e4CR > d4C)?d4C+1:0)];
|
||||
o4GR = b4GR[e4GR-((e4GR > d4G)?d4G+1:0)];
|
||||
o4KR = b4KR[e4KR-((e4KR > d4K)?d4K+1:0)];
|
||||
o4OR = b4OR[e4OR-((e4OR > d4O)?d4O+1:0)];
|
||||
|
||||
//-------- two
|
||||
|
||||
b4IL[e4IL] = o4EL - (o4FL + o4GL + o4HL);
|
||||
b4JL[e4JL] = o4FL - (o4EL + o4GL + o4HL);
|
||||
b4KL[e4KL] = o4GL - (o4EL + o4FL + o4HL);
|
||||
b4LL[e4LL] = o4HL - (o4EL + o4FL + o4GL);
|
||||
|
||||
e4IL++; if (e4IL < 0 || e4IL > d4I) e4IL = 0;
|
||||
e4JL++; if (e4JL < 0 || e4JL > d4J) e4JL = 0;
|
||||
e4KL++; if (e4KL < 0 || e4KL > d4K) e4KL = 0;
|
||||
e4LL++; if (e4LL < 0 || e4LL > d4L) e4LL = 0;
|
||||
|
||||
o4IL = b4IL[e4IL-((e4IL > d4I)?d4I+1:0)];
|
||||
o4JL = b4JL[e4JL-((e4JL > d4J)?d4J+1:0)];
|
||||
o4KL = b4KL[e4KL-((e4KL > d4K)?d4K+1:0)];
|
||||
o4LL = b4LL[e4LL-((e4LL > d4L)?d4L+1:0)];
|
||||
|
||||
b4BR[e4BR] = o4CR - (o4GR + o4KR + o4OR);
|
||||
b4FR[e4FR] = o4GR - (o4CR + o4KR + o4OR);
|
||||
b4JR[e4JR] = o4KR - (o4CR + o4GR + o4OR);
|
||||
b4NR[e4NR] = o4OR - (o4CR + o4GR + o4KR);
|
||||
|
||||
e4BR++; if (e4BR < 0 || e4BR > d4B) e4BR = 0;
|
||||
e4FR++; if (e4FR < 0 || e4FR > d4F) e4FR = 0;
|
||||
e4JR++; if (e4JR < 0 || e4JR > d4J) e4JR = 0;
|
||||
e4NR++; if (e4NR < 0 || e4NR > d4N) e4NR = 0;
|
||||
|
||||
o4BR = b4BR[e4BR-((e4BR > d4B)?d4B+1:0)];
|
||||
o4FR = b4FR[e4FR-((e4FR > d4F)?d4F+1:0)];
|
||||
o4JR = b4JR[e4JR-((e4JR > d4J)?d4J+1:0)];
|
||||
o4NR = b4NR[e4NR-((e4NR > d4N)?d4N+1:0)];
|
||||
|
||||
//-------- three
|
||||
|
||||
b4ML[e4ML] = o4IL - (o4JL + o4KL + o4LL);
|
||||
b4NL[e4NL] = o4JL - (o4IL + o4KL + o4LL);
|
||||
b4OL[e4OL] = o4KL - (o4IL + o4JL + o4LL);
|
||||
b4PL[e4PL] = o4LL - (o4IL + o4JL + o4KL);
|
||||
|
||||
e4ML++; if (e4ML < 0 || e4ML > d4M) e4ML = 0;
|
||||
e4NL++; if (e4NL < 0 || e4NL > d4N) e4NL = 0;
|
||||
e4OL++; if (e4OL < 0 || e4OL > d4O) e4OL = 0;
|
||||
e4PL++; if (e4PL < 0 || e4PL > d4P) e4PL = 0;
|
||||
|
||||
o4ML = b4ML[e4ML-((e4ML > d4M)?d4M+1:0)];
|
||||
o4NL = b4NL[e4NL-((e4NL > d4N)?d4N+1:0)];
|
||||
o4OL = b4OL[e4OL-((e4OL > d4O)?d4O+1:0)];
|
||||
o4PL = b4PL[e4PL-((e4PL > d4P)?d4P+1:0)];
|
||||
|
||||
b4AR[e4AR] = o4BR - (o4FR + o4JR + o4NR);
|
||||
b4ER[e4ER] = o4FR - (o4BR + o4JR + o4NR);
|
||||
b4IR[e4IR] = o4JR - (o4BR + o4FR + o4NR);
|
||||
b4MR[e4MR] = o4NR - (o4BR + o4FR + o4JR);
|
||||
|
||||
e4AR++; if (e4AR < 0 || e4AR > d4A) e4AR = 0;
|
||||
e4ER++; if (e4ER < 0 || e4ER > d4E) e4ER = 0;
|
||||
e4IR++; if (e4IR < 0 || e4IR > d4I) e4IR = 0;
|
||||
e4MR++; if (e4MR < 0 || e4MR > d4M) e4MR = 0;
|
||||
|
||||
o4AR = b4AR[e4AR-((e4AR > d4A)?d4A+1:0)];
|
||||
o4ER = b4ER[e4ER-((e4ER > d4E)?d4E+1:0)];
|
||||
o4IR = b4IR[e4IR-((e4IR > d4I)?d4I+1:0)];
|
||||
o4MR = b4MR[e4MR-((e4MR > d4M)?d4M+1:0)];
|
||||
|
||||
//-------- four
|
||||
|
||||
g4DR = o4AR - (o4ER + o4IR + o4MR);
|
||||
g4HR = o4ER - (o4AR + o4IR + o4MR);
|
||||
g4LR = o4IR - (o4AR + o4ER + o4MR);
|
||||
g4PR = o4MR - (o4AR + o4ER + o4IR);
|
||||
|
||||
g4AL = o4ML - (o4NL + o4OL + o4PL);
|
||||
g4BL = o4NL - (o4ML + o4OL + o4PL);
|
||||
g4CL = o4OL - (o4ML + o4NL + o4PL);
|
||||
g4DL = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
dualmonoSampleR = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
dualmonoSampleL = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
//dual mono version is wider = 1.0 at the center
|
||||
//with mainsample 0.0 and 2.0 (only at the edges)
|
||||
//with mainsample out of phase when over 1.0
|
||||
//couldn't re-do the arrays perfectly, so instead
|
||||
//we keep exactly the same cross-matrix,
|
||||
//but we flip the sides we're using for initial reverb.
|
||||
//then, dualmono remains totally dualmono, and blend a bit in for wideness.
|
||||
|
||||
if (wider < 1.0) {
|
||||
inputSampleL = (dualmonoSampleL*wider) + (mainSampleL*(1.0-wider));
|
||||
inputSampleR = (dualmonoSampleR*wider) + (mainSampleR*(1.0-wider));
|
||||
} else {
|
||||
inputSampleL = (dualmonoSampleL*(2.0-wider)) + (mainSampleL*(wider-1.0));
|
||||
inputSampleR = (dualmonoSampleR*(2.0-wider)) + (-mainSampleR*(wider-1.0));
|
||||
}
|
||||
|
||||
bez[bez_CL] = bez[bez_BL];
|
||||
bez[bez_BL] = bez[bez_AL];
|
||||
|
|
@ -213,9 +379,8 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
inputSampleR = (bez[bez_BR]+(CBR*(1.0-X))+(BAR*X))*-0.25;
|
||||
|
||||
bezF[bez_cycle] += derezFreq;
|
||||
bezF[bez_SampL] += ((inputSampleL+bezF[bez_InL]) * derezFreq);
|
||||
bezF[bez_SampR] += ((inputSampleL+bezF[bez_InR]) * derezFreq);
|
||||
bezF[bez_InL] = inputSampleL; bezF[bez_InR] = inputSampleR;
|
||||
bezF[bez_SampL] += (inputSampleL * derezFreq);
|
||||
bezF[bez_SampR] += (inputSampleR * derezFreq);
|
||||
if (bezF[bez_cycle] > 1.0) { //hit the end point and we do a filter sample
|
||||
bezF[bez_cycle] = 0.0;
|
||||
bezF[bez_CL] = bezF[bez_BL];
|
||||
|
|
@ -230,10 +395,10 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
X = bezF[bez_cycle]*bezFreqTrim;
|
||||
double CBLfreq = (bezF[bez_CL]*(1.0-X))+(bezF[bez_BL]*X);
|
||||
double BALfreq = (bezF[bez_BL]*(1.0-X))+(bezF[bez_AL]*X);
|
||||
inputSampleL = (bezF[bez_BL]+(CBLfreq*(1.0-X))+(BALfreq*X))*0.25;
|
||||
inputSampleL = (bezF[bez_BL]+(CBLfreq*(1.0-X))+(BALfreq*X))*0.5;
|
||||
double CBRfreq = (bezF[bez_CR]*(1.0-X))+(bezF[bez_BR]*X);
|
||||
double BARfreq = (bezF[bez_BR]*(1.0-X))+(bezF[bez_AR]*X);
|
||||
inputSampleR = (bezF[bez_BR]+(CBRfreq*(1.0-X))+(BARfreq*X))*0.25;
|
||||
inputSampleR = (bezF[bez_BR]+(CBRfreq*(1.0-X))+(BARfreq*X))*0.5;
|
||||
//filtering the reverb separately, after making it
|
||||
|
||||
inputSampleL = (inputSampleL * wet)+(drySampleL * (1.0-wet));
|
||||
|
|
@ -285,7 +450,8 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
derezFreq = 1.0 / bezFreqFraction;
|
||||
bezFreqTrim = 1.0-(derezFreq*bezFreqTrim);
|
||||
//the revision more accurately connects the bezier curves
|
||||
double wet = D;
|
||||
double wider = D*2.0;
|
||||
double wet = E;
|
||||
|
||||
while (--sampleFrames >= 0)
|
||||
{
|
||||
|
|
@ -301,13 +467,13 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
bez[bez_SampR] += (inputSampleR*attenuate*derez);
|
||||
if (bez[bez_cycle] > 1.0) { //hit the end point and we do a reverb sample
|
||||
bez[bez_cycle] = 0.0;
|
||||
inputSampleL = bez[bez_SampL];
|
||||
inputSampleR = bez[bez_SampR];
|
||||
double mainSampleL = bez[bez_SampL];
|
||||
double mainSampleR = bez[bez_SampR]; //begin primary reverb
|
||||
|
||||
a4AL[c4AL] = inputSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = inputSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = inputSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = inputSampleL + (f4DL * reg4n);
|
||||
a4AL[c4AL] = mainSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = mainSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = mainSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = mainSampleL + (f4DL * reg4n);
|
||||
|
||||
c4AL++; if (c4AL < 0 || c4AL > d4A) c4AL = 0;
|
||||
c4BL++; if (c4BL < 0 || c4BL > d4B) c4BL = 0;
|
||||
|
|
@ -319,10 +485,10 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
double o4CL = a4CL[c4CL-((c4CL > d4C)?d4C+1:0)];
|
||||
double o4DL = a4DL[c4DL-((c4DL > d4D)?d4D+1:0)];
|
||||
|
||||
a4DR[c4DR] = inputSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = inputSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = inputSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = inputSampleR + (f4PR * reg4n);
|
||||
a4DR[c4DR] = mainSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = mainSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = mainSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = mainSampleR + (f4PR * reg4n);
|
||||
|
||||
c4DR++; if (c4DR < 0 || c4DR > d4D) c4DR = 0;
|
||||
c4HR++; if (c4HR < 0 || c4HR > d4H) c4HR = 0;
|
||||
|
|
@ -442,8 +608,173 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
f4LR = o4OL - (o4ML + o4NL + o4PL);
|
||||
f4PR = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
inputSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
inputSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
mainSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
mainSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
|
||||
//we still have an untouched inputsample, turn it into dual mono
|
||||
//won't need to redeclare any of the o4 temp variables, just re-use
|
||||
|
||||
double dualmonoSampleL = bez[bez_SampR];
|
||||
double dualmonoSampleR = bez[bez_SampL];
|
||||
//workaround involves keeping the cross-matrix system,
|
||||
//but for initial layering, each side gets each version
|
||||
//making blends never quite line up as exactly the same.
|
||||
|
||||
b4AL[e4AL] = dualmonoSampleL + (g4AL * reg4n);
|
||||
b4BL[e4BL] = dualmonoSampleL + (g4BL * reg4n);
|
||||
b4CL[e4CL] = dualmonoSampleL + (g4CL * reg4n);
|
||||
b4DL[e4DL] = dualmonoSampleL + (g4DL * reg4n);
|
||||
|
||||
e4AL++; if (e4AL < 0 || e4AL > d4A) e4AL = 0;
|
||||
e4BL++; if (e4BL < 0 || e4BL > d4B) e4BL = 0;
|
||||
e4CL++; if (e4CL < 0 || e4CL > d4C) e4CL = 0;
|
||||
e4DL++; if (e4DL < 0 || e4DL > d4D) e4DL = 0;
|
||||
|
||||
o4AL = b4AL[e4AL-((e4AL > d4A)?d4A+1:0)];
|
||||
o4BL = b4BL[e4BL-((e4BL > d4B)?d4B+1:0)];
|
||||
o4CL = b4CL[e4CL-((e4CL > d4C)?d4C+1:0)];
|
||||
o4DL = b4DL[e4DL-((e4DL > d4D)?d4D+1:0)];
|
||||
|
||||
b4DR[e4DR] = dualmonoSampleR + (g4DR * reg4n);
|
||||
b4HR[e4HR] = dualmonoSampleR + (g4HR * reg4n);
|
||||
b4LR[e4LR] = dualmonoSampleR + (g4LR * reg4n);
|
||||
b4PR[e4PR] = dualmonoSampleR + (g4PR * reg4n);
|
||||
|
||||
e4DR++; if (e4DR < 0 || e4DR > d4D) e4DR = 0;
|
||||
e4HR++; if (e4HR < 0 || e4HR > d4H) e4HR = 0;
|
||||
e4LR++; if (e4LR < 0 || e4LR > d4L) e4LR = 0;
|
||||
e4PR++; if (e4PR < 0 || e4PR > d4P) e4PR = 0;
|
||||
|
||||
o4DR = b4DR[e4DR-((e4DR > d4D)?d4D+1:0)];
|
||||
o4HR = b4HR[e4HR-((e4HR > d4H)?d4H+1:0)];
|
||||
o4LR = b4LR[e4LR-((e4LR > d4L)?d4L+1:0)];
|
||||
o4PR = b4PR[e4PR-((e4PR > d4P)?d4P+1:0)];
|
||||
|
||||
//-------- one
|
||||
|
||||
b4EL[e4EL] = o4AL - (o4BL + o4CL + o4DL);
|
||||
b4FL[e4FL] = o4BL - (o4AL + o4CL + o4DL);
|
||||
b4GL[e4GL] = o4CL - (o4AL + o4BL + o4DL);
|
||||
b4HL[e4HL] = o4DL - (o4AL + o4BL + o4CL);
|
||||
|
||||
e4EL++; if (e4EL < 0 || e4EL > d4E) e4EL = 0;
|
||||
e4FL++; if (e4FL < 0 || e4FL > d4F) e4FL = 0;
|
||||
e4GL++; if (e4GL < 0 || e4GL > d4G) e4GL = 0;
|
||||
e4HL++; if (e4HL < 0 || e4HL > d4H) e4HL = 0;
|
||||
|
||||
o4EL = b4EL[e4EL-((e4EL > d4E)?d4E+1:0)];
|
||||
o4FL = b4FL[e4FL-((e4FL > d4F)?d4F+1:0)];
|
||||
o4GL = b4GL[e4GL-((e4GL > d4G)?d4G+1:0)];
|
||||
o4HL = b4HL[e4HL-((e4HL > d4H)?d4H+1:0)];
|
||||
|
||||
b4CR[e4CR] = o4DR - (o4HR + o4LR + o4PR);
|
||||
b4GR[e4GR] = o4HR - (o4DR + o4LR + o4PR);
|
||||
b4KR[e4KR] = o4LR - (o4DR + o4HR + o4PR);
|
||||
b4OR[e4OR] = o4PR - (o4DR + o4HR + o4LR);
|
||||
|
||||
e4CR++; if (e4CR < 0 || e4CR > d4C) e4CR = 0;
|
||||
e4GR++; if (e4GR < 0 || e4GR > d4G) e4GR = 0;
|
||||
e4KR++; if (e4KR < 0 || e4KR > d4K) e4KR = 0;
|
||||
e4OR++; if (e4OR < 0 || e4OR > d4O) e4OR = 0;
|
||||
|
||||
o4CR = b4CR[e4CR-((e4CR > d4C)?d4C+1:0)];
|
||||
o4GR = b4GR[e4GR-((e4GR > d4G)?d4G+1:0)];
|
||||
o4KR = b4KR[e4KR-((e4KR > d4K)?d4K+1:0)];
|
||||
o4OR = b4OR[e4OR-((e4OR > d4O)?d4O+1:0)];
|
||||
|
||||
//-------- two
|
||||
|
||||
b4IL[e4IL] = o4EL - (o4FL + o4GL + o4HL);
|
||||
b4JL[e4JL] = o4FL - (o4EL + o4GL + o4HL);
|
||||
b4KL[e4KL] = o4GL - (o4EL + o4FL + o4HL);
|
||||
b4LL[e4LL] = o4HL - (o4EL + o4FL + o4GL);
|
||||
|
||||
e4IL++; if (e4IL < 0 || e4IL > d4I) e4IL = 0;
|
||||
e4JL++; if (e4JL < 0 || e4JL > d4J) e4JL = 0;
|
||||
e4KL++; if (e4KL < 0 || e4KL > d4K) e4KL = 0;
|
||||
e4LL++; if (e4LL < 0 || e4LL > d4L) e4LL = 0;
|
||||
|
||||
o4IL = b4IL[e4IL-((e4IL > d4I)?d4I+1:0)];
|
||||
o4JL = b4JL[e4JL-((e4JL > d4J)?d4J+1:0)];
|
||||
o4KL = b4KL[e4KL-((e4KL > d4K)?d4K+1:0)];
|
||||
o4LL = b4LL[e4LL-((e4LL > d4L)?d4L+1:0)];
|
||||
|
||||
b4BR[e4BR] = o4CR - (o4GR + o4KR + o4OR);
|
||||
b4FR[e4FR] = o4GR - (o4CR + o4KR + o4OR);
|
||||
b4JR[e4JR] = o4KR - (o4CR + o4GR + o4OR);
|
||||
b4NR[e4NR] = o4OR - (o4CR + o4GR + o4KR);
|
||||
|
||||
e4BR++; if (e4BR < 0 || e4BR > d4B) e4BR = 0;
|
||||
e4FR++; if (e4FR < 0 || e4FR > d4F) e4FR = 0;
|
||||
e4JR++; if (e4JR < 0 || e4JR > d4J) e4JR = 0;
|
||||
e4NR++; if (e4NR < 0 || e4NR > d4N) e4NR = 0;
|
||||
|
||||
o4BR = b4BR[e4BR-((e4BR > d4B)?d4B+1:0)];
|
||||
o4FR = b4FR[e4FR-((e4FR > d4F)?d4F+1:0)];
|
||||
o4JR = b4JR[e4JR-((e4JR > d4J)?d4J+1:0)];
|
||||
o4NR = b4NR[e4NR-((e4NR > d4N)?d4N+1:0)];
|
||||
|
||||
//-------- three
|
||||
|
||||
b4ML[e4ML] = o4IL - (o4JL + o4KL + o4LL);
|
||||
b4NL[e4NL] = o4JL - (o4IL + o4KL + o4LL);
|
||||
b4OL[e4OL] = o4KL - (o4IL + o4JL + o4LL);
|
||||
b4PL[e4PL] = o4LL - (o4IL + o4JL + o4KL);
|
||||
|
||||
e4ML++; if (e4ML < 0 || e4ML > d4M) e4ML = 0;
|
||||
e4NL++; if (e4NL < 0 || e4NL > d4N) e4NL = 0;
|
||||
e4OL++; if (e4OL < 0 || e4OL > d4O) e4OL = 0;
|
||||
e4PL++; if (e4PL < 0 || e4PL > d4P) e4PL = 0;
|
||||
|
||||
o4ML = b4ML[e4ML-((e4ML > d4M)?d4M+1:0)];
|
||||
o4NL = b4NL[e4NL-((e4NL > d4N)?d4N+1:0)];
|
||||
o4OL = b4OL[e4OL-((e4OL > d4O)?d4O+1:0)];
|
||||
o4PL = b4PL[e4PL-((e4PL > d4P)?d4P+1:0)];
|
||||
|
||||
b4AR[e4AR] = o4BR - (o4FR + o4JR + o4NR);
|
||||
b4ER[e4ER] = o4FR - (o4BR + o4JR + o4NR);
|
||||
b4IR[e4IR] = o4JR - (o4BR + o4FR + o4NR);
|
||||
b4MR[e4MR] = o4NR - (o4BR + o4FR + o4JR);
|
||||
|
||||
e4AR++; if (e4AR < 0 || e4AR > d4A) e4AR = 0;
|
||||
e4ER++; if (e4ER < 0 || e4ER > d4E) e4ER = 0;
|
||||
e4IR++; if (e4IR < 0 || e4IR > d4I) e4IR = 0;
|
||||
e4MR++; if (e4MR < 0 || e4MR > d4M) e4MR = 0;
|
||||
|
||||
o4AR = b4AR[e4AR-((e4AR > d4A)?d4A+1:0)];
|
||||
o4ER = b4ER[e4ER-((e4ER > d4E)?d4E+1:0)];
|
||||
o4IR = b4IR[e4IR-((e4IR > d4I)?d4I+1:0)];
|
||||
o4MR = b4MR[e4MR-((e4MR > d4M)?d4M+1:0)];
|
||||
|
||||
//-------- four
|
||||
|
||||
g4DR = o4AR - (o4ER + o4IR + o4MR);
|
||||
g4HR = o4ER - (o4AR + o4IR + o4MR);
|
||||
g4LR = o4IR - (o4AR + o4ER + o4MR);
|
||||
g4PR = o4MR - (o4AR + o4ER + o4IR);
|
||||
|
||||
g4AL = o4ML - (o4NL + o4OL + o4PL);
|
||||
g4BL = o4NL - (o4ML + o4OL + o4PL);
|
||||
g4CL = o4OL - (o4ML + o4NL + o4PL);
|
||||
g4DL = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
dualmonoSampleR = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
dualmonoSampleL = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
//dual mono version is wider = 1.0 at the center
|
||||
//with mainsample 0.0 and 2.0 (only at the edges)
|
||||
//with mainsample out of phase when over 1.0
|
||||
//couldn't re-do the arrays perfectly, so instead
|
||||
//we keep exactly the same cross-matrix,
|
||||
//but we flip the sides we're using for initial reverb.
|
||||
//then, dualmono remains totally dualmono, and blend a bit in for wideness.
|
||||
|
||||
if (wider < 1.0) {
|
||||
inputSampleL = (dualmonoSampleL*wider) + (mainSampleL*(1.0-wider));
|
||||
inputSampleR = (dualmonoSampleR*wider) + (mainSampleR*(1.0-wider));
|
||||
} else {
|
||||
inputSampleL = (dualmonoSampleL*(2.0-wider)) + (mainSampleL*(wider-1.0));
|
||||
inputSampleR = (dualmonoSampleR*(2.0-wider)) + (-mainSampleR*(wider-1.0));
|
||||
}
|
||||
|
||||
bez[bez_CL] = bez[bez_BL];
|
||||
bez[bez_BL] = bez[bez_AL];
|
||||
|
|
@ -464,9 +795,8 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
inputSampleR = (bez[bez_BR]+(CBR*(1.0-X))+(BAR*X))*-0.25;
|
||||
|
||||
bezF[bez_cycle] += derezFreq;
|
||||
bezF[bez_SampL] += ((inputSampleL+bezF[bez_InL]) * derezFreq);
|
||||
bezF[bez_SampR] += ((inputSampleL+bezF[bez_InR]) * derezFreq);
|
||||
bezF[bez_InL] = inputSampleL; bezF[bez_InR] = inputSampleR;
|
||||
bezF[bez_SampL] += (inputSampleL * derezFreq);
|
||||
bezF[bez_SampR] += (inputSampleR * derezFreq);
|
||||
if (bezF[bez_cycle] > 1.0) { //hit the end point and we do a filter sample
|
||||
bezF[bez_cycle] = 0.0;
|
||||
bezF[bez_CL] = bezF[bez_BL];
|
||||
|
|
|
|||
|
|
@ -49,8 +49,13 @@
|
|||
PBXFileDataSource_Warnings_ColumnID,
|
||||
);
|
||||
};
|
||||
PBXPerProjectTemplateStateSaveDate = 784508639;
|
||||
PBXWorkspaceStateSaveDate = 784508639;
|
||||
PBXPerProjectTemplateStateSaveDate = 785500095;
|
||||
PBXWorkspaceStateSaveDate = 785500095;
|
||||
};
|
||||
perUserProjectItems = {
|
||||
8BFFBCB42ED1D18800188089 /* PBXTextBookmark */ = 8BFFBCB42ED1D18800188089 /* PBXTextBookmark */;
|
||||
8BFFBCB52ED1D18800188089 /* PBXBookmark */ = 8BFFBCB52ED1D18800188089 /* PBXBookmark */;
|
||||
8BFFBCB62ED1D18800188089 /* PBXTextBookmark */ = 8BFFBCB62ED1D18800188089 /* PBXTextBookmark */;
|
||||
};
|
||||
sourceControlManager = 8B02375E1D42B1C400E1E8C8 /* Source Control */;
|
||||
userBuildSettings = {
|
||||
|
|
@ -58,18 +63,18 @@
|
|||
};
|
||||
2407DEB6089929BA00EB68BF /* VerbTiny.cpp */ = {
|
||||
uiCtxt = {
|
||||
sepNavIntBoundsRect = "{{0, 0}, {948, 3150}}";
|
||||
sepNavSelRange = "{1950, 0}";
|
||||
sepNavVisRange = "{5271, 1659}";
|
||||
sepNavWindowFrame = "{{545, 47}, {895, 831}}";
|
||||
sepNavIntBoundsRect = "{{0, 0}, {930, 3762}}";
|
||||
sepNavSelRange = "{7935, 0}";
|
||||
sepNavVisRange = "{7769, 286}";
|
||||
sepNavWindowFrame = "{{26, 47}, {895, 831}}";
|
||||
};
|
||||
};
|
||||
245463B80991757100464AD3 /* VerbTiny.h */ = {
|
||||
uiCtxt = {
|
||||
sepNavIntBoundsRect = "{{0, 0}, {3342, 2304}}";
|
||||
sepNavSelRange = "{1058, 0}";
|
||||
sepNavVisRange = "{3396, 755}";
|
||||
sepNavWindowFrame = "{{549, 47}, {895, 831}}";
|
||||
sepNavIntBoundsRect = "{{0, 0}, {1047, 3348}}";
|
||||
sepNavSelRange = "{4902, 0}";
|
||||
sepNavVisRange = "{4329, 811}";
|
||||
sepNavWindowFrame = "{{6, 47}, {895, 831}}";
|
||||
};
|
||||
};
|
||||
24A2FFDB0F90D1DD003BB5A7 /* audioeffectx.cpp */ = {
|
||||
|
|
@ -82,10 +87,10 @@
|
|||
};
|
||||
24D8286F09A914000093AEF8 /* VerbTinyProc.cpp */ = {
|
||||
uiCtxt = {
|
||||
sepNavIntBoundsRect = "{{0, 0}, {848, 10962}}";
|
||||
sepNavSelRange = "{443, 0}";
|
||||
sepNavVisRange = "{0, 1332}";
|
||||
sepNavWindowFrame = "{{551, 47}, {895, 831}}";
|
||||
sepNavIntBoundsRect = "{{0, 0}, {741, 15318}}";
|
||||
sepNavSelRange = "{30799, 0}";
|
||||
sepNavVisRange = "{1585, 246}";
|
||||
sepNavWindowFrame = "{{6, 47}, {895, 831}}";
|
||||
};
|
||||
};
|
||||
8B02375E1D42B1C400E1E8C8 /* Source Control */ = {
|
||||
|
|
@ -102,6 +107,30 @@
|
|||
isa = PBXCodeSenseManager;
|
||||
indexTemplatePath = "";
|
||||
};
|
||||
8BFFBCB42ED1D18800188089 /* PBXTextBookmark */ = {
|
||||
isa = PBXTextBookmark;
|
||||
fRef = 2407DEB6089929BA00EB68BF /* VerbTiny.cpp */;
|
||||
name = "VerbTiny.cpp: 185";
|
||||
rLen = 0;
|
||||
rLoc = 7935;
|
||||
rType = 0;
|
||||
vrLen = 286;
|
||||
vrLoc = 7769;
|
||||
};
|
||||
8BFFBCB52ED1D18800188089 /* PBXBookmark */ = {
|
||||
isa = PBXBookmark;
|
||||
fRef = 24D8286F09A914000093AEF8 /* VerbTinyProc.cpp */;
|
||||
};
|
||||
8BFFBCB62ED1D18800188089 /* PBXTextBookmark */ = {
|
||||
isa = PBXTextBookmark;
|
||||
fRef = 24D8286F09A914000093AEF8 /* VerbTinyProc.cpp */;
|
||||
name = "VerbTinyProc.cpp: 823";
|
||||
rLen = 0;
|
||||
rLoc = 30799;
|
||||
rType = 0;
|
||||
vrLen = 246;
|
||||
vrLoc = 1585;
|
||||
};
|
||||
8D01CCC60486CAD60068D4B7 /* VerbTiny */ = {
|
||||
activeExec = 0;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -323,7 +323,7 @@
|
|||
<real>185</real>
|
||||
</array>
|
||||
<key>RubberWindowFrame</key>
|
||||
<string>669 348 810 487 0 0 1440 878 </string>
|
||||
<string>9 315 810 487 0 0 1440 878 </string>
|
||||
</dict>
|
||||
<key>Module</key>
|
||||
<string>PBXSmartGroupTreeModule</string>
|
||||
|
|
@ -339,7 +339,7 @@
|
|||
<key>PBXProjectModuleGUID</key>
|
||||
<string>8B0237581D42B1C400E1E8C8</string>
|
||||
<key>PBXProjectModuleLabel</key>
|
||||
<string>Gain.h</string>
|
||||
<string>VerbTinyProc.cpp</string>
|
||||
<key>PBXSplitModuleInNavigatorKey</key>
|
||||
<dict>
|
||||
<key>Split0</key>
|
||||
|
|
@ -347,7 +347,16 @@
|
|||
<key>PBXProjectModuleGUID</key>
|
||||
<string>8B0237591D42B1C400E1E8C8</string>
|
||||
<key>PBXProjectModuleLabel</key>
|
||||
<string>Gain.h</string>
|
||||
<string>VerbTinyProc.cpp</string>
|
||||
<key>_historyCapacity</key>
|
||||
<integer>0</integer>
|
||||
<key>bookmark</key>
|
||||
<string>8BFFBCB62ED1D18800188089</string>
|
||||
<key>history</key>
|
||||
<array>
|
||||
<string>8BFFBCB42ED1D18800188089</string>
|
||||
<string>8BFFBCB52ED1D18800188089</string>
|
||||
</array>
|
||||
</dict>
|
||||
<key>SplitCount</key>
|
||||
<string>1</string>
|
||||
|
|
@ -360,18 +369,18 @@
|
|||
<key>GeometryConfiguration</key>
|
||||
<dict>
|
||||
<key>Frame</key>
|
||||
<string>{{0, 0}, {603, 0}}</string>
|
||||
<string>{{0, 0}, {603, 132}}</string>
|
||||
<key>RubberWindowFrame</key>
|
||||
<string>669 348 810 487 0 0 1440 878 </string>
|
||||
<string>9 315 810 487 0 0 1440 878 </string>
|
||||
</dict>
|
||||
<key>Module</key>
|
||||
<string>PBXNavigatorGroup</string>
|
||||
<key>Proportion</key>
|
||||
<string>0pt</string>
|
||||
<string>132pt</string>
|
||||
</dict>
|
||||
<dict>
|
||||
<key>Proportion</key>
|
||||
<string>441pt</string>
|
||||
<string>309pt</string>
|
||||
<key>Tabs</key>
|
||||
<array>
|
||||
<dict>
|
||||
|
|
@ -385,9 +394,9 @@
|
|||
<key>GeometryConfiguration</key>
|
||||
<dict>
|
||||
<key>Frame</key>
|
||||
<string>{{10, 27}, {603, 414}}</string>
|
||||
<string>{{10, 27}, {603, 282}}</string>
|
||||
<key>RubberWindowFrame</key>
|
||||
<string>669 348 810 487 0 0 1440 878 </string>
|
||||
<string>9 315 810 487 0 0 1440 878 </string>
|
||||
</dict>
|
||||
<key>Module</key>
|
||||
<string>XCDetailModule</string>
|
||||
|
|
@ -469,11 +478,11 @@
|
|||
</array>
|
||||
<key>TableOfContents</key>
|
||||
<array>
|
||||
<string>8B8C63EE2EC2B06B008CA66C</string>
|
||||
<string>8BFFBCB72ED1D18800188089</string>
|
||||
<string>1CA23ED40692098700951B8B</string>
|
||||
<string>8B8C63EF2EC2B06B008CA66C</string>
|
||||
<string>8BFFBCB82ED1D18800188089</string>
|
||||
<string>8B0237581D42B1C400E1E8C8</string>
|
||||
<string>8B8C63F02EC2B06B008CA66C</string>
|
||||
<string>8BFFBCB92ED1D18800188089</string>
|
||||
<string>1CA23EDF0692099D00951B8B</string>
|
||||
<string>1CA23EE00692099D00951B8B</string>
|
||||
<string>1CA23EE10692099D00951B8B</string>
|
||||
|
|
@ -626,7 +635,7 @@
|
|||
<key>StatusbarIsVisible</key>
|
||||
<true/>
|
||||
<key>TimeStamp</key>
|
||||
<real>784511083.917153</real>
|
||||
<real>785502600.37377</real>
|
||||
<key>ToolbarConfigUserDefaultsMinorVersion</key>
|
||||
<string>2</string>
|
||||
<key>ToolbarDisplayMode</key>
|
||||
|
|
@ -643,11 +652,10 @@
|
|||
<integer>5</integer>
|
||||
<key>WindowOrderList</key>
|
||||
<array>
|
||||
<string>8B8C63F12EC2B06B008CA66C</string>
|
||||
<string>/Users/christopherjohnson/Desktop/VerbTiny/VerbTiny.xcodeproj</string>
|
||||
<string>/Users/christopherjohnson/Desktop/airwindows/plugins/MacVST/VerbTiny/VerbTiny.xcodeproj</string>
|
||||
</array>
|
||||
<key>WindowString</key>
|
||||
<string>669 348 810 487 0 0 1440 878 </string>
|
||||
<string>9 315 810 487 0 0 1440 878 </string>
|
||||
<key>WindowToolsV3</key>
|
||||
<array>
|
||||
<dict>
|
||||
|
|
|
|||
|
|
@ -15,7 +15,8 @@ VerbTiny::VerbTiny(audioMasterCallback audioMaster) :
|
|||
A = 0.5;
|
||||
B = 1.0;
|
||||
C = 1.0;
|
||||
D = 1.0;
|
||||
D = 0.0;
|
||||
E = 1.0;
|
||||
|
||||
for(int x = 0; x < d4A+2; x++) {a4AL[x] = 0.0; a4AR[x] = 0.0;}
|
||||
for(int x = 0; x < d4B+2; x++) {a4BL[x] = 0.0; a4BR[x] = 0.0;}
|
||||
|
|
@ -40,6 +41,29 @@ VerbTiny::VerbTiny(audioMasterCallback audioMaster) :
|
|||
f4AL = f4BL = f4CL = f4DL = 0.0;
|
||||
f4DR = f4HR = f4LR = f4PR = 0.0;
|
||||
|
||||
for(int x = 0; x < d4A+2; x++) {b4AL[x] = 0.0; b4AR[x] = 0.0;}
|
||||
for(int x = 0; x < d4B+2; x++) {b4BL[x] = 0.0; b4BR[x] = 0.0;}
|
||||
for(int x = 0; x < d4C+2; x++) {b4CL[x] = 0.0; b4CR[x] = 0.0;}
|
||||
for(int x = 0; x < d4D+2; x++) {b4DL[x] = 0.0; b4DR[x] = 0.0;}
|
||||
for(int x = 0; x < d4E+2; x++) {b4EL[x] = 0.0; b4ER[x] = 0.0;}
|
||||
for(int x = 0; x < d4F+2; x++) {b4FL[x] = 0.0; b4FR[x] = 0.0;}
|
||||
for(int x = 0; x < d4G+2; x++) {b4GL[x] = 0.0; b4GR[x] = 0.0;}
|
||||
for(int x = 0; x < d4H+2; x++) {b4HL[x] = 0.0; b4HR[x] = 0.0;}
|
||||
for(int x = 0; x < d4I+2; x++) {b4IL[x] = 0.0; b4IR[x] = 0.0;}
|
||||
for(int x = 0; x < d4J+2; x++) {b4JL[x] = 0.0; b4JR[x] = 0.0;}
|
||||
for(int x = 0; x < d4K+2; x++) {b4KL[x] = 0.0; b4KR[x] = 0.0;}
|
||||
for(int x = 0; x < d4L+2; x++) {b4LL[x] = 0.0; b4LR[x] = 0.0;}
|
||||
for(int x = 0; x < d4M+2; x++) {b4ML[x] = 0.0; b4MR[x] = 0.0;}
|
||||
for(int x = 0; x < d4N+2; x++) {b4NL[x] = 0.0; b4NR[x] = 0.0;}
|
||||
for(int x = 0; x < d4O+2; x++) {b4OL[x] = 0.0; b4OR[x] = 0.0;}
|
||||
for(int x = 0; x < d4P+2; x++) {b4PL[x] = 0.0; b4PR[x] = 0.0;}
|
||||
e4AL = e4BL = e4CL = e4DL = e4EL = e4FL = e4GL = e4HL = 1;
|
||||
e4IL = e4JL = e4KL = e4LL = e4ML = e4NL = e4OL = e4PL = 1;
|
||||
e4AR = e4BR = e4CR = e4DR = e4ER = e4FR = e4GR = e4HR = 1;
|
||||
e4IR = e4JR = e4KR = e4LR = e4MR = e4NR = e4OR = e4PR = 1;
|
||||
g4AL = g4BL = g4CL = g4DL = 0.0;
|
||||
g4DR = g4HR = g4LR = g4PR = 0.0;
|
||||
|
||||
for (int x = 0; x < bez_total; x++) {
|
||||
bez[x] = 0.0;
|
||||
bezF[x] = 0.0;
|
||||
|
|
@ -84,6 +108,7 @@ VstInt32 VerbTiny::getChunk (void** data, bool isPreset)
|
|||
chunkData[1] = B;
|
||||
chunkData[2] = C;
|
||||
chunkData[3] = D;
|
||||
chunkData[4] = E;
|
||||
/* Note: The way this is set up, it will break if you manage to save settings on an Intel
|
||||
machine and load them on a PPC Mac. However, it's fine if you stick to the machine you
|
||||
started with. */
|
||||
|
|
@ -99,6 +124,7 @@ VstInt32 VerbTiny::setChunk (void* data, VstInt32 byteSize, bool isPreset)
|
|||
B = pinParameter(chunkData[1]);
|
||||
C = pinParameter(chunkData[2]);
|
||||
D = pinParameter(chunkData[3]);
|
||||
E = pinParameter(chunkData[4]);
|
||||
/* We're ignoring byteSize as we found it to be a filthy liar */
|
||||
|
||||
/* calculate any other fields you need here - you could copy in
|
||||
|
|
@ -112,6 +138,7 @@ void VerbTiny::setParameter(VstInt32 index, float value) {
|
|||
case kParamB: B = value; break;
|
||||
case kParamC: C = value; break;
|
||||
case kParamD: D = value; break;
|
||||
case kParamE: E = value; break;
|
||||
default: throw; // unknown parameter, shouldn't happen!
|
||||
}
|
||||
}
|
||||
|
|
@ -122,6 +149,7 @@ float VerbTiny::getParameter(VstInt32 index) {
|
|||
case kParamB: return B; break;
|
||||
case kParamC: return C; break;
|
||||
case kParamD: return D; break;
|
||||
case kParamE: return E; break;
|
||||
default: break; // unknown parameter, shouldn't happen!
|
||||
} return 0.0; //we only need to update the relevant name, this is simple to manage
|
||||
}
|
||||
|
|
@ -131,7 +159,8 @@ void VerbTiny::getParameterName(VstInt32 index, char *text) {
|
|||
case kParamA: vst_strncpy (text, "Replace", kVstMaxParamStrLen); break;
|
||||
case kParamB: vst_strncpy (text, "Derez", kVstMaxParamStrLen); break;
|
||||
case kParamC: vst_strncpy (text, "Filter", kVstMaxParamStrLen); break;
|
||||
case kParamD: vst_strncpy (text, "Dry/Wet", kVstMaxParamStrLen); break;
|
||||
case kParamD: vst_strncpy (text, "Wider", kVstMaxParamStrLen); break;
|
||||
case kParamE: vst_strncpy (text, "Dry/Wet", kVstMaxParamStrLen); break;
|
||||
default: break; // unknown parameter, shouldn't happen!
|
||||
} //this is our labels for displaying in the VST host
|
||||
}
|
||||
|
|
@ -142,6 +171,7 @@ void VerbTiny::getParameterDisplay(VstInt32 index, char *text) {
|
|||
case kParamB: float2string (B, text, kVstMaxParamStrLen); break;
|
||||
case kParamC: float2string (C, text, kVstMaxParamStrLen); break;
|
||||
case kParamD: float2string (D, text, kVstMaxParamStrLen); break;
|
||||
case kParamE: float2string (E, text, kVstMaxParamStrLen); break;
|
||||
default: break; // unknown parameter, shouldn't happen!
|
||||
} //this displays the values and handles 'popups' where it's discrete choices
|
||||
}
|
||||
|
|
@ -152,6 +182,7 @@ void VerbTiny::getParameterLabel(VstInt32 index, char *text) {
|
|||
case kParamB: vst_strncpy (text, "", kVstMaxParamStrLen); break;
|
||||
case kParamC: vst_strncpy (text, "", kVstMaxParamStrLen); break;
|
||||
case kParamD: vst_strncpy (text, "", kVstMaxParamStrLen); break;
|
||||
case kParamE: vst_strncpy (text, "", kVstMaxParamStrLen); break;
|
||||
default: break; // unknown parameter, shouldn't happen!
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,7 +20,8 @@ enum {
|
|||
kParamB =1,
|
||||
kParamC =2,
|
||||
kParamD =3,
|
||||
kNumParameters = 4
|
||||
kParamE =4,
|
||||
kNumParameters =5
|
||||
}; //
|
||||
|
||||
const int kNumPrograms = 0;
|
||||
|
|
@ -62,6 +63,7 @@ private:
|
|||
float B;
|
||||
float C;
|
||||
float D;
|
||||
float E;
|
||||
|
||||
double a4AL[d4A+5];
|
||||
double a4BL[d4B+5];
|
||||
|
|
@ -100,6 +102,45 @@ private:
|
|||
int c4AR,c4BR,c4CR,c4DR,c4ER,c4FR,c4GR,c4HR;
|
||||
int c4IR,c4JR,c4KR,c4LR,c4MR,c4NR,c4OR,c4PR;
|
||||
double f4AL,f4BL,f4CL,f4DL,f4DR,f4HR,f4LR,f4PR;
|
||||
//base stereo reverb
|
||||
double b4AL[d4A+5];
|
||||
double b4BL[d4B+5];
|
||||
double b4CL[d4C+5];
|
||||
double b4DL[d4D+5];
|
||||
double b4EL[d4E+5];
|
||||
double b4FL[d4F+5];
|
||||
double b4GL[d4G+5];
|
||||
double b4HL[d4H+5];
|
||||
double b4IL[d4I+5];
|
||||
double b4JL[d4J+5];
|
||||
double b4KL[d4K+5];
|
||||
double b4LL[d4L+5];
|
||||
double b4ML[d4M+5];
|
||||
double b4NL[d4N+5];
|
||||
double b4OL[d4O+5];
|
||||
double b4PL[d4P+5];
|
||||
double b4AR[d4A+5];
|
||||
double b4BR[d4B+5];
|
||||
double b4CR[d4C+5];
|
||||
double b4DR[d4D+5];
|
||||
double b4ER[d4E+5];
|
||||
double b4FR[d4F+5];
|
||||
double b4GR[d4G+5];
|
||||
double b4HR[d4H+5];
|
||||
double b4IR[d4I+5];
|
||||
double b4JR[d4J+5];
|
||||
double b4KR[d4K+5];
|
||||
double b4LR[d4L+5];
|
||||
double b4MR[d4M+5];
|
||||
double b4NR[d4N+5];
|
||||
double b4OR[d4O+5];
|
||||
double b4PR[d4P+5];
|
||||
int e4AL,e4BL,e4CL,e4DL,e4EL,e4FL,e4GL,e4HL;
|
||||
int e4IL,e4JL,e4KL,e4LL,e4ML,e4NL,e4OL,e4PL;
|
||||
int e4AR,e4BR,e4CR,e4DR,e4ER,e4FR,e4GR,e4HR;
|
||||
int e4IR,e4JR,e4KR,e4LR,e4MR,e4NR,e4OR,e4PR;
|
||||
double g4AL,g4BL,g4CL,g4DL,g4DR,g4HR,g4LR,g4PR;
|
||||
//changed letter is the dual mono, with rearranged grid
|
||||
|
||||
enum {
|
||||
bez_AL,
|
||||
|
|
@ -108,8 +149,6 @@ private:
|
|||
bez_BR,
|
||||
bez_CL,
|
||||
bez_CR,
|
||||
bez_InL,
|
||||
bez_InR,
|
||||
bez_SampL,
|
||||
bez_SampR,
|
||||
bez_cycle,
|
||||
|
|
|
|||
|
|
@ -34,7 +34,8 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
derezFreq = 1.0 / bezFreqFraction;
|
||||
bezFreqTrim = 1.0-(derezFreq*bezFreqTrim);
|
||||
//the revision more accurately connects the bezier curves
|
||||
double wet = D;
|
||||
double wider = D*2.0;
|
||||
double wet = E;
|
||||
|
||||
while (--sampleFrames >= 0)
|
||||
{
|
||||
|
|
@ -50,13 +51,13 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
bez[bez_SampR] += (inputSampleR*attenuate*derez);
|
||||
if (bez[bez_cycle] > 1.0) { //hit the end point and we do a reverb sample
|
||||
bez[bez_cycle] = 0.0;
|
||||
inputSampleL = bez[bez_SampL];
|
||||
inputSampleR = bez[bez_SampR];
|
||||
double mainSampleL = bez[bez_SampL];
|
||||
double mainSampleR = bez[bez_SampR]; //begin primary reverb
|
||||
|
||||
a4AL[c4AL] = inputSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = inputSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = inputSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = inputSampleL + (f4DL * reg4n);
|
||||
a4AL[c4AL] = mainSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = mainSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = mainSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = mainSampleL + (f4DL * reg4n);
|
||||
|
||||
c4AL++; if (c4AL < 0 || c4AL > d4A) c4AL = 0;
|
||||
c4BL++; if (c4BL < 0 || c4BL > d4B) c4BL = 0;
|
||||
|
|
@ -68,10 +69,10 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
double o4CL = a4CL[c4CL-((c4CL > d4C)?d4C+1:0)];
|
||||
double o4DL = a4DL[c4DL-((c4DL > d4D)?d4D+1:0)];
|
||||
|
||||
a4DR[c4DR] = inputSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = inputSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = inputSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = inputSampleR + (f4PR * reg4n);
|
||||
a4DR[c4DR] = mainSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = mainSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = mainSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = mainSampleR + (f4PR * reg4n);
|
||||
|
||||
c4DR++; if (c4DR < 0 || c4DR > d4D) c4DR = 0;
|
||||
c4HR++; if (c4HR < 0 || c4HR > d4H) c4HR = 0;
|
||||
|
|
@ -191,8 +192,173 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
f4LR = o4OL - (o4ML + o4NL + o4PL);
|
||||
f4PR = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
inputSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
inputSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
mainSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
mainSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
|
||||
//we still have an untouched inputsample, turn it into dual mono
|
||||
//won't need to redeclare any of the o4 temp variables, just re-use
|
||||
|
||||
double dualmonoSampleL = bez[bez_SampR];
|
||||
double dualmonoSampleR = bez[bez_SampL];
|
||||
//workaround involves keeping the cross-matrix system,
|
||||
//but for initial layering, each side gets each version
|
||||
//making blends never quite line up as exactly the same.
|
||||
|
||||
b4AL[e4AL] = dualmonoSampleL + (g4AL * reg4n);
|
||||
b4BL[e4BL] = dualmonoSampleL + (g4BL * reg4n);
|
||||
b4CL[e4CL] = dualmonoSampleL + (g4CL * reg4n);
|
||||
b4DL[e4DL] = dualmonoSampleL + (g4DL * reg4n);
|
||||
|
||||
e4AL++; if (e4AL < 0 || e4AL > d4A) e4AL = 0;
|
||||
e4BL++; if (e4BL < 0 || e4BL > d4B) e4BL = 0;
|
||||
e4CL++; if (e4CL < 0 || e4CL > d4C) e4CL = 0;
|
||||
e4DL++; if (e4DL < 0 || e4DL > d4D) e4DL = 0;
|
||||
|
||||
o4AL = b4AL[e4AL-((e4AL > d4A)?d4A+1:0)];
|
||||
o4BL = b4BL[e4BL-((e4BL > d4B)?d4B+1:0)];
|
||||
o4CL = b4CL[e4CL-((e4CL > d4C)?d4C+1:0)];
|
||||
o4DL = b4DL[e4DL-((e4DL > d4D)?d4D+1:0)];
|
||||
|
||||
b4DR[e4DR] = dualmonoSampleR + (g4DR * reg4n);
|
||||
b4HR[e4HR] = dualmonoSampleR + (g4HR * reg4n);
|
||||
b4LR[e4LR] = dualmonoSampleR + (g4LR * reg4n);
|
||||
b4PR[e4PR] = dualmonoSampleR + (g4PR * reg4n);
|
||||
|
||||
e4DR++; if (e4DR < 0 || e4DR > d4D) e4DR = 0;
|
||||
e4HR++; if (e4HR < 0 || e4HR > d4H) e4HR = 0;
|
||||
e4LR++; if (e4LR < 0 || e4LR > d4L) e4LR = 0;
|
||||
e4PR++; if (e4PR < 0 || e4PR > d4P) e4PR = 0;
|
||||
|
||||
o4DR = b4DR[e4DR-((e4DR > d4D)?d4D+1:0)];
|
||||
o4HR = b4HR[e4HR-((e4HR > d4H)?d4H+1:0)];
|
||||
o4LR = b4LR[e4LR-((e4LR > d4L)?d4L+1:0)];
|
||||
o4PR = b4PR[e4PR-((e4PR > d4P)?d4P+1:0)];
|
||||
|
||||
//-------- one
|
||||
|
||||
b4EL[e4EL] = o4AL - (o4BL + o4CL + o4DL);
|
||||
b4FL[e4FL] = o4BL - (o4AL + o4CL + o4DL);
|
||||
b4GL[e4GL] = o4CL - (o4AL + o4BL + o4DL);
|
||||
b4HL[e4HL] = o4DL - (o4AL + o4BL + o4CL);
|
||||
|
||||
e4EL++; if (e4EL < 0 || e4EL > d4E) e4EL = 0;
|
||||
e4FL++; if (e4FL < 0 || e4FL > d4F) e4FL = 0;
|
||||
e4GL++; if (e4GL < 0 || e4GL > d4G) e4GL = 0;
|
||||
e4HL++; if (e4HL < 0 || e4HL > d4H) e4HL = 0;
|
||||
|
||||
o4EL = b4EL[e4EL-((e4EL > d4E)?d4E+1:0)];
|
||||
o4FL = b4FL[e4FL-((e4FL > d4F)?d4F+1:0)];
|
||||
o4GL = b4GL[e4GL-((e4GL > d4G)?d4G+1:0)];
|
||||
o4HL = b4HL[e4HL-((e4HL > d4H)?d4H+1:0)];
|
||||
|
||||
b4CR[e4CR] = o4DR - (o4HR + o4LR + o4PR);
|
||||
b4GR[e4GR] = o4HR - (o4DR + o4LR + o4PR);
|
||||
b4KR[e4KR] = o4LR - (o4DR + o4HR + o4PR);
|
||||
b4OR[e4OR] = o4PR - (o4DR + o4HR + o4LR);
|
||||
|
||||
e4CR++; if (e4CR < 0 || e4CR > d4C) e4CR = 0;
|
||||
e4GR++; if (e4GR < 0 || e4GR > d4G) e4GR = 0;
|
||||
e4KR++; if (e4KR < 0 || e4KR > d4K) e4KR = 0;
|
||||
e4OR++; if (e4OR < 0 || e4OR > d4O) e4OR = 0;
|
||||
|
||||
o4CR = b4CR[e4CR-((e4CR > d4C)?d4C+1:0)];
|
||||
o4GR = b4GR[e4GR-((e4GR > d4G)?d4G+1:0)];
|
||||
o4KR = b4KR[e4KR-((e4KR > d4K)?d4K+1:0)];
|
||||
o4OR = b4OR[e4OR-((e4OR > d4O)?d4O+1:0)];
|
||||
|
||||
//-------- two
|
||||
|
||||
b4IL[e4IL] = o4EL - (o4FL + o4GL + o4HL);
|
||||
b4JL[e4JL] = o4FL - (o4EL + o4GL + o4HL);
|
||||
b4KL[e4KL] = o4GL - (o4EL + o4FL + o4HL);
|
||||
b4LL[e4LL] = o4HL - (o4EL + o4FL + o4GL);
|
||||
|
||||
e4IL++; if (e4IL < 0 || e4IL > d4I) e4IL = 0;
|
||||
e4JL++; if (e4JL < 0 || e4JL > d4J) e4JL = 0;
|
||||
e4KL++; if (e4KL < 0 || e4KL > d4K) e4KL = 0;
|
||||
e4LL++; if (e4LL < 0 || e4LL > d4L) e4LL = 0;
|
||||
|
||||
o4IL = b4IL[e4IL-((e4IL > d4I)?d4I+1:0)];
|
||||
o4JL = b4JL[e4JL-((e4JL > d4J)?d4J+1:0)];
|
||||
o4KL = b4KL[e4KL-((e4KL > d4K)?d4K+1:0)];
|
||||
o4LL = b4LL[e4LL-((e4LL > d4L)?d4L+1:0)];
|
||||
|
||||
b4BR[e4BR] = o4CR - (o4GR + o4KR + o4OR);
|
||||
b4FR[e4FR] = o4GR - (o4CR + o4KR + o4OR);
|
||||
b4JR[e4JR] = o4KR - (o4CR + o4GR + o4OR);
|
||||
b4NR[e4NR] = o4OR - (o4CR + o4GR + o4KR);
|
||||
|
||||
e4BR++; if (e4BR < 0 || e4BR > d4B) e4BR = 0;
|
||||
e4FR++; if (e4FR < 0 || e4FR > d4F) e4FR = 0;
|
||||
e4JR++; if (e4JR < 0 || e4JR > d4J) e4JR = 0;
|
||||
e4NR++; if (e4NR < 0 || e4NR > d4N) e4NR = 0;
|
||||
|
||||
o4BR = b4BR[e4BR-((e4BR > d4B)?d4B+1:0)];
|
||||
o4FR = b4FR[e4FR-((e4FR > d4F)?d4F+1:0)];
|
||||
o4JR = b4JR[e4JR-((e4JR > d4J)?d4J+1:0)];
|
||||
o4NR = b4NR[e4NR-((e4NR > d4N)?d4N+1:0)];
|
||||
|
||||
//-------- three
|
||||
|
||||
b4ML[e4ML] = o4IL - (o4JL + o4KL + o4LL);
|
||||
b4NL[e4NL] = o4JL - (o4IL + o4KL + o4LL);
|
||||
b4OL[e4OL] = o4KL - (o4IL + o4JL + o4LL);
|
||||
b4PL[e4PL] = o4LL - (o4IL + o4JL + o4KL);
|
||||
|
||||
e4ML++; if (e4ML < 0 || e4ML > d4M) e4ML = 0;
|
||||
e4NL++; if (e4NL < 0 || e4NL > d4N) e4NL = 0;
|
||||
e4OL++; if (e4OL < 0 || e4OL > d4O) e4OL = 0;
|
||||
e4PL++; if (e4PL < 0 || e4PL > d4P) e4PL = 0;
|
||||
|
||||
o4ML = b4ML[e4ML-((e4ML > d4M)?d4M+1:0)];
|
||||
o4NL = b4NL[e4NL-((e4NL > d4N)?d4N+1:0)];
|
||||
o4OL = b4OL[e4OL-((e4OL > d4O)?d4O+1:0)];
|
||||
o4PL = b4PL[e4PL-((e4PL > d4P)?d4P+1:0)];
|
||||
|
||||
b4AR[e4AR] = o4BR - (o4FR + o4JR + o4NR);
|
||||
b4ER[e4ER] = o4FR - (o4BR + o4JR + o4NR);
|
||||
b4IR[e4IR] = o4JR - (o4BR + o4FR + o4NR);
|
||||
b4MR[e4MR] = o4NR - (o4BR + o4FR + o4JR);
|
||||
|
||||
e4AR++; if (e4AR < 0 || e4AR > d4A) e4AR = 0;
|
||||
e4ER++; if (e4ER < 0 || e4ER > d4E) e4ER = 0;
|
||||
e4IR++; if (e4IR < 0 || e4IR > d4I) e4IR = 0;
|
||||
e4MR++; if (e4MR < 0 || e4MR > d4M) e4MR = 0;
|
||||
|
||||
o4AR = b4AR[e4AR-((e4AR > d4A)?d4A+1:0)];
|
||||
o4ER = b4ER[e4ER-((e4ER > d4E)?d4E+1:0)];
|
||||
o4IR = b4IR[e4IR-((e4IR > d4I)?d4I+1:0)];
|
||||
o4MR = b4MR[e4MR-((e4MR > d4M)?d4M+1:0)];
|
||||
|
||||
//-------- four
|
||||
|
||||
g4DR = o4AR - (o4ER + o4IR + o4MR);
|
||||
g4HR = o4ER - (o4AR + o4IR + o4MR);
|
||||
g4LR = o4IR - (o4AR + o4ER + o4MR);
|
||||
g4PR = o4MR - (o4AR + o4ER + o4IR);
|
||||
|
||||
g4AL = o4ML - (o4NL + o4OL + o4PL);
|
||||
g4BL = o4NL - (o4ML + o4OL + o4PL);
|
||||
g4CL = o4OL - (o4ML + o4NL + o4PL);
|
||||
g4DL = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
dualmonoSampleR = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
dualmonoSampleL = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
//dual mono version is wider = 1.0 at the center
|
||||
//with mainsample 0.0 and 2.0 (only at the edges)
|
||||
//with mainsample out of phase when over 1.0
|
||||
//couldn't re-do the arrays perfectly, so instead
|
||||
//we keep exactly the same cross-matrix,
|
||||
//but we flip the sides we're using for initial reverb.
|
||||
//then, dualmono remains totally dualmono, and blend a bit in for wideness.
|
||||
|
||||
if (wider < 1.0) {
|
||||
inputSampleL = (dualmonoSampleL*wider) + (mainSampleL*(1.0-wider));
|
||||
inputSampleR = (dualmonoSampleR*wider) + (mainSampleR*(1.0-wider));
|
||||
} else {
|
||||
inputSampleL = (dualmonoSampleL*(2.0-wider)) + (mainSampleL*(wider-1.0));
|
||||
inputSampleR = (dualmonoSampleR*(2.0-wider)) + (-mainSampleR*(wider-1.0));
|
||||
}
|
||||
|
||||
bez[bez_CL] = bez[bez_BL];
|
||||
bez[bez_BL] = bez[bez_AL];
|
||||
|
|
@ -213,9 +379,8 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
inputSampleR = (bez[bez_BR]+(CBR*(1.0-X))+(BAR*X))*-0.25;
|
||||
|
||||
bezF[bez_cycle] += derezFreq;
|
||||
bezF[bez_SampL] += ((inputSampleL+bezF[bez_InL]) * derezFreq);
|
||||
bezF[bez_SampR] += ((inputSampleL+bezF[bez_InR]) * derezFreq);
|
||||
bezF[bez_InL] = inputSampleL; bezF[bez_InR] = inputSampleR;
|
||||
bezF[bez_SampL] += (inputSampleL * derezFreq);
|
||||
bezF[bez_SampR] += (inputSampleR * derezFreq);
|
||||
if (bezF[bez_cycle] > 1.0) { //hit the end point and we do a filter sample
|
||||
bezF[bez_cycle] = 0.0;
|
||||
bezF[bez_CL] = bezF[bez_BL];
|
||||
|
|
@ -230,10 +395,10 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
X = bezF[bez_cycle]*bezFreqTrim;
|
||||
double CBLfreq = (bezF[bez_CL]*(1.0-X))+(bezF[bez_BL]*X);
|
||||
double BALfreq = (bezF[bez_BL]*(1.0-X))+(bezF[bez_AL]*X);
|
||||
inputSampleL = (bezF[bez_BL]+(CBLfreq*(1.0-X))+(BALfreq*X))*0.25;
|
||||
inputSampleL = (bezF[bez_BL]+(CBLfreq*(1.0-X))+(BALfreq*X))*0.5;
|
||||
double CBRfreq = (bezF[bez_CR]*(1.0-X))+(bezF[bez_BR]*X);
|
||||
double BARfreq = (bezF[bez_BR]*(1.0-X))+(bezF[bez_AR]*X);
|
||||
inputSampleR = (bezF[bez_BR]+(CBRfreq*(1.0-X))+(BARfreq*X))*0.25;
|
||||
inputSampleR = (bezF[bez_BR]+(CBRfreq*(1.0-X))+(BARfreq*X))*0.5;
|
||||
//filtering the reverb separately, after making it
|
||||
|
||||
inputSampleL = (inputSampleL * wet)+(drySampleL * (1.0-wet));
|
||||
|
|
@ -285,7 +450,8 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
derezFreq = 1.0 / bezFreqFraction;
|
||||
bezFreqTrim = 1.0-(derezFreq*bezFreqTrim);
|
||||
//the revision more accurately connects the bezier curves
|
||||
double wet = D;
|
||||
double wider = D*2.0;
|
||||
double wet = E;
|
||||
|
||||
while (--sampleFrames >= 0)
|
||||
{
|
||||
|
|
@ -301,13 +467,13 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
bez[bez_SampR] += (inputSampleR*attenuate*derez);
|
||||
if (bez[bez_cycle] > 1.0) { //hit the end point and we do a reverb sample
|
||||
bez[bez_cycle] = 0.0;
|
||||
inputSampleL = bez[bez_SampL];
|
||||
inputSampleR = bez[bez_SampR];
|
||||
double mainSampleL = bez[bez_SampL];
|
||||
double mainSampleR = bez[bez_SampR]; //begin primary reverb
|
||||
|
||||
a4AL[c4AL] = inputSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = inputSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = inputSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = inputSampleL + (f4DL * reg4n);
|
||||
a4AL[c4AL] = mainSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = mainSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = mainSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = mainSampleL + (f4DL * reg4n);
|
||||
|
||||
c4AL++; if (c4AL < 0 || c4AL > d4A) c4AL = 0;
|
||||
c4BL++; if (c4BL < 0 || c4BL > d4B) c4BL = 0;
|
||||
|
|
@ -319,10 +485,10 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
double o4CL = a4CL[c4CL-((c4CL > d4C)?d4C+1:0)];
|
||||
double o4DL = a4DL[c4DL-((c4DL > d4D)?d4D+1:0)];
|
||||
|
||||
a4DR[c4DR] = inputSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = inputSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = inputSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = inputSampleR + (f4PR * reg4n);
|
||||
a4DR[c4DR] = mainSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = mainSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = mainSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = mainSampleR + (f4PR * reg4n);
|
||||
|
||||
c4DR++; if (c4DR < 0 || c4DR > d4D) c4DR = 0;
|
||||
c4HR++; if (c4HR < 0 || c4HR > d4H) c4HR = 0;
|
||||
|
|
@ -442,8 +608,173 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
f4LR = o4OL - (o4ML + o4NL + o4PL);
|
||||
f4PR = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
inputSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
inputSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
mainSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
mainSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
|
||||
//we still have an untouched inputsample, turn it into dual mono
|
||||
//won't need to redeclare any of the o4 temp variables, just re-use
|
||||
|
||||
double dualmonoSampleL = bez[bez_SampR];
|
||||
double dualmonoSampleR = bez[bez_SampL];
|
||||
//workaround involves keeping the cross-matrix system,
|
||||
//but for initial layering, each side gets each version
|
||||
//making blends never quite line up as exactly the same.
|
||||
|
||||
b4AL[e4AL] = dualmonoSampleL + (g4AL * reg4n);
|
||||
b4BL[e4BL] = dualmonoSampleL + (g4BL * reg4n);
|
||||
b4CL[e4CL] = dualmonoSampleL + (g4CL * reg4n);
|
||||
b4DL[e4DL] = dualmonoSampleL + (g4DL * reg4n);
|
||||
|
||||
e4AL++; if (e4AL < 0 || e4AL > d4A) e4AL = 0;
|
||||
e4BL++; if (e4BL < 0 || e4BL > d4B) e4BL = 0;
|
||||
e4CL++; if (e4CL < 0 || e4CL > d4C) e4CL = 0;
|
||||
e4DL++; if (e4DL < 0 || e4DL > d4D) e4DL = 0;
|
||||
|
||||
o4AL = b4AL[e4AL-((e4AL > d4A)?d4A+1:0)];
|
||||
o4BL = b4BL[e4BL-((e4BL > d4B)?d4B+1:0)];
|
||||
o4CL = b4CL[e4CL-((e4CL > d4C)?d4C+1:0)];
|
||||
o4DL = b4DL[e4DL-((e4DL > d4D)?d4D+1:0)];
|
||||
|
||||
b4DR[e4DR] = dualmonoSampleR + (g4DR * reg4n);
|
||||
b4HR[e4HR] = dualmonoSampleR + (g4HR * reg4n);
|
||||
b4LR[e4LR] = dualmonoSampleR + (g4LR * reg4n);
|
||||
b4PR[e4PR] = dualmonoSampleR + (g4PR * reg4n);
|
||||
|
||||
e4DR++; if (e4DR < 0 || e4DR > d4D) e4DR = 0;
|
||||
e4HR++; if (e4HR < 0 || e4HR > d4H) e4HR = 0;
|
||||
e4LR++; if (e4LR < 0 || e4LR > d4L) e4LR = 0;
|
||||
e4PR++; if (e4PR < 0 || e4PR > d4P) e4PR = 0;
|
||||
|
||||
o4DR = b4DR[e4DR-((e4DR > d4D)?d4D+1:0)];
|
||||
o4HR = b4HR[e4HR-((e4HR > d4H)?d4H+1:0)];
|
||||
o4LR = b4LR[e4LR-((e4LR > d4L)?d4L+1:0)];
|
||||
o4PR = b4PR[e4PR-((e4PR > d4P)?d4P+1:0)];
|
||||
|
||||
//-------- one
|
||||
|
||||
b4EL[e4EL] = o4AL - (o4BL + o4CL + o4DL);
|
||||
b4FL[e4FL] = o4BL - (o4AL + o4CL + o4DL);
|
||||
b4GL[e4GL] = o4CL - (o4AL + o4BL + o4DL);
|
||||
b4HL[e4HL] = o4DL - (o4AL + o4BL + o4CL);
|
||||
|
||||
e4EL++; if (e4EL < 0 || e4EL > d4E) e4EL = 0;
|
||||
e4FL++; if (e4FL < 0 || e4FL > d4F) e4FL = 0;
|
||||
e4GL++; if (e4GL < 0 || e4GL > d4G) e4GL = 0;
|
||||
e4HL++; if (e4HL < 0 || e4HL > d4H) e4HL = 0;
|
||||
|
||||
o4EL = b4EL[e4EL-((e4EL > d4E)?d4E+1:0)];
|
||||
o4FL = b4FL[e4FL-((e4FL > d4F)?d4F+1:0)];
|
||||
o4GL = b4GL[e4GL-((e4GL > d4G)?d4G+1:0)];
|
||||
o4HL = b4HL[e4HL-((e4HL > d4H)?d4H+1:0)];
|
||||
|
||||
b4CR[e4CR] = o4DR - (o4HR + o4LR + o4PR);
|
||||
b4GR[e4GR] = o4HR - (o4DR + o4LR + o4PR);
|
||||
b4KR[e4KR] = o4LR - (o4DR + o4HR + o4PR);
|
||||
b4OR[e4OR] = o4PR - (o4DR + o4HR + o4LR);
|
||||
|
||||
e4CR++; if (e4CR < 0 || e4CR > d4C) e4CR = 0;
|
||||
e4GR++; if (e4GR < 0 || e4GR > d4G) e4GR = 0;
|
||||
e4KR++; if (e4KR < 0 || e4KR > d4K) e4KR = 0;
|
||||
e4OR++; if (e4OR < 0 || e4OR > d4O) e4OR = 0;
|
||||
|
||||
o4CR = b4CR[e4CR-((e4CR > d4C)?d4C+1:0)];
|
||||
o4GR = b4GR[e4GR-((e4GR > d4G)?d4G+1:0)];
|
||||
o4KR = b4KR[e4KR-((e4KR > d4K)?d4K+1:0)];
|
||||
o4OR = b4OR[e4OR-((e4OR > d4O)?d4O+1:0)];
|
||||
|
||||
//-------- two
|
||||
|
||||
b4IL[e4IL] = o4EL - (o4FL + o4GL + o4HL);
|
||||
b4JL[e4JL] = o4FL - (o4EL + o4GL + o4HL);
|
||||
b4KL[e4KL] = o4GL - (o4EL + o4FL + o4HL);
|
||||
b4LL[e4LL] = o4HL - (o4EL + o4FL + o4GL);
|
||||
|
||||
e4IL++; if (e4IL < 0 || e4IL > d4I) e4IL = 0;
|
||||
e4JL++; if (e4JL < 0 || e4JL > d4J) e4JL = 0;
|
||||
e4KL++; if (e4KL < 0 || e4KL > d4K) e4KL = 0;
|
||||
e4LL++; if (e4LL < 0 || e4LL > d4L) e4LL = 0;
|
||||
|
||||
o4IL = b4IL[e4IL-((e4IL > d4I)?d4I+1:0)];
|
||||
o4JL = b4JL[e4JL-((e4JL > d4J)?d4J+1:0)];
|
||||
o4KL = b4KL[e4KL-((e4KL > d4K)?d4K+1:0)];
|
||||
o4LL = b4LL[e4LL-((e4LL > d4L)?d4L+1:0)];
|
||||
|
||||
b4BR[e4BR] = o4CR - (o4GR + o4KR + o4OR);
|
||||
b4FR[e4FR] = o4GR - (o4CR + o4KR + o4OR);
|
||||
b4JR[e4JR] = o4KR - (o4CR + o4GR + o4OR);
|
||||
b4NR[e4NR] = o4OR - (o4CR + o4GR + o4KR);
|
||||
|
||||
e4BR++; if (e4BR < 0 || e4BR > d4B) e4BR = 0;
|
||||
e4FR++; if (e4FR < 0 || e4FR > d4F) e4FR = 0;
|
||||
e4JR++; if (e4JR < 0 || e4JR > d4J) e4JR = 0;
|
||||
e4NR++; if (e4NR < 0 || e4NR > d4N) e4NR = 0;
|
||||
|
||||
o4BR = b4BR[e4BR-((e4BR > d4B)?d4B+1:0)];
|
||||
o4FR = b4FR[e4FR-((e4FR > d4F)?d4F+1:0)];
|
||||
o4JR = b4JR[e4JR-((e4JR > d4J)?d4J+1:0)];
|
||||
o4NR = b4NR[e4NR-((e4NR > d4N)?d4N+1:0)];
|
||||
|
||||
//-------- three
|
||||
|
||||
b4ML[e4ML] = o4IL - (o4JL + o4KL + o4LL);
|
||||
b4NL[e4NL] = o4JL - (o4IL + o4KL + o4LL);
|
||||
b4OL[e4OL] = o4KL - (o4IL + o4JL + o4LL);
|
||||
b4PL[e4PL] = o4LL - (o4IL + o4JL + o4KL);
|
||||
|
||||
e4ML++; if (e4ML < 0 || e4ML > d4M) e4ML = 0;
|
||||
e4NL++; if (e4NL < 0 || e4NL > d4N) e4NL = 0;
|
||||
e4OL++; if (e4OL < 0 || e4OL > d4O) e4OL = 0;
|
||||
e4PL++; if (e4PL < 0 || e4PL > d4P) e4PL = 0;
|
||||
|
||||
o4ML = b4ML[e4ML-((e4ML > d4M)?d4M+1:0)];
|
||||
o4NL = b4NL[e4NL-((e4NL > d4N)?d4N+1:0)];
|
||||
o4OL = b4OL[e4OL-((e4OL > d4O)?d4O+1:0)];
|
||||
o4PL = b4PL[e4PL-((e4PL > d4P)?d4P+1:0)];
|
||||
|
||||
b4AR[e4AR] = o4BR - (o4FR + o4JR + o4NR);
|
||||
b4ER[e4ER] = o4FR - (o4BR + o4JR + o4NR);
|
||||
b4IR[e4IR] = o4JR - (o4BR + o4FR + o4NR);
|
||||
b4MR[e4MR] = o4NR - (o4BR + o4FR + o4JR);
|
||||
|
||||
e4AR++; if (e4AR < 0 || e4AR > d4A) e4AR = 0;
|
||||
e4ER++; if (e4ER < 0 || e4ER > d4E) e4ER = 0;
|
||||
e4IR++; if (e4IR < 0 || e4IR > d4I) e4IR = 0;
|
||||
e4MR++; if (e4MR < 0 || e4MR > d4M) e4MR = 0;
|
||||
|
||||
o4AR = b4AR[e4AR-((e4AR > d4A)?d4A+1:0)];
|
||||
o4ER = b4ER[e4ER-((e4ER > d4E)?d4E+1:0)];
|
||||
o4IR = b4IR[e4IR-((e4IR > d4I)?d4I+1:0)];
|
||||
o4MR = b4MR[e4MR-((e4MR > d4M)?d4M+1:0)];
|
||||
|
||||
//-------- four
|
||||
|
||||
g4DR = o4AR - (o4ER + o4IR + o4MR);
|
||||
g4HR = o4ER - (o4AR + o4IR + o4MR);
|
||||
g4LR = o4IR - (o4AR + o4ER + o4MR);
|
||||
g4PR = o4MR - (o4AR + o4ER + o4IR);
|
||||
|
||||
g4AL = o4ML - (o4NL + o4OL + o4PL);
|
||||
g4BL = o4NL - (o4ML + o4OL + o4PL);
|
||||
g4CL = o4OL - (o4ML + o4NL + o4PL);
|
||||
g4DL = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
dualmonoSampleR = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
dualmonoSampleL = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
//dual mono version is wider = 1.0 at the center
|
||||
//with mainsample 0.0 and 2.0 (only at the edges)
|
||||
//with mainsample out of phase when over 1.0
|
||||
//couldn't re-do the arrays perfectly, so instead
|
||||
//we keep exactly the same cross-matrix,
|
||||
//but we flip the sides we're using for initial reverb.
|
||||
//then, dualmono remains totally dualmono, and blend a bit in for wideness.
|
||||
|
||||
if (wider < 1.0) {
|
||||
inputSampleL = (dualmonoSampleL*wider) + (mainSampleL*(1.0-wider));
|
||||
inputSampleR = (dualmonoSampleR*wider) + (mainSampleR*(1.0-wider));
|
||||
} else {
|
||||
inputSampleL = (dualmonoSampleL*(2.0-wider)) + (mainSampleL*(wider-1.0));
|
||||
inputSampleR = (dualmonoSampleR*(2.0-wider)) + (-mainSampleR*(wider-1.0));
|
||||
}
|
||||
|
||||
bez[bez_CL] = bez[bez_BL];
|
||||
bez[bez_BL] = bez[bez_AL];
|
||||
|
|
@ -464,9 +795,8 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
inputSampleR = (bez[bez_BR]+(CBR*(1.0-X))+(BAR*X))*-0.25;
|
||||
|
||||
bezF[bez_cycle] += derezFreq;
|
||||
bezF[bez_SampL] += ((inputSampleL+bezF[bez_InL]) * derezFreq);
|
||||
bezF[bez_SampR] += ((inputSampleL+bezF[bez_InR]) * derezFreq);
|
||||
bezF[bez_InL] = inputSampleL; bezF[bez_InR] = inputSampleR;
|
||||
bezF[bez_SampL] += (inputSampleL * derezFreq);
|
||||
bezF[bez_SampR] += (inputSampleR * derezFreq);
|
||||
if (bezF[bez_cycle] > 1.0) { //hit the end point and we do a filter sample
|
||||
bezF[bez_cycle] = 0.0;
|
||||
bezF[bez_CL] = bezF[bez_BL];
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -15,7 +15,8 @@ VerbTiny::VerbTiny(audioMasterCallback audioMaster) :
|
|||
A = 0.5;
|
||||
B = 1.0;
|
||||
C = 1.0;
|
||||
D = 1.0;
|
||||
D = 0.0;
|
||||
E = 1.0;
|
||||
|
||||
for(int x = 0; x < d4A+2; x++) {a4AL[x] = 0.0; a4AR[x] = 0.0;}
|
||||
for(int x = 0; x < d4B+2; x++) {a4BL[x] = 0.0; a4BR[x] = 0.0;}
|
||||
|
|
@ -40,6 +41,29 @@ VerbTiny::VerbTiny(audioMasterCallback audioMaster) :
|
|||
f4AL = f4BL = f4CL = f4DL = 0.0;
|
||||
f4DR = f4HR = f4LR = f4PR = 0.0;
|
||||
|
||||
for(int x = 0; x < d4A+2; x++) {b4AL[x] = 0.0; b4AR[x] = 0.0;}
|
||||
for(int x = 0; x < d4B+2; x++) {b4BL[x] = 0.0; b4BR[x] = 0.0;}
|
||||
for(int x = 0; x < d4C+2; x++) {b4CL[x] = 0.0; b4CR[x] = 0.0;}
|
||||
for(int x = 0; x < d4D+2; x++) {b4DL[x] = 0.0; b4DR[x] = 0.0;}
|
||||
for(int x = 0; x < d4E+2; x++) {b4EL[x] = 0.0; b4ER[x] = 0.0;}
|
||||
for(int x = 0; x < d4F+2; x++) {b4FL[x] = 0.0; b4FR[x] = 0.0;}
|
||||
for(int x = 0; x < d4G+2; x++) {b4GL[x] = 0.0; b4GR[x] = 0.0;}
|
||||
for(int x = 0; x < d4H+2; x++) {b4HL[x] = 0.0; b4HR[x] = 0.0;}
|
||||
for(int x = 0; x < d4I+2; x++) {b4IL[x] = 0.0; b4IR[x] = 0.0;}
|
||||
for(int x = 0; x < d4J+2; x++) {b4JL[x] = 0.0; b4JR[x] = 0.0;}
|
||||
for(int x = 0; x < d4K+2; x++) {b4KL[x] = 0.0; b4KR[x] = 0.0;}
|
||||
for(int x = 0; x < d4L+2; x++) {b4LL[x] = 0.0; b4LR[x] = 0.0;}
|
||||
for(int x = 0; x < d4M+2; x++) {b4ML[x] = 0.0; b4MR[x] = 0.0;}
|
||||
for(int x = 0; x < d4N+2; x++) {b4NL[x] = 0.0; b4NR[x] = 0.0;}
|
||||
for(int x = 0; x < d4O+2; x++) {b4OL[x] = 0.0; b4OR[x] = 0.0;}
|
||||
for(int x = 0; x < d4P+2; x++) {b4PL[x] = 0.0; b4PR[x] = 0.0;}
|
||||
e4AL = e4BL = e4CL = e4DL = e4EL = e4FL = e4GL = e4HL = 1;
|
||||
e4IL = e4JL = e4KL = e4LL = e4ML = e4NL = e4OL = e4PL = 1;
|
||||
e4AR = e4BR = e4CR = e4DR = e4ER = e4FR = e4GR = e4HR = 1;
|
||||
e4IR = e4JR = e4KR = e4LR = e4MR = e4NR = e4OR = e4PR = 1;
|
||||
g4AL = g4BL = g4CL = g4DL = 0.0;
|
||||
g4DR = g4HR = g4LR = g4PR = 0.0;
|
||||
|
||||
for (int x = 0; x < bez_total; x++) {
|
||||
bez[x] = 0.0;
|
||||
bezF[x] = 0.0;
|
||||
|
|
@ -84,6 +108,7 @@ VstInt32 VerbTiny::getChunk (void** data, bool isPreset)
|
|||
chunkData[1] = B;
|
||||
chunkData[2] = C;
|
||||
chunkData[3] = D;
|
||||
chunkData[4] = E;
|
||||
/* Note: The way this is set up, it will break if you manage to save settings on an Intel
|
||||
machine and load them on a PPC Mac. However, it's fine if you stick to the machine you
|
||||
started with. */
|
||||
|
|
@ -99,6 +124,7 @@ VstInt32 VerbTiny::setChunk (void* data, VstInt32 byteSize, bool isPreset)
|
|||
B = pinParameter(chunkData[1]);
|
||||
C = pinParameter(chunkData[2]);
|
||||
D = pinParameter(chunkData[3]);
|
||||
E = pinParameter(chunkData[4]);
|
||||
/* We're ignoring byteSize as we found it to be a filthy liar */
|
||||
|
||||
/* calculate any other fields you need here - you could copy in
|
||||
|
|
@ -112,6 +138,7 @@ void VerbTiny::setParameter(VstInt32 index, float value) {
|
|||
case kParamB: B = value; break;
|
||||
case kParamC: C = value; break;
|
||||
case kParamD: D = value; break;
|
||||
case kParamE: E = value; break;
|
||||
default: throw; // unknown parameter, shouldn't happen!
|
||||
}
|
||||
}
|
||||
|
|
@ -122,6 +149,7 @@ float VerbTiny::getParameter(VstInt32 index) {
|
|||
case kParamB: return B; break;
|
||||
case kParamC: return C; break;
|
||||
case kParamD: return D; break;
|
||||
case kParamE: return E; break;
|
||||
default: break; // unknown parameter, shouldn't happen!
|
||||
} return 0.0; //we only need to update the relevant name, this is simple to manage
|
||||
}
|
||||
|
|
@ -131,7 +159,8 @@ void VerbTiny::getParameterName(VstInt32 index, char *text) {
|
|||
case kParamA: vst_strncpy (text, "Replace", kVstMaxParamStrLen); break;
|
||||
case kParamB: vst_strncpy (text, "Derez", kVstMaxParamStrLen); break;
|
||||
case kParamC: vst_strncpy (text, "Filter", kVstMaxParamStrLen); break;
|
||||
case kParamD: vst_strncpy (text, "Dry/Wet", kVstMaxParamStrLen); break;
|
||||
case kParamD: vst_strncpy (text, "Wider", kVstMaxParamStrLen); break;
|
||||
case kParamE: vst_strncpy (text, "Dry/Wet", kVstMaxParamStrLen); break;
|
||||
default: break; // unknown parameter, shouldn't happen!
|
||||
} //this is our labels for displaying in the VST host
|
||||
}
|
||||
|
|
@ -142,6 +171,7 @@ void VerbTiny::getParameterDisplay(VstInt32 index, char *text) {
|
|||
case kParamB: float2string (B, text, kVstMaxParamStrLen); break;
|
||||
case kParamC: float2string (C, text, kVstMaxParamStrLen); break;
|
||||
case kParamD: float2string (D, text, kVstMaxParamStrLen); break;
|
||||
case kParamE: float2string (E, text, kVstMaxParamStrLen); break;
|
||||
default: break; // unknown parameter, shouldn't happen!
|
||||
} //this displays the values and handles 'popups' where it's discrete choices
|
||||
}
|
||||
|
|
@ -152,6 +182,7 @@ void VerbTiny::getParameterLabel(VstInt32 index, char *text) {
|
|||
case kParamB: vst_strncpy (text, "", kVstMaxParamStrLen); break;
|
||||
case kParamC: vst_strncpy (text, "", kVstMaxParamStrLen); break;
|
||||
case kParamD: vst_strncpy (text, "", kVstMaxParamStrLen); break;
|
||||
case kParamE: vst_strncpy (text, "", kVstMaxParamStrLen); break;
|
||||
default: break; // unknown parameter, shouldn't happen!
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,7 +20,8 @@ enum {
|
|||
kParamB =1,
|
||||
kParamC =2,
|
||||
kParamD =3,
|
||||
kNumParameters = 4
|
||||
kParamE =4,
|
||||
kNumParameters =5
|
||||
}; //
|
||||
|
||||
const int kNumPrograms = 0;
|
||||
|
|
@ -62,6 +63,7 @@ private:
|
|||
float B;
|
||||
float C;
|
||||
float D;
|
||||
float E;
|
||||
|
||||
double a4AL[d4A+5];
|
||||
double a4BL[d4B+5];
|
||||
|
|
@ -100,6 +102,45 @@ private:
|
|||
int c4AR,c4BR,c4CR,c4DR,c4ER,c4FR,c4GR,c4HR;
|
||||
int c4IR,c4JR,c4KR,c4LR,c4MR,c4NR,c4OR,c4PR;
|
||||
double f4AL,f4BL,f4CL,f4DL,f4DR,f4HR,f4LR,f4PR;
|
||||
//base stereo reverb
|
||||
double b4AL[d4A+5];
|
||||
double b4BL[d4B+5];
|
||||
double b4CL[d4C+5];
|
||||
double b4DL[d4D+5];
|
||||
double b4EL[d4E+5];
|
||||
double b4FL[d4F+5];
|
||||
double b4GL[d4G+5];
|
||||
double b4HL[d4H+5];
|
||||
double b4IL[d4I+5];
|
||||
double b4JL[d4J+5];
|
||||
double b4KL[d4K+5];
|
||||
double b4LL[d4L+5];
|
||||
double b4ML[d4M+5];
|
||||
double b4NL[d4N+5];
|
||||
double b4OL[d4O+5];
|
||||
double b4PL[d4P+5];
|
||||
double b4AR[d4A+5];
|
||||
double b4BR[d4B+5];
|
||||
double b4CR[d4C+5];
|
||||
double b4DR[d4D+5];
|
||||
double b4ER[d4E+5];
|
||||
double b4FR[d4F+5];
|
||||
double b4GR[d4G+5];
|
||||
double b4HR[d4H+5];
|
||||
double b4IR[d4I+5];
|
||||
double b4JR[d4J+5];
|
||||
double b4KR[d4K+5];
|
||||
double b4LR[d4L+5];
|
||||
double b4MR[d4M+5];
|
||||
double b4NR[d4N+5];
|
||||
double b4OR[d4O+5];
|
||||
double b4PR[d4P+5];
|
||||
int e4AL,e4BL,e4CL,e4DL,e4EL,e4FL,e4GL,e4HL;
|
||||
int e4IL,e4JL,e4KL,e4LL,e4ML,e4NL,e4OL,e4PL;
|
||||
int e4AR,e4BR,e4CR,e4DR,e4ER,e4FR,e4GR,e4HR;
|
||||
int e4IR,e4JR,e4KR,e4LR,e4MR,e4NR,e4OR,e4PR;
|
||||
double g4AL,g4BL,g4CL,g4DL,g4DR,g4HR,g4LR,g4PR;
|
||||
//changed letter is the dual mono, with rearranged grid
|
||||
|
||||
enum {
|
||||
bez_AL,
|
||||
|
|
@ -108,8 +149,6 @@ private:
|
|||
bez_BR,
|
||||
bez_CL,
|
||||
bez_CR,
|
||||
bez_InL,
|
||||
bez_InR,
|
||||
bez_SampL,
|
||||
bez_SampR,
|
||||
bez_cycle,
|
||||
|
|
|
|||
|
|
@ -34,7 +34,8 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
derezFreq = 1.0 / bezFreqFraction;
|
||||
bezFreqTrim = 1.0-(derezFreq*bezFreqTrim);
|
||||
//the revision more accurately connects the bezier curves
|
||||
double wet = D;
|
||||
double wider = D*2.0;
|
||||
double wet = E;
|
||||
|
||||
while (--sampleFrames >= 0)
|
||||
{
|
||||
|
|
@ -50,13 +51,13 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
bez[bez_SampR] += (inputSampleR*attenuate*derez);
|
||||
if (bez[bez_cycle] > 1.0) { //hit the end point and we do a reverb sample
|
||||
bez[bez_cycle] = 0.0;
|
||||
inputSampleL = bez[bez_SampL];
|
||||
inputSampleR = bez[bez_SampR];
|
||||
double mainSampleL = bez[bez_SampL];
|
||||
double mainSampleR = bez[bez_SampR]; //begin primary reverb
|
||||
|
||||
a4AL[c4AL] = inputSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = inputSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = inputSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = inputSampleL + (f4DL * reg4n);
|
||||
a4AL[c4AL] = mainSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = mainSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = mainSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = mainSampleL + (f4DL * reg4n);
|
||||
|
||||
c4AL++; if (c4AL < 0 || c4AL > d4A) c4AL = 0;
|
||||
c4BL++; if (c4BL < 0 || c4BL > d4B) c4BL = 0;
|
||||
|
|
@ -68,10 +69,10 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
double o4CL = a4CL[c4CL-((c4CL > d4C)?d4C+1:0)];
|
||||
double o4DL = a4DL[c4DL-((c4DL > d4D)?d4D+1:0)];
|
||||
|
||||
a4DR[c4DR] = inputSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = inputSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = inputSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = inputSampleR + (f4PR * reg4n);
|
||||
a4DR[c4DR] = mainSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = mainSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = mainSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = mainSampleR + (f4PR * reg4n);
|
||||
|
||||
c4DR++; if (c4DR < 0 || c4DR > d4D) c4DR = 0;
|
||||
c4HR++; if (c4HR < 0 || c4HR > d4H) c4HR = 0;
|
||||
|
|
@ -191,8 +192,173 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
f4LR = o4OL - (o4ML + o4NL + o4PL);
|
||||
f4PR = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
inputSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
inputSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
mainSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
mainSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
|
||||
//we still have an untouched inputsample, turn it into dual mono
|
||||
//won't need to redeclare any of the o4 temp variables, just re-use
|
||||
|
||||
double dualmonoSampleL = bez[bez_SampR];
|
||||
double dualmonoSampleR = bez[bez_SampL];
|
||||
//workaround involves keeping the cross-matrix system,
|
||||
//but for initial layering, each side gets each version
|
||||
//making blends never quite line up as exactly the same.
|
||||
|
||||
b4AL[e4AL] = dualmonoSampleL + (g4AL * reg4n);
|
||||
b4BL[e4BL] = dualmonoSampleL + (g4BL * reg4n);
|
||||
b4CL[e4CL] = dualmonoSampleL + (g4CL * reg4n);
|
||||
b4DL[e4DL] = dualmonoSampleL + (g4DL * reg4n);
|
||||
|
||||
e4AL++; if (e4AL < 0 || e4AL > d4A) e4AL = 0;
|
||||
e4BL++; if (e4BL < 0 || e4BL > d4B) e4BL = 0;
|
||||
e4CL++; if (e4CL < 0 || e4CL > d4C) e4CL = 0;
|
||||
e4DL++; if (e4DL < 0 || e4DL > d4D) e4DL = 0;
|
||||
|
||||
o4AL = b4AL[e4AL-((e4AL > d4A)?d4A+1:0)];
|
||||
o4BL = b4BL[e4BL-((e4BL > d4B)?d4B+1:0)];
|
||||
o4CL = b4CL[e4CL-((e4CL > d4C)?d4C+1:0)];
|
||||
o4DL = b4DL[e4DL-((e4DL > d4D)?d4D+1:0)];
|
||||
|
||||
b4DR[e4DR] = dualmonoSampleR + (g4DR * reg4n);
|
||||
b4HR[e4HR] = dualmonoSampleR + (g4HR * reg4n);
|
||||
b4LR[e4LR] = dualmonoSampleR + (g4LR * reg4n);
|
||||
b4PR[e4PR] = dualmonoSampleR + (g4PR * reg4n);
|
||||
|
||||
e4DR++; if (e4DR < 0 || e4DR > d4D) e4DR = 0;
|
||||
e4HR++; if (e4HR < 0 || e4HR > d4H) e4HR = 0;
|
||||
e4LR++; if (e4LR < 0 || e4LR > d4L) e4LR = 0;
|
||||
e4PR++; if (e4PR < 0 || e4PR > d4P) e4PR = 0;
|
||||
|
||||
o4DR = b4DR[e4DR-((e4DR > d4D)?d4D+1:0)];
|
||||
o4HR = b4HR[e4HR-((e4HR > d4H)?d4H+1:0)];
|
||||
o4LR = b4LR[e4LR-((e4LR > d4L)?d4L+1:0)];
|
||||
o4PR = b4PR[e4PR-((e4PR > d4P)?d4P+1:0)];
|
||||
|
||||
//-------- one
|
||||
|
||||
b4EL[e4EL] = o4AL - (o4BL + o4CL + o4DL);
|
||||
b4FL[e4FL] = o4BL - (o4AL + o4CL + o4DL);
|
||||
b4GL[e4GL] = o4CL - (o4AL + o4BL + o4DL);
|
||||
b4HL[e4HL] = o4DL - (o4AL + o4BL + o4CL);
|
||||
|
||||
e4EL++; if (e4EL < 0 || e4EL > d4E) e4EL = 0;
|
||||
e4FL++; if (e4FL < 0 || e4FL > d4F) e4FL = 0;
|
||||
e4GL++; if (e4GL < 0 || e4GL > d4G) e4GL = 0;
|
||||
e4HL++; if (e4HL < 0 || e4HL > d4H) e4HL = 0;
|
||||
|
||||
o4EL = b4EL[e4EL-((e4EL > d4E)?d4E+1:0)];
|
||||
o4FL = b4FL[e4FL-((e4FL > d4F)?d4F+1:0)];
|
||||
o4GL = b4GL[e4GL-((e4GL > d4G)?d4G+1:0)];
|
||||
o4HL = b4HL[e4HL-((e4HL > d4H)?d4H+1:0)];
|
||||
|
||||
b4CR[e4CR] = o4DR - (o4HR + o4LR + o4PR);
|
||||
b4GR[e4GR] = o4HR - (o4DR + o4LR + o4PR);
|
||||
b4KR[e4KR] = o4LR - (o4DR + o4HR + o4PR);
|
||||
b4OR[e4OR] = o4PR - (o4DR + o4HR + o4LR);
|
||||
|
||||
e4CR++; if (e4CR < 0 || e4CR > d4C) e4CR = 0;
|
||||
e4GR++; if (e4GR < 0 || e4GR > d4G) e4GR = 0;
|
||||
e4KR++; if (e4KR < 0 || e4KR > d4K) e4KR = 0;
|
||||
e4OR++; if (e4OR < 0 || e4OR > d4O) e4OR = 0;
|
||||
|
||||
o4CR = b4CR[e4CR-((e4CR > d4C)?d4C+1:0)];
|
||||
o4GR = b4GR[e4GR-((e4GR > d4G)?d4G+1:0)];
|
||||
o4KR = b4KR[e4KR-((e4KR > d4K)?d4K+1:0)];
|
||||
o4OR = b4OR[e4OR-((e4OR > d4O)?d4O+1:0)];
|
||||
|
||||
//-------- two
|
||||
|
||||
b4IL[e4IL] = o4EL - (o4FL + o4GL + o4HL);
|
||||
b4JL[e4JL] = o4FL - (o4EL + o4GL + o4HL);
|
||||
b4KL[e4KL] = o4GL - (o4EL + o4FL + o4HL);
|
||||
b4LL[e4LL] = o4HL - (o4EL + o4FL + o4GL);
|
||||
|
||||
e4IL++; if (e4IL < 0 || e4IL > d4I) e4IL = 0;
|
||||
e4JL++; if (e4JL < 0 || e4JL > d4J) e4JL = 0;
|
||||
e4KL++; if (e4KL < 0 || e4KL > d4K) e4KL = 0;
|
||||
e4LL++; if (e4LL < 0 || e4LL > d4L) e4LL = 0;
|
||||
|
||||
o4IL = b4IL[e4IL-((e4IL > d4I)?d4I+1:0)];
|
||||
o4JL = b4JL[e4JL-((e4JL > d4J)?d4J+1:0)];
|
||||
o4KL = b4KL[e4KL-((e4KL > d4K)?d4K+1:0)];
|
||||
o4LL = b4LL[e4LL-((e4LL > d4L)?d4L+1:0)];
|
||||
|
||||
b4BR[e4BR] = o4CR - (o4GR + o4KR + o4OR);
|
||||
b4FR[e4FR] = o4GR - (o4CR + o4KR + o4OR);
|
||||
b4JR[e4JR] = o4KR - (o4CR + o4GR + o4OR);
|
||||
b4NR[e4NR] = o4OR - (o4CR + o4GR + o4KR);
|
||||
|
||||
e4BR++; if (e4BR < 0 || e4BR > d4B) e4BR = 0;
|
||||
e4FR++; if (e4FR < 0 || e4FR > d4F) e4FR = 0;
|
||||
e4JR++; if (e4JR < 0 || e4JR > d4J) e4JR = 0;
|
||||
e4NR++; if (e4NR < 0 || e4NR > d4N) e4NR = 0;
|
||||
|
||||
o4BR = b4BR[e4BR-((e4BR > d4B)?d4B+1:0)];
|
||||
o4FR = b4FR[e4FR-((e4FR > d4F)?d4F+1:0)];
|
||||
o4JR = b4JR[e4JR-((e4JR > d4J)?d4J+1:0)];
|
||||
o4NR = b4NR[e4NR-((e4NR > d4N)?d4N+1:0)];
|
||||
|
||||
//-------- three
|
||||
|
||||
b4ML[e4ML] = o4IL - (o4JL + o4KL + o4LL);
|
||||
b4NL[e4NL] = o4JL - (o4IL + o4KL + o4LL);
|
||||
b4OL[e4OL] = o4KL - (o4IL + o4JL + o4LL);
|
||||
b4PL[e4PL] = o4LL - (o4IL + o4JL + o4KL);
|
||||
|
||||
e4ML++; if (e4ML < 0 || e4ML > d4M) e4ML = 0;
|
||||
e4NL++; if (e4NL < 0 || e4NL > d4N) e4NL = 0;
|
||||
e4OL++; if (e4OL < 0 || e4OL > d4O) e4OL = 0;
|
||||
e4PL++; if (e4PL < 0 || e4PL > d4P) e4PL = 0;
|
||||
|
||||
o4ML = b4ML[e4ML-((e4ML > d4M)?d4M+1:0)];
|
||||
o4NL = b4NL[e4NL-((e4NL > d4N)?d4N+1:0)];
|
||||
o4OL = b4OL[e4OL-((e4OL > d4O)?d4O+1:0)];
|
||||
o4PL = b4PL[e4PL-((e4PL > d4P)?d4P+1:0)];
|
||||
|
||||
b4AR[e4AR] = o4BR - (o4FR + o4JR + o4NR);
|
||||
b4ER[e4ER] = o4FR - (o4BR + o4JR + o4NR);
|
||||
b4IR[e4IR] = o4JR - (o4BR + o4FR + o4NR);
|
||||
b4MR[e4MR] = o4NR - (o4BR + o4FR + o4JR);
|
||||
|
||||
e4AR++; if (e4AR < 0 || e4AR > d4A) e4AR = 0;
|
||||
e4ER++; if (e4ER < 0 || e4ER > d4E) e4ER = 0;
|
||||
e4IR++; if (e4IR < 0 || e4IR > d4I) e4IR = 0;
|
||||
e4MR++; if (e4MR < 0 || e4MR > d4M) e4MR = 0;
|
||||
|
||||
o4AR = b4AR[e4AR-((e4AR > d4A)?d4A+1:0)];
|
||||
o4ER = b4ER[e4ER-((e4ER > d4E)?d4E+1:0)];
|
||||
o4IR = b4IR[e4IR-((e4IR > d4I)?d4I+1:0)];
|
||||
o4MR = b4MR[e4MR-((e4MR > d4M)?d4M+1:0)];
|
||||
|
||||
//-------- four
|
||||
|
||||
g4DR = o4AR - (o4ER + o4IR + o4MR);
|
||||
g4HR = o4ER - (o4AR + o4IR + o4MR);
|
||||
g4LR = o4IR - (o4AR + o4ER + o4MR);
|
||||
g4PR = o4MR - (o4AR + o4ER + o4IR);
|
||||
|
||||
g4AL = o4ML - (o4NL + o4OL + o4PL);
|
||||
g4BL = o4NL - (o4ML + o4OL + o4PL);
|
||||
g4CL = o4OL - (o4ML + o4NL + o4PL);
|
||||
g4DL = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
dualmonoSampleR = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
dualmonoSampleL = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
//dual mono version is wider = 1.0 at the center
|
||||
//with mainsample 0.0 and 2.0 (only at the edges)
|
||||
//with mainsample out of phase when over 1.0
|
||||
//couldn't re-do the arrays perfectly, so instead
|
||||
//we keep exactly the same cross-matrix,
|
||||
//but we flip the sides we're using for initial reverb.
|
||||
//then, dualmono remains totally dualmono, and blend a bit in for wideness.
|
||||
|
||||
if (wider < 1.0) {
|
||||
inputSampleL = (dualmonoSampleL*wider) + (mainSampleL*(1.0-wider));
|
||||
inputSampleR = (dualmonoSampleR*wider) + (mainSampleR*(1.0-wider));
|
||||
} else {
|
||||
inputSampleL = (dualmonoSampleL*(2.0-wider)) + (mainSampleL*(wider-1.0));
|
||||
inputSampleR = (dualmonoSampleR*(2.0-wider)) + (-mainSampleR*(wider-1.0));
|
||||
}
|
||||
|
||||
bez[bez_CL] = bez[bez_BL];
|
||||
bez[bez_BL] = bez[bez_AL];
|
||||
|
|
@ -213,9 +379,8 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
inputSampleR = (bez[bez_BR]+(CBR*(1.0-X))+(BAR*X))*-0.25;
|
||||
|
||||
bezF[bez_cycle] += derezFreq;
|
||||
bezF[bez_SampL] += ((inputSampleL+bezF[bez_InL]) * derezFreq);
|
||||
bezF[bez_SampR] += ((inputSampleL+bezF[bez_InR]) * derezFreq);
|
||||
bezF[bez_InL] = inputSampleL; bezF[bez_InR] = inputSampleR;
|
||||
bezF[bez_SampL] += (inputSampleL * derezFreq);
|
||||
bezF[bez_SampR] += (inputSampleR * derezFreq);
|
||||
if (bezF[bez_cycle] > 1.0) { //hit the end point and we do a filter sample
|
||||
bezF[bez_cycle] = 0.0;
|
||||
bezF[bez_CL] = bezF[bez_BL];
|
||||
|
|
@ -230,10 +395,10 @@ void VerbTiny::processReplacing(float **inputs, float **outputs, VstInt32 sample
|
|||
X = bezF[bez_cycle]*bezFreqTrim;
|
||||
double CBLfreq = (bezF[bez_CL]*(1.0-X))+(bezF[bez_BL]*X);
|
||||
double BALfreq = (bezF[bez_BL]*(1.0-X))+(bezF[bez_AL]*X);
|
||||
inputSampleL = (bezF[bez_BL]+(CBLfreq*(1.0-X))+(BALfreq*X))*0.25;
|
||||
inputSampleL = (bezF[bez_BL]+(CBLfreq*(1.0-X))+(BALfreq*X))*0.5;
|
||||
double CBRfreq = (bezF[bez_CR]*(1.0-X))+(bezF[bez_BR]*X);
|
||||
double BARfreq = (bezF[bez_BR]*(1.0-X))+(bezF[bez_AR]*X);
|
||||
inputSampleR = (bezF[bez_BR]+(CBRfreq*(1.0-X))+(BARfreq*X))*0.25;
|
||||
inputSampleR = (bezF[bez_BR]+(CBRfreq*(1.0-X))+(BARfreq*X))*0.5;
|
||||
//filtering the reverb separately, after making it
|
||||
|
||||
inputSampleL = (inputSampleL * wet)+(drySampleL * (1.0-wet));
|
||||
|
|
@ -285,7 +450,8 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
derezFreq = 1.0 / bezFreqFraction;
|
||||
bezFreqTrim = 1.0-(derezFreq*bezFreqTrim);
|
||||
//the revision more accurately connects the bezier curves
|
||||
double wet = D;
|
||||
double wider = D*2.0;
|
||||
double wet = E;
|
||||
|
||||
while (--sampleFrames >= 0)
|
||||
{
|
||||
|
|
@ -301,13 +467,13 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
bez[bez_SampR] += (inputSampleR*attenuate*derez);
|
||||
if (bez[bez_cycle] > 1.0) { //hit the end point and we do a reverb sample
|
||||
bez[bez_cycle] = 0.0;
|
||||
inputSampleL = bez[bez_SampL];
|
||||
inputSampleR = bez[bez_SampR];
|
||||
double mainSampleL = bez[bez_SampL];
|
||||
double mainSampleR = bez[bez_SampR]; //begin primary reverb
|
||||
|
||||
a4AL[c4AL] = inputSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = inputSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = inputSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = inputSampleL + (f4DL * reg4n);
|
||||
a4AL[c4AL] = mainSampleL + (f4AL * reg4n);
|
||||
a4BL[c4BL] = mainSampleL + (f4BL * reg4n);
|
||||
a4CL[c4CL] = mainSampleL + (f4CL * reg4n);
|
||||
a4DL[c4DL] = mainSampleL + (f4DL * reg4n);
|
||||
|
||||
c4AL++; if (c4AL < 0 || c4AL > d4A) c4AL = 0;
|
||||
c4BL++; if (c4BL < 0 || c4BL > d4B) c4BL = 0;
|
||||
|
|
@ -319,10 +485,10 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
double o4CL = a4CL[c4CL-((c4CL > d4C)?d4C+1:0)];
|
||||
double o4DL = a4DL[c4DL-((c4DL > d4D)?d4D+1:0)];
|
||||
|
||||
a4DR[c4DR] = inputSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = inputSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = inputSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = inputSampleR + (f4PR * reg4n);
|
||||
a4DR[c4DR] = mainSampleR + (f4DR * reg4n);
|
||||
a4HR[c4HR] = mainSampleR + (f4HR * reg4n);
|
||||
a4LR[c4LR] = mainSampleR + (f4LR * reg4n);
|
||||
a4PR[c4PR] = mainSampleR + (f4PR * reg4n);
|
||||
|
||||
c4DR++; if (c4DR < 0 || c4DR > d4D) c4DR = 0;
|
||||
c4HR++; if (c4HR < 0 || c4HR > d4H) c4HR = 0;
|
||||
|
|
@ -442,8 +608,173 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
f4LR = o4OL - (o4ML + o4NL + o4PL);
|
||||
f4PR = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
inputSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
inputSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
mainSampleL = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
mainSampleR = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
|
||||
//we still have an untouched inputsample, turn it into dual mono
|
||||
//won't need to redeclare any of the o4 temp variables, just re-use
|
||||
|
||||
double dualmonoSampleL = bez[bez_SampR];
|
||||
double dualmonoSampleR = bez[bez_SampL];
|
||||
//workaround involves keeping the cross-matrix system,
|
||||
//but for initial layering, each side gets each version
|
||||
//making blends never quite line up as exactly the same.
|
||||
|
||||
b4AL[e4AL] = dualmonoSampleL + (g4AL * reg4n);
|
||||
b4BL[e4BL] = dualmonoSampleL + (g4BL * reg4n);
|
||||
b4CL[e4CL] = dualmonoSampleL + (g4CL * reg4n);
|
||||
b4DL[e4DL] = dualmonoSampleL + (g4DL * reg4n);
|
||||
|
||||
e4AL++; if (e4AL < 0 || e4AL > d4A) e4AL = 0;
|
||||
e4BL++; if (e4BL < 0 || e4BL > d4B) e4BL = 0;
|
||||
e4CL++; if (e4CL < 0 || e4CL > d4C) e4CL = 0;
|
||||
e4DL++; if (e4DL < 0 || e4DL > d4D) e4DL = 0;
|
||||
|
||||
o4AL = b4AL[e4AL-((e4AL > d4A)?d4A+1:0)];
|
||||
o4BL = b4BL[e4BL-((e4BL > d4B)?d4B+1:0)];
|
||||
o4CL = b4CL[e4CL-((e4CL > d4C)?d4C+1:0)];
|
||||
o4DL = b4DL[e4DL-((e4DL > d4D)?d4D+1:0)];
|
||||
|
||||
b4DR[e4DR] = dualmonoSampleR + (g4DR * reg4n);
|
||||
b4HR[e4HR] = dualmonoSampleR + (g4HR * reg4n);
|
||||
b4LR[e4LR] = dualmonoSampleR + (g4LR * reg4n);
|
||||
b4PR[e4PR] = dualmonoSampleR + (g4PR * reg4n);
|
||||
|
||||
e4DR++; if (e4DR < 0 || e4DR > d4D) e4DR = 0;
|
||||
e4HR++; if (e4HR < 0 || e4HR > d4H) e4HR = 0;
|
||||
e4LR++; if (e4LR < 0 || e4LR > d4L) e4LR = 0;
|
||||
e4PR++; if (e4PR < 0 || e4PR > d4P) e4PR = 0;
|
||||
|
||||
o4DR = b4DR[e4DR-((e4DR > d4D)?d4D+1:0)];
|
||||
o4HR = b4HR[e4HR-((e4HR > d4H)?d4H+1:0)];
|
||||
o4LR = b4LR[e4LR-((e4LR > d4L)?d4L+1:0)];
|
||||
o4PR = b4PR[e4PR-((e4PR > d4P)?d4P+1:0)];
|
||||
|
||||
//-------- one
|
||||
|
||||
b4EL[e4EL] = o4AL - (o4BL + o4CL + o4DL);
|
||||
b4FL[e4FL] = o4BL - (o4AL + o4CL + o4DL);
|
||||
b4GL[e4GL] = o4CL - (o4AL + o4BL + o4DL);
|
||||
b4HL[e4HL] = o4DL - (o4AL + o4BL + o4CL);
|
||||
|
||||
e4EL++; if (e4EL < 0 || e4EL > d4E) e4EL = 0;
|
||||
e4FL++; if (e4FL < 0 || e4FL > d4F) e4FL = 0;
|
||||
e4GL++; if (e4GL < 0 || e4GL > d4G) e4GL = 0;
|
||||
e4HL++; if (e4HL < 0 || e4HL > d4H) e4HL = 0;
|
||||
|
||||
o4EL = b4EL[e4EL-((e4EL > d4E)?d4E+1:0)];
|
||||
o4FL = b4FL[e4FL-((e4FL > d4F)?d4F+1:0)];
|
||||
o4GL = b4GL[e4GL-((e4GL > d4G)?d4G+1:0)];
|
||||
o4HL = b4HL[e4HL-((e4HL > d4H)?d4H+1:0)];
|
||||
|
||||
b4CR[e4CR] = o4DR - (o4HR + o4LR + o4PR);
|
||||
b4GR[e4GR] = o4HR - (o4DR + o4LR + o4PR);
|
||||
b4KR[e4KR] = o4LR - (o4DR + o4HR + o4PR);
|
||||
b4OR[e4OR] = o4PR - (o4DR + o4HR + o4LR);
|
||||
|
||||
e4CR++; if (e4CR < 0 || e4CR > d4C) e4CR = 0;
|
||||
e4GR++; if (e4GR < 0 || e4GR > d4G) e4GR = 0;
|
||||
e4KR++; if (e4KR < 0 || e4KR > d4K) e4KR = 0;
|
||||
e4OR++; if (e4OR < 0 || e4OR > d4O) e4OR = 0;
|
||||
|
||||
o4CR = b4CR[e4CR-((e4CR > d4C)?d4C+1:0)];
|
||||
o4GR = b4GR[e4GR-((e4GR > d4G)?d4G+1:0)];
|
||||
o4KR = b4KR[e4KR-((e4KR > d4K)?d4K+1:0)];
|
||||
o4OR = b4OR[e4OR-((e4OR > d4O)?d4O+1:0)];
|
||||
|
||||
//-------- two
|
||||
|
||||
b4IL[e4IL] = o4EL - (o4FL + o4GL + o4HL);
|
||||
b4JL[e4JL] = o4FL - (o4EL + o4GL + o4HL);
|
||||
b4KL[e4KL] = o4GL - (o4EL + o4FL + o4HL);
|
||||
b4LL[e4LL] = o4HL - (o4EL + o4FL + o4GL);
|
||||
|
||||
e4IL++; if (e4IL < 0 || e4IL > d4I) e4IL = 0;
|
||||
e4JL++; if (e4JL < 0 || e4JL > d4J) e4JL = 0;
|
||||
e4KL++; if (e4KL < 0 || e4KL > d4K) e4KL = 0;
|
||||
e4LL++; if (e4LL < 0 || e4LL > d4L) e4LL = 0;
|
||||
|
||||
o4IL = b4IL[e4IL-((e4IL > d4I)?d4I+1:0)];
|
||||
o4JL = b4JL[e4JL-((e4JL > d4J)?d4J+1:0)];
|
||||
o4KL = b4KL[e4KL-((e4KL > d4K)?d4K+1:0)];
|
||||
o4LL = b4LL[e4LL-((e4LL > d4L)?d4L+1:0)];
|
||||
|
||||
b4BR[e4BR] = o4CR - (o4GR + o4KR + o4OR);
|
||||
b4FR[e4FR] = o4GR - (o4CR + o4KR + o4OR);
|
||||
b4JR[e4JR] = o4KR - (o4CR + o4GR + o4OR);
|
||||
b4NR[e4NR] = o4OR - (o4CR + o4GR + o4KR);
|
||||
|
||||
e4BR++; if (e4BR < 0 || e4BR > d4B) e4BR = 0;
|
||||
e4FR++; if (e4FR < 0 || e4FR > d4F) e4FR = 0;
|
||||
e4JR++; if (e4JR < 0 || e4JR > d4J) e4JR = 0;
|
||||
e4NR++; if (e4NR < 0 || e4NR > d4N) e4NR = 0;
|
||||
|
||||
o4BR = b4BR[e4BR-((e4BR > d4B)?d4B+1:0)];
|
||||
o4FR = b4FR[e4FR-((e4FR > d4F)?d4F+1:0)];
|
||||
o4JR = b4JR[e4JR-((e4JR > d4J)?d4J+1:0)];
|
||||
o4NR = b4NR[e4NR-((e4NR > d4N)?d4N+1:0)];
|
||||
|
||||
//-------- three
|
||||
|
||||
b4ML[e4ML] = o4IL - (o4JL + o4KL + o4LL);
|
||||
b4NL[e4NL] = o4JL - (o4IL + o4KL + o4LL);
|
||||
b4OL[e4OL] = o4KL - (o4IL + o4JL + o4LL);
|
||||
b4PL[e4PL] = o4LL - (o4IL + o4JL + o4KL);
|
||||
|
||||
e4ML++; if (e4ML < 0 || e4ML > d4M) e4ML = 0;
|
||||
e4NL++; if (e4NL < 0 || e4NL > d4N) e4NL = 0;
|
||||
e4OL++; if (e4OL < 0 || e4OL > d4O) e4OL = 0;
|
||||
e4PL++; if (e4PL < 0 || e4PL > d4P) e4PL = 0;
|
||||
|
||||
o4ML = b4ML[e4ML-((e4ML > d4M)?d4M+1:0)];
|
||||
o4NL = b4NL[e4NL-((e4NL > d4N)?d4N+1:0)];
|
||||
o4OL = b4OL[e4OL-((e4OL > d4O)?d4O+1:0)];
|
||||
o4PL = b4PL[e4PL-((e4PL > d4P)?d4P+1:0)];
|
||||
|
||||
b4AR[e4AR] = o4BR - (o4FR + o4JR + o4NR);
|
||||
b4ER[e4ER] = o4FR - (o4BR + o4JR + o4NR);
|
||||
b4IR[e4IR] = o4JR - (o4BR + o4FR + o4NR);
|
||||
b4MR[e4MR] = o4NR - (o4BR + o4FR + o4JR);
|
||||
|
||||
e4AR++; if (e4AR < 0 || e4AR > d4A) e4AR = 0;
|
||||
e4ER++; if (e4ER < 0 || e4ER > d4E) e4ER = 0;
|
||||
e4IR++; if (e4IR < 0 || e4IR > d4I) e4IR = 0;
|
||||
e4MR++; if (e4MR < 0 || e4MR > d4M) e4MR = 0;
|
||||
|
||||
o4AR = b4AR[e4AR-((e4AR > d4A)?d4A+1:0)];
|
||||
o4ER = b4ER[e4ER-((e4ER > d4E)?d4E+1:0)];
|
||||
o4IR = b4IR[e4IR-((e4IR > d4I)?d4I+1:0)];
|
||||
o4MR = b4MR[e4MR-((e4MR > d4M)?d4M+1:0)];
|
||||
|
||||
//-------- four
|
||||
|
||||
g4DR = o4AR - (o4ER + o4IR + o4MR);
|
||||
g4HR = o4ER - (o4AR + o4IR + o4MR);
|
||||
g4LR = o4IR - (o4AR + o4ER + o4MR);
|
||||
g4PR = o4MR - (o4AR + o4ER + o4IR);
|
||||
|
||||
g4AL = o4ML - (o4NL + o4OL + o4PL);
|
||||
g4BL = o4NL - (o4ML + o4OL + o4PL);
|
||||
g4CL = o4OL - (o4ML + o4NL + o4PL);
|
||||
g4DL = o4PL - (o4ML + o4NL + o4OL);
|
||||
|
||||
dualmonoSampleR = (o4ML + o4NL + o4OL + o4PL)*0.125;
|
||||
dualmonoSampleL = (o4AR + o4ER + o4IR + o4MR)*0.125;
|
||||
//dual mono version is wider = 1.0 at the center
|
||||
//with mainsample 0.0 and 2.0 (only at the edges)
|
||||
//with mainsample out of phase when over 1.0
|
||||
//couldn't re-do the arrays perfectly, so instead
|
||||
//we keep exactly the same cross-matrix,
|
||||
//but we flip the sides we're using for initial reverb.
|
||||
//then, dualmono remains totally dualmono, and blend a bit in for wideness.
|
||||
|
||||
if (wider < 1.0) {
|
||||
inputSampleL = (dualmonoSampleL*wider) + (mainSampleL*(1.0-wider));
|
||||
inputSampleR = (dualmonoSampleR*wider) + (mainSampleR*(1.0-wider));
|
||||
} else {
|
||||
inputSampleL = (dualmonoSampleL*(2.0-wider)) + (mainSampleL*(wider-1.0));
|
||||
inputSampleR = (dualmonoSampleR*(2.0-wider)) + (-mainSampleR*(wider-1.0));
|
||||
}
|
||||
|
||||
bez[bez_CL] = bez[bez_BL];
|
||||
bez[bez_BL] = bez[bez_AL];
|
||||
|
|
@ -464,9 +795,8 @@ void VerbTiny::processDoubleReplacing(double **inputs, double **outputs, VstInt3
|
|||
inputSampleR = (bez[bez_BR]+(CBR*(1.0-X))+(BAR*X))*-0.25;
|
||||
|
||||
bezF[bez_cycle] += derezFreq;
|
||||
bezF[bez_SampL] += ((inputSampleL+bezF[bez_InL]) * derezFreq);
|
||||
bezF[bez_SampR] += ((inputSampleL+bezF[bez_InR]) * derezFreq);
|
||||
bezF[bez_InL] = inputSampleL; bezF[bez_InR] = inputSampleR;
|
||||
bezF[bez_SampL] += (inputSampleL * derezFreq);
|
||||
bezF[bez_SampR] += (inputSampleR * derezFreq);
|
||||
if (bezF[bez_cycle] > 1.0) { //hit the end point and we do a filter sample
|
||||
bezF[bez_cycle] = 0.0;
|
||||
bezF[bez_CL] = bezF[bez_BL];
|
||||
|
|
|
|||
1
what.txt
1
what.txt
|
|
@ -434,6 +434,7 @@ VariMu is a more organic variation on Pressure (a compressor)[coll=]
|
|||
Verbity is a dual-mono reverb, which uses feedforward reverb topology.[coll=]
|
||||
Verbity2 adds stereo crossmodulation and expands Verbity's feedforward reverb topology.[coll=Latest]
|
||||
VerbSixes is a calibrated reference reverb plugin for Householder matrices.[coll=Latest]
|
||||
VerbTiny is a classic artificial reverb that expands reverb shape.[coll=Basic,Recommended,Latest]
|
||||
Vibrato lets you vibrato, chorus, flange, and make odd FM noises.[coll=Basic,Recommended,Latest]
|
||||
VinylDither is a high-performance dither that converts digital noise to ‘groove noise’.[coll=]
|
||||
VoiceOfTheStarship is a deep noise tone source.[coll=Latest]
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue