Update to Latest Airwin

Author: baconpaul

libs/airwindows

@@ -0,0 +1,19 @@
+# Suzan is a new type of ladder filter.
+
+So a funny thing happened to me on the way to Dattorro…
+
+I was talking about the very simple state variable filter I made, Dattorro, and how it was very handy, could even substitute for a biquad filter according to Andy from Cytomic who's an eager advocate of these (as opposed to, say, a biquad filter of direct form 1), and how I'd come up with a twist on it using only a sin() function to do the unexpected thing of subtracting the distorted bandpass element FROM the lowpass, and how that had a neat tone I liked. The twist was new, and I was excited about the possibilities.
+
+Then, on a famously crotchety forum, a guy popped up to object… saying I shouldn't call it not a biquad. It's just an SVF and not direct form 1, but it's still a biquadratic filter. You could even have literal analog filters that are biquads. I had the language wrong and he apologized for the fact that this drove him up the wall.
+
+He's Antoine Portes, and he's writing an experimental book about filters called Working Class Filter Design. Biquadratic means the transfer function's denominator is a quadratic formula, another name for second order polynomial. He's been trying to do a really good Moog ladder, which apparently is more like fourth order, and he notes that we use Q for resonance, but there's another part that goes 1/(2*Q) and this doesn't have a consistent name. He's calling it Damping, but suggests if you don't like that you can call it Suzan for all the difference it'll make to him.
+
+Naturally, I was charmed though his math is over my foolish head :) and so, I got busy again, except it was with experimenting in code rather than figuring out the math of it. And I told him I'd name the filter, meant to be experiments on this fourth-order, Moog-flavored filter, 'Suzan' in his honor.
+
+And this is the result. It's a small stack of SVFs. The difference is, Antoine understandably is interested in representing these things in correct math, and doing sensible things at least some of the time. Me on the other hand… my whole deal is being able to try things that don't exist yet. By all rights the AIs should be paying me to come up with novel things for them (maybe there'll come a day when that's a reality).
+
+And so, Suzan is not two but three SVFs in series. And the SVFs are still normal, except I'm up to my Dattorro tricks but even worse. Stage A subtracts the bandpass of stage C. Stage B subtracts the bandpass of stage A… and stage C adds the bandpass of stage B. Oh, except they're all the sines of those bandpasses, and the first two are using half the amplitude of the bandpass, the final one which adds is using the full amplitude going into the sine function.
+
+I don't claim justification for this or an analysis of why it works. Swept way up high it can have high frequency instability when hit with full blast white noise, which I hope doesn't cause issues (I got it to where it was simply a boost but didn't blow up). I find it's a nice chunky resonant peak and even gives appropriate amounts of bass restriction when resonance is turned up… and the inappropriate use of feedback across the stages does a nice job of giving a colorful texture. One I am intimately familiar with both from records, and from owning everything from a MG-1 Concertmate to a Werkstatt to a Sub Phatty. But we're not calling it that, because it isn't one of those. It's Suzan, and it's trying to bring the right kind of mojo to my filter collection. I hope you like it :)
+
+

res/awpdoc/Suzan.txt

