Update to Latest Airwin

res/awpdoc/kCathedral2.txt

@@ -0,0 +1,17 @@
+# kCathedral2 is a giant reverby space modeled after the Bricasti Cathedral.
+
+Here we go: this should do nicely.
+
+This is still a 5x5 Householder matrix like the last time, but that's about the only similarity, and it's not at all the same matrix as last time. I am keeping that as kCathedral because I know full well that people find uses for things, but you can hear pretty plainly in my video on kCathedral2 that this is in another league (as they will all be, going forward).
+
+How was that done? A lot of it was time spent generating possible reverb matrices. There's a wide array of ways to evaluate how those become reverbs, none of which existed when I made the original kCathedral. I knew what I wanted but I had no way to measure it… and no way to generate thousands, millions, billions of possible options and automate the process of throwing out the metallic or lame ones. And that changed, over months of work on the tools.
+
+There's also new things that didn't exist in the more purist, uncompromising kCathedral. The new one uses one of my reverb delays differently, by turning it into a single solitary allpass (well, two, one per channel) and also adding the very subtlest of modulation to just that one allpass (not inside it, as a separate effect). None of this was present in the original, but even though it's only the tiniest amount, it's felt.
+
+But most of all, this time around it's using a completely different approach to early reflections. The real Bricasti Cathedral uses early reflections so strong I mistook them for dry signal being let in. Original kCathedral used a 3x3 matrix, very gingerly, trying not to be obvious because I thought I was hearing dry energy off the Bricasti, therefore the early reflections had to be much quieter, right? kCathedral2 uses a 4x4 matrix… which means it's able to literally use a patch from ClearCoat/CloudCoat, except without regeneration (the sound literally bounces away into the cathedral and doesn't even enter the deep reverb field). That's early reflections that can stand alone as their own reverb.
+
+It's subtle, but it's also where I was able to step away from the Bricasti sound and try to establish my own. I think you'll find that the deep room tone is about the same, and the depth of space, but I want those early reflections to be a lot more diffuse (but NOT allpassy), so I've scaled them up and spread them out. It should sound more like detail in the actual room rather than an obvious back wall, which I think will be more useful for how I'll be using it. And I've got a lot closer to that textural butter-sound of the real Bricasti, while retaining some of my own goals for the project.
+
+Welcome to kCathedral2. Oops, I did it again (this time more like what I intended for the first time). Thanks to my Patreon patrons, who are literally the reason I can persist at goals like this, and without whom I might have to stop halfway and not get to stuff like this. Hope you like it!
+
+

src/autogen_airwin/ADClip8.cpp

@@ -0,0 +1,146 @@
+/* ========================================
+ *  ADClip8 - ADClip8.h
+ *  Copyright (c) airwindows, Airwindows uses the MIT license
+ * ======================================== */
+
+#ifndef __ADClip8_H
+#include "ADClip8.h"
+#endif
+namespace airwin2rack::ADClip8 {
+
+AudioEffect* createEffectInstance(audioMasterCallback audioMaster) {return new ADClip8(audioMaster);}
+
+ADClip8::ADClip8(audioMasterCallback audioMaster) :
+    AudioEffectX(audioMaster, kNumPrograms, kNumParameters)
+{
+	A = 0.0;
+	B = 0.883;
+	C = 0.0;
+	for (int stage = 0; stage < 8; stage++) {
+		lastSampleL[stage] = 0.0;
+		lastSampleR[stage] = 0.0;
+		wasPosClipL[stage] = false;
+		wasPosClipR[stage] = false;
+		wasNegClipL[stage] = false;
+		wasNegClipR[stage] = false;
+		for (int x = 0; x < 16; x++) {intermediateL[x][stage] = 0.0;intermediateR[x][stage] = 0.0;}
+	}
+
+	fpdL = 1.0; while (fpdL < 16386) fpdL = rand()*UINT32_MAX;
+	fpdR = 1.0; while (fpdR < 16386) fpdR = rand()*UINT32_MAX;
+	//this is reset: values being initialized only once. Startup values, whatever they are.
+
+    _canDo.insert("plugAsChannelInsert"); // plug-in can be used as a channel insert effect.
+    _canDo.insert("plugAsSend"); // plug-in can be used as a send effect.
+    _canDo.insert("x2in2out"); 
+    setNumInputs(kNumInputs);
+    setNumOutputs(kNumOutputs);
+    setUniqueID(kUniqueId);
+    canProcessReplacing();     // supports output replacing
+    canDoubleReplacing();      // supports double precision processing
+	programsAreChunks(true);
+    vst_strncpy (_programName, "Default", kVstMaxProgNameLen); // default program name
+}
+
+ADClip8::~ADClip8() {}
+VstInt32 ADClip8::getVendorVersion () {return 1000;}
+void ADClip8::setProgramName(char *name) {vst_strncpy (_programName, name, kVstMaxProgNameLen);}
+void ADClip8::getProgramName(char *name) {vst_strncpy (name, _programName, kVstMaxProgNameLen);}
+//airwindows likes to ignore this stuff. Make your own programs, and make a different plugin rather than
+//trying to do versioning and preventing people from using older versions. Maybe they like the old one!
+
+static float pinParameter(float data)
+{
+	if (data < 0.0f) return 0.0f;
+	if (data > 1.0f) return 1.0f;
+	return data;
+}
+
+void ADClip8::setParameter(VstInt32 index, float value) {
+    switch (index) {
+        case kParamA: A = value; break;
+        case kParamB: B = value; break;
+        case kParamC: C = value; break;
+        default: break; // unknown parameter, shouldn't happen!
+    }
+}
+
+float ADClip8::getParameter(VstInt32 index) {
+    switch (index) {
+        case kParamA: return A; break;
+        case kParamB: return B; break;
+        case kParamC: return C; break;
+		default: break; // unknown parameter, shouldn't happen!
+    } return 0.0; //we only need to update the relevant name, this is simple to manage
+}
+
+void ADClip8::getParameterName(VstInt32 index, char *text) {
+    switch (index) {
+        case kParamA: vst_strncpy (text, "Boost", kVstMaxParamStrLen); break;
+		case kParamB: vst_strncpy (text, "Ceiling", kVstMaxParamStrLen); break;
+		case kParamC: vst_strncpy (text, "Mode", kVstMaxParamStrLen); break;
+        default: break; // unknown parameter, shouldn't happen!
+    } //this is our labels for displaying in the VST host
+}
+
+void ADClip8::getParameterDisplay(VstInt32 index, char *text) {
+    switch (index) {
+        case kParamA: float2string (A*18.0, text, kVstMaxParamStrLen); break;
+        case kParamB: float2string (B, text, kVstMaxParamStrLen); break;
+        case kParamC: switch((VstInt32)( C * 7.999 )) //0 to almost edge of # of params
+		{case 0: vst_strncpy (text, "Normal", kVstMaxParamStrLen); break;
+			case 1: vst_strncpy (text, "Atten", kVstMaxParamStrLen); break;
+			case 2: vst_strncpy (text, "Clips", kVstMaxParamStrLen); break;
+			case 3: vst_strncpy (text, "Afterbr", kVstMaxParamStrLen); break;
+			case 4: vst_strncpy (text, "Explode", kVstMaxParamStrLen); break;
+			case 5: vst_strncpy (text, "Nuke", kVstMaxParamStrLen); break;
+			case 6: vst_strncpy (text, "Apocaly", kVstMaxParamStrLen); break;
+			case 7: vst_strncpy (text, "Apothes", kVstMaxParamStrLen); break;
+			default: break; // unknown parameter, shouldn't happen!
+		} break;
+        default: break; // unknown parameter, shouldn't happen!
+	} //this displays the values and handles 'popups' where it's discrete choices
+}
+
+void ADClip8::getParameterLabel(VstInt32 index, char *text) {
+    switch (index) {
+        case kParamA: vst_strncpy (text, "dB", kVstMaxParamStrLen); break;
+        case kParamB: vst_strncpy (text, "", kVstMaxParamStrLen); break;
+        case kParamC: vst_strncpy (text, "", kVstMaxParamStrLen); break;
+		default: break; // unknown parameter, shouldn't happen!
+    }
+}
+
+VstInt32 ADClip8::canDo(char *text) 
+{ return (_canDo.find(text) == _canDo.end()) ? -1: 1; } // 1 = yes, -1 = no, 0 = don't know
+
+bool ADClip8::getEffectName(char* name) {
+    vst_strncpy(name, "ADClip8", kVstMaxProductStrLen); return true;
+}
+
+VstPlugCategory ADClip8::getPlugCategory() {return kPlugCategEffect;}
+
+bool ADClip8::getProductString(char* text) {
+  	vst_strncpy (text, "airwindows ADClip8", kVstMaxProductStrLen); return true;
+}
+
+bool ADClip8::getVendorString(char* text) {
+  	vst_strncpy (text, "airwindows", kVstMaxVendorStrLen); return true;
+}
+bool ADClip8::parameterTextToValue(VstInt32 index, const char *text, float &value) {
+    switch(index) {
+    case kParamA: { auto b = string2float(text, value); if (b) { value = value / (18.0); } return b; break; }
+    case kParamB: { auto b = string2float(text, value); return b; break; }
+
+    }
+    return false;
+}
+bool ADClip8::canConvertParameterTextToValue(VstInt32 index) {
+    switch(index) {
+        case kParamA: return true;
+        case kParamB: return true;
+
+    }
+    return false;
+}
+} // end namespace

src/autogen_airwin/ADClip8.h

@@ -0,0 +1,78 @@
+/* ========================================
+ *  ADClip8 - ADClip8.h
+ *  Created 8/12/11 by SPIAdmin 
+ *  Copyright (c) Airwindows, Airwindows uses the MIT license
+ * ======================================== */
+
+#ifndef __ADClip8_ADClip8_H
+#define __ADClip8_ADClip8_H
+
+#ifndef __audioeffect__
+#include "../airwin2rackbase.h"
+#endif
+
+#include <set>
+#include <string>
+#include <math.h>
+
+namespace airwin2rack::ADClip8 {
+enum {
+	kParamA = 0,
+	kParamB = 1,
+	kParamC = 2,
+  kNumParameters = 3
+}; //
+
+const int kNumPrograms = 0;
+const int kNumInputs = 2;
+const int kNumOutputs = 2;
+const unsigned long kUniqueId = 'adcs';    //Change this to what the AU identity is!
+
+class ADClip8 : 
+    public AudioEffectX 
+{
+public:
+    ADClip8(audioMasterCallback audioMaster);
+    ~ADClip8();
+    virtual bool getEffectName(char* name);                       // The plug-in name
+    virtual VstPlugCategory getPlugCategory();                    // The general category for the plug-in
+    virtual bool getProductString(char* text);                    // This is a unique plug-in string provided by Steinberg
+    virtual bool getVendorString(char* text);                     // Vendor info
+    virtual VstInt32 getVendorVersion();                          // Version number
+    virtual void processReplacing (float** inputs, float** outputs, VstInt32 sampleFrames);
+    virtual void processDoubleReplacing (double** inputs, double** outputs, VstInt32 sampleFrames);
+    virtual void getProgramName(char *name);                      // read the name from the host
+    virtual void setProgramName(char *name);                      // changes the name of the preset displayed in the host
+    virtual float getParameter(VstInt32 index);                   // get the parameter value at the specified index
+    virtual void setParameter(VstInt32 index, float value);       // set the parameter at index to value
+    virtual void getParameterLabel(VstInt32 index, char *text);  // label for the parameter (eg dB)
+    virtual void getParameterName(VstInt32 index, char *text);    // name of the parameter
+    virtual void getParameterDisplay(VstInt32 index, char *text); // text description of the current value    
+    // Added by the perl as inverses
+    virtual bool parameterTextToValue(VstInt32 index, const char *text, float &value);
+    virtual bool canConvertParameterTextToValue(VstInt32 index);
+    virtual VstInt32 canDo(char *text);
+private:
+    char _programName[kVstMaxProgNameLen + 1];
+    std::set< std::string > _canDo;
+
+	uint32_t fpdL;
+	uint32_t fpdR;
+	//default stuff
+
+	double lastSampleL[8];
+	double intermediateL[16][8];
+	bool wasPosClipL[8];
+	bool wasNegClipL[8];
+	double lastSampleR[8];
+	double intermediateR[16][8];
+	bool wasPosClipR[8];
+	bool wasNegClipR[8];
+
+    float A;
+    float B;
+    float C;
+};
+
+#endif
+} // end namespace