Update to Latest Airwin

res/awpdoc/Flutter.txt

@@ -1,4 +1,4 @@
-# Flutter is the most recent Airwindows flutter, standalone.
+# Flutter is the flutter from ToTape6, standalone.
 
 This is by request. Sometimes you want stuff to go a little unsteady and wobbly, but you don't want a full-on tape emulation with, like, dubly and everything. (you don't do heavy metal in dubly, you know.) And so, here is Flutter, standalone!
 
@@ -8,4 +8,5 @@ In practice, you get a flutter/warble that stays pretty subtle right up to when
 
 Sometimes it's handy to be able to take something ultra-pure, like a bell or electric piano, and destabilize it without any tonal adjustment at all. Retain the chime but add that bit of drift. I hope you like Flutter.
 
+
 

res/awpdoc/Flutter2.txt

@@ -0,0 +1,15 @@
+# Flutter2 is the flutter from ToTape7, standalone.
+
+It's time for a new ToTape (actively being worked on, and yes you're still getting more reverbs and ConsoleX and all that) and it turns out that when I went back in to revise the tape flutter algorithm, live on stream, the work went so well that I COULD NOT WAIT. I was basically looking to address how, in the original Flutter, it slows as well as becoming gentler when you turn it down, and I thought that for 2024 ToTape7 it might be worth bringing in extra controls just to give people more power over their flutter effect.
+
+And then when I improved the algorithm and discovered that, cranked up, it does everything from shortwave radio impressions to Cookie Monsterification, that was exciting.
+
+But not as exciting as when I learned that if you crank it way up and make the flutterspeed REALLY slow, you get a heavy guitar doubler. Suddenly, I had a really decent fake hard-panned, still weirdly tight, doubled guitar that sounded fantastic apart from occasionally (and understandably) going mono on me.
+
+Enjoy Flutter2, it's going to be in the new ToTape7 when that's done. It means you have everything from reel-to-reel (less flutter than 0.5 for that), to cassette, to Roland Space Echo, to VHS, to cassette that's been yanked out of the shell and jumped up and down on for a bit and put back and attempted to be played.
+
+Also, here's my tip: rather than track one guitar and try to make it two with Flutter2, have you considered tracking three guitars and trying to make it five? If you do two real doubletracks, and then one 'thickener' to put in the center, and THEN add Flutter2 to that center track and use the dry/wet control, you can very definitely mimic FIVE guitar tracks for the price of three, and if center/flutter2 is slightly quieter it won't stick out that much when Flutter starts to hint at mono occasionally, because there's meant to be a mono track. You can lean on the Flutter2 a bit harder if you want to go superwide.
+
+Oh, which reminds me, there's also a new Srsly coming… but more on that later. Enjoy Flutter2 :)
+
+

src/autogen_airwin/CMakeLists.txt