@@ -0,0 +1,160 @@
+/* ========================================
+ *  ADClip9 - ADClip9.h
+ *  Copyright (c) airwindows, Airwindows uses the MIT license
+ * ======================================== */
+
+#ifndef __ADClip9_H
+#include "ADClip9.h"
+#endif
+#include <cmath>
+#include <cstdlib>
+#include <algorithm>
+namespace airwinconsolidated::ADClip9 {
+
+AudioEffect* createEffectInstance(audioMasterCallback audioMaster) {return new ADClip9(audioMaster);}
+
+ADClip9::ADClip9(audioMasterCallback audioMaster) :
+    AudioEffectX(audioMaster, kNumPrograms, kNumParameters)
+{
+	A = 0.0;
+	B = 0.0;
+	C = 0.7;
+	D = 0.75;
+	E = 0.0;
+	
+	lastSampleL = 0.0;
+	wasPosClipL = false;
+	wasNegClipL = false;
+	lastSampleR = 0.0;
+	wasPosClipR = false;
+	wasNegClipR = false;
+	for (int x = 0; x < 17; x++) {intermediateL[x] = 0.0; intermediateR[x] = 0.0;}
+	for (int x = 0; x < 33; x++) {slewL[x] = 0.0; slewR[x] = 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
+}
+
+ADClip9::~ADClip9() {}
+VstInt32 ADClip9::getVendorVersion () {return 1000;}
+void ADClip9::setProgramName(char *name) {vst_strncpy (_programName, name, kVstMaxProgNameLen);}
+void ADClip9::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 ADClip9::setParameter(VstInt32 index, float value) {
+    switch (index) {
+        case kParamA: A = value; break;
+        case kParamB: B = value; break;
+        case kParamC: C = value; break;
+        case kParamD: D = value; break;
+        case kParamE: E = value; break;
+        default: break; // unknown parameter, shouldn't happen!
+    }
+}
+
+float ADClip9::getParameter(VstInt32 index) {
+    switch (index) {
+        case kParamA: return A; break;
+        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
+}
+
+void ADClip9::getParameterName(VstInt32 index, char *text) {
+    switch (index) {
+        case kParamA: vst_strncpy (text, "Boost", kVstMaxParamStrLen); break;
+		case kParamB: vst_strncpy (text, "Match", kVstMaxParamStrLen); break;
+		case kParamC: vst_strncpy (text, "Noise", kVstMaxParamStrLen); break;
+		case kParamD: vst_strncpy (text, "Ceiling", kVstMaxParamStrLen); break;
+		case kParamE: vst_strncpy (text, "Mode", kVstMaxParamStrLen); break;
+        default: break; // unknown parameter, shouldn't happen!
+    } //this is our labels for displaying in the VST host
+}
+
+void ADClip9::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: float2string (C, text, kVstMaxParamStrLen); break;
+        case kParamD: float2string (D, text, kVstMaxParamStrLen); break;
+        case kParamE: switch((VstInt32)( E * 2.999 )) {
+			case 0: vst_strncpy (text, "Boost", kVstMaxParamStrLen); break;
+			case 1: vst_strncpy (text, "Match", kVstMaxParamStrLen); break;
+			case 2: vst_strncpy (text, "ClipOnly", 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 ADClip9::getParameterLabel(VstInt32 index, char *text) {
+    switch (index) {
+        case kParamA: vst_strncpy (text, "dB", kVstMaxParamStrLen); break;
+        case kParamB: vst_strncpy (text, "dB", 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!
+    }
+}
+
+VstInt32 ADClip9::canDo(char *text) 
+{ return (_canDo.find(text) == _canDo.end()) ? -1: 1; } // 1 = yes, -1 = no, 0 = don't know
+
+bool ADClip9::getEffectName(char* name) {
+    vst_strncpy(name, "ADClip9", kVstMaxProductStrLen); return true;
+}
+
+VstPlugCategory ADClip9::getPlugCategory() {return kPlugCategEffect;}
+
+bool ADClip9::getProductString(char* text) {
+  	vst_strncpy (text, "airwindows ADClip9", kVstMaxProductStrLen); return true;
+}
+
+bool ADClip9::getVendorString(char* text) {
+  	vst_strncpy (text, "airwindows", kVstMaxVendorStrLen); return true;
+}
+bool ADClip9::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; }
+    case kParamC: { auto b = string2float(text, value); return b; break; }
+    case kParamD: { auto b = string2float(text, value); return b; break; }
+
+    }
+    return false;
+}
+bool ADClip9::canConvertParameterTextToValue(VstInt32 index) {
+    switch(index) {
+        case kParamA: return true;
+        case kParamB: return true;
+        case kParamC: return true;
+        case kParamD: return true;
+
+    }
+    return false;
+}
+} // end namespace

src/ModuleAdd.h

@@ -0,0 +1,87 @@
+/* ========================================
+ *  ADClip9 - ADClip9.h
+ *  Created 8/12/11 by SPIAdmin 
+ *  Copyright (c) Airwindows, Airwindows uses the MIT license
+ * ======================================== */
+
+#ifndef __ADClip9_ADClip9_H
+#define __ADClip9_ADClip9_H
+
+#ifndef __audioeffect__
+#include "../airwin_consolidated_base.h"
+#endif
+
+#include <set>
+#include <string>
+#include <math.h>
+
+namespace airwinconsolidated::ADClip9 {
+enum {
+	kParamA =0,
+	kParamB =1,
+	kParamC =2,
+	kParamD =3,
+	kParamE =4,
+  kNumParameters = 5
+}; //
+
+const int kNumPrograms = 0;
+const int kNumInputs = 2;
+const int kNumOutputs = 2;
+const unsigned long kUniqueId = 'adct';    //Change this to what the AU identity is!
+
+class ADClip9 : 
+    public AudioEffectX 
+{
+public:
+    ADClip9(audioMasterCallback audioMaster);
+    ~ADClip9();
+    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;
+    
+    float A;
+    float B;
+    float C;
+    float D;
+    float E;
+
+	double lastSampleL;
+	double lastDryL;
+	double intermediateL[18];
+	double slewL[34];
+	bool wasPosClipL;
+	bool wasNegClipL;
+
+	double lastSampleR;
+	double lastDryR;
+	double intermediateR[18];
+	double slewR[34];
+	bool wasPosClipR;
+	bool wasNegClipR;
+	
+	uint32_t fpdL;
+	uint32_t fpdR;
+	//default stuff
+};
+
+#endif
+} // end namespace