@@ -337,6 +337,8 @@ set(AIRWIN_SOURCES
    src/autogen_airwin/FloorProc.cpp
    src/autogen_airwin/Flutter.cpp
    src/autogen_airwin/FlutterProc.cpp
+   src/autogen_airwin/Flutter2.cpp
+   src/autogen_airwin/Flutter2Proc.cpp
    src/autogen_airwin/Focus.cpp
    src/autogen_airwin/FocusProc.cpp
    src/autogen_airwin/Fracture.cpp

src/autogen_airwin/Flutter2.cpp

@@ -0,0 +1,139 @@
+/* ========================================
+ *  Flutter2 - Flutter2.h
+ *  Copyright (c) airwindows, Airwindows uses the MIT license
+ * ======================================== */
+
+#ifndef __Flutter2_H
+#include "Flutter2.h"
+#endif
+#include <cmath>
+#include <algorithm>
+namespace airwinconsolidated::Flutter2 {
+
+AudioEffect* createEffectInstance(audioMasterCallback audioMaster) {return new Flutter2(audioMaster);}
+
+Flutter2::Flutter2(audioMasterCallback audioMaster) :
+    AudioEffectX(audioMaster, kNumPrograms, kNumParameters)
+{
+	A = 0.5;
+	B = 0.5;
+	C = 1.0;
+
+	for (int temp = 0; temp < 1001; temp++) {dL[temp] = 0.0;dR[temp] = 0.0;}
+	sweepL = M_PI;
+	sweepR = M_PI;
+	nextmaxL = 0.5;	
+	nextmaxR = 0.5;
+
+	gcount = 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
+}
+
+Flutter2::~Flutter2() {}
+VstInt32 Flutter2::getVendorVersion () {return 1000;}
+void Flutter2::setProgramName(char *name) {vst_strncpy (_programName, name, kVstMaxProgNameLen);}
+void Flutter2::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 Flutter2::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 Flutter2::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 Flutter2::getParameterName(VstInt32 index, char *text) {
+    switch (index) {
+        case kParamA: vst_strncpy (text, "Flutter", kVstMaxParamStrLen); break;
+		case kParamB: vst_strncpy (text, "Speed", kVstMaxParamStrLen); break;
+		case kParamC: vst_strncpy (text, "Dry/Wet", kVstMaxParamStrLen); break;
+        default: break; // unknown parameter, shouldn't happen!
+    } //this is our labels for displaying in the VST host
+}
+
+void Flutter2::getParameterDisplay(VstInt32 index, char *text) {
+    switch (index) {
+        case kParamA: float2string (A, text, kVstMaxParamStrLen); break;
+        case kParamB: float2string (B, text, kVstMaxParamStrLen); break;
+        case kParamC: float2string (C, text, kVstMaxParamStrLen); break;
+        default: break; // unknown parameter, shouldn't happen!
+	} //this displays the values and handles 'popups' where it's discrete choices
+}
+
+void Flutter2::getParameterLabel(VstInt32 index, char *text) {
+    switch (index) {
+        case kParamA: vst_strncpy (text, "", kVstMaxParamStrLen); break;
+        case kParamB: vst_strncpy (text, "", kVstMaxParamStrLen); break;
+        case kParamC: vst_strncpy (text, "", kVstMaxParamStrLen); break;
+		default: break; // unknown parameter, shouldn't happen!
+    }
+}
+
+VstInt32 Flutter2::canDo(char *text) 
+{ return (_canDo.find(text) == _canDo.end()) ? -1: 1; } // 1 = yes, -1 = no, 0 = don't know
+
+bool Flutter2::getEffectName(char* name) {
+    vst_strncpy(name, "Flutter2", kVstMaxProductStrLen); return true;
+}
+
+VstPlugCategory Flutter2::getPlugCategory() {return kPlugCategEffect;}
+
+bool Flutter2::getProductString(char* text) {
+  	vst_strncpy (text, "airwindows Flutter2", kVstMaxProductStrLen); return true;
+}
+
+bool Flutter2::getVendorString(char* text) {
+  	vst_strncpy (text, "airwindows", kVstMaxVendorStrLen); return true;
+}
+bool Flutter2::parameterTextToValue(VstInt32 index, const char *text, float &value) {
+    switch(index) {
+    case kParamA: { auto b = string2float(text, value); return b; break; }
+    case kParamB: { auto b = string2float(text, value); return b; break; }
+    case kParamC: { auto b = string2float(text, value); return b; break; }
+
+    }
+    return false;
+}
+bool Flutter2::canConvertParameterTextToValue(VstInt32 index) {
+    switch(index) {
+        case kParamA: return true;
+        case kParamB: return true;
+        case kParamC: return true;
+
+    }
+    return false;
+}
+} // end namespace

src/autogen_airwin/Flutter2.h

@@ -0,0 +1,78 @@
+/* ========================================
+ *  Flutter2 - Flutter2.h
+ *  Created 8/12/11 by SPIAdmin 
+ *  Copyright (c) Airwindows, Airwindows uses the MIT license
+ * ======================================== */
+
+#ifndef __Flutter2_Flutter2_H
+#define __Flutter2_Flutter2_H
+
+#ifndef __audioeffect__
+#include "../airwin_consolidated_base.h"
+#endif
+
+#include <set>
+#include <string>
+#include <math.h>
+
+namespace airwinconsolidated::Flutter2 {
+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 = 'fluu';    //Change this to what the AU identity is!
+
+class Flutter2 : 
+    public AudioEffectX 
+{
+public:
+    Flutter2(audioMasterCallback audioMaster);
+    ~Flutter2();
+    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;
+
+	double dL[1002];
+	double dR[1002];
+	double sweepL;
+	double sweepR;
+	double nextmaxL;
+	double nextmaxR;
+
+	int gcount;		
+
+	uint32_t fpdL;
+	uint32_t fpdR;
+	//default stuff
+};
+
+#endif
+} // end namespace