From 8a4bca986c57062e96f1e58281b3eff52a856ee6 Mon Sep 17 00:00:00 2001
From: rekado <rekado@elephly.net>
Date: Tue, 6 Sep 2016 22:13:03 +0200
Subject: Initial commit.

---
 objects/faust/moog_vcf.axo | 205 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 205 insertions(+)
 create mode 100644 objects/faust/moog_vcf.axo

(limited to 'objects/faust/moog_vcf.axo')

diff --git a/objects/faust/moog_vcf.axo b/objects/faust/moog_vcf.axo
new file mode 100644
index 0000000..8abb697
--- /dev/null
+++ b/objects/faust/moog_vcf.axo
@@ -0,0 +1,205 @@
+<objdefs>
+   <obj.normal id="moog_vcf" uuid="9329f089dced01ba64f7e22ac77fd78fbec47db9" sha="6b8d84e43d5934e94f32e1d50318f8feede69769">
+   <sDescription>Moog VCF (from Faust)</sDescription>
+      <author>Ricardo Wurmus</author>
+      <license>GPL</license>
+      <helpPatch>filter.axh</helpPatch>
+      <includes>
+        <include>math.h</include>
+      </includes>
+      <inlets>
+         <frac32buffer name="in" description="filter input"/>
+      </inlets>
+      <outlets>
+         <frac32buffer name="out" description="filter output"/>
+      </outlets>
+      <displays/>
+      <attribs/>
+      <code.declaration><![CDATA[
+            // convert float to fixed point notation
+            // * take absolute value
+            // * multiply with constant to keep precision;
+            //   to get a fixed point at x:y we multiply by 2^y,
+            //   e.g. for 24:8 (24 significant bits before decimal point)
+            //   we multiply f by 2^8 (1<<8).
+            // * truncate and cast to int32_t
+            // * invert bits if negative
+            int32_t floatToFrac32(float f) {
+              // was 1 000 000 000 and then >> 2
+              // now is 2^27 = 134 217 728
+              // 2^32 = 4 294 967 296
+              // 2^29 = 536 870 912 (3:29)
+              int32_t preout = int32_t(((f < 0) ? (-f) : f) * (1<<29));
+              return ((f < 0) ? ~preout : preout);
+            }
+            // convert fixed point to float
+            // * invert bits if sign bit is set (0x08000000, or (1<<27))
+            // * cast int to float
+            // * divide by constant to shift decimal point
+            // * multiply by -1 if sign bit was set
+            float frac32ToFloat(int32_t frac) {
+              bool neg = (((1<<27) & frac) != 0);
+              float res = (float)(neg ? frac : ~frac);
+              res = res / (float(1<<29));
+              return (neg ? (-1 * res) : res);
+            }
+
+
+	float 	fslider0;
+    float 	fslider1;
+	float 	fslider2;
+  	float 	fcheckbox0;
+	float 	fcheckbox1;
+	float 	fcheckbox2;
+
+  	float 	fRec0[2];
+	float 	fRec1[2];
+   	float 	fRec2[2];
+	float 	fRec3[2];
+  	float 	fRec4[2];
+	float 	fRec5[2];
+   	float 	fRec6[3];
+	float 	fRec7[3];
+	float 	fRec8[2];
+   	float 	fRec10[2];
+	float 	fRec11[2];
+	float 	fRec13[2];
+	float 	fRec14[2];
+
+	float 	fConst1;
+	float 	fConst2;
+    float   fSqrtTwo;
+    inline float faustpower2(float x) {
+      return powf(x,2);
+    }
+    inline float faustpower4(float x) {
+      return powf(x,4);
+    }
+
+    // template <int N> inline float faustpower(float x)          { return powf(x,N); } 
+    // template <int N> inline double faustpower(double x)        { return pow(x,N); }
+    // template <int N> inline int faustpower(int x)              { return faustpower<N/2>(x) * faustpower<N-N/2>(x); } 
+    // template <> 	 inline int faustpower<0>(int x)            { return 1; }
+    // template <> 	 inline int faustpower<1>(int x)            { return x; }
+]]></code.declaration>
+      <code.init><![CDATA[
+		fConst1 = ((2 * PI_F) / float(SAMPLERATE));
+   		fConst2 = (PI_F / float(SAMPLERATE));
+        fSqrtTwo = 1.4142135623730951f;
+		fcheckbox0 = 0.0;
+   		fcheckbox1 = 0.0;
+		fcheckbox2 = 0.0;
+  		fslider0 = 25.0f;
+   		fslider1 = 0.9f;
+		fslider2 = 5.0f;
+
+        for (int i=0; i<2; i++) fRec0[i] = 0;
+		for (int i=0; i<2; i++) fRec1[i] = 0;
+   		for (int i=0; i<2; i++) fRec2[i] = 0;
+  		for (int i=0; i<2; i++) fRec3[i] = 0;
+   		for (int i=0; i<2; i++) fRec4[i] = 0;
+		for (int i=0; i<2; i++) fRec5[i] = 0;
+		for (int i=0; i<3; i++) fRec6[i] = 0;
+		for (int i=0; i<3; i++) fRec7[i] = 0;
+		for (int i=0; i<2; i++) fRec8[i] = 0;
+		for (int i=0; i<2; i++) fRec10[i] = 0;
+		for (int i=0; i<2; i++) fRec11[i] = 0;
+		for (int i=0; i<2; i++) fRec13[i] = 0;
+		for (int i=0; i<2; i++) fRec14[i] = 0;
+
+]]></code.init>
+      <code.krate><![CDATA[
+		float 	fSlow0 = (0.4400000000000004f * powf(2.0f,(0.08333333333333333f * (float(fslider0) - 49.0f))));
+		int 	iSlow1 = int(float(fcheckbox0));
+		float 	fSlow2 = float(fslider1);
+		float 	fSlow3 = (0 - (4.0f * fmaxf((float)0, fminf(faustpower4(fSlow2), 0.999999f))));
+		float 	fSlow4 = fminf(1.412799348810722f, (fSqrtTwo * fSlow2));
+		float 	fSlow5 = (fSqrtTwo * fSlow4);
+		float 	fSlow6 = 2 - fSlow5;
+		float 	fSlow7 = 1 + (fSlow4 * (fSlow4 - fSqrtTwo));
+		float 	fSlow8 = 2 + fSlow5;
+		float 	fSlow9 = 1 + (fSlow4 * (fSqrtTwo + fSlow4));
+		float 	fSlow10 = 2 * fSlow2;
+		float 	fSlow11 = 2 - fSlow10;
+		float 	fSlow12 = faustpower2((1.412799348810722f * fSlow2));
+		float 	fSlow13 = ((1 + fSlow12) - fSlow10);
+		float 	fSlow14 = (2 + fSlow10);
+		float 	fSlow15 = (1 + (fSlow10 + fSlow12));
+		int 	iSlow16 = int(float(fcheckbox1));
+		int 	iSlow17 = int(float(fcheckbox2));
+		float 	fSlow18 = (0.001f * powf(10,(0.05f * float(fslider2))));
+		//const int32_t* input0 = inlet_in;
+		int32_t* output0 = outlet_out;
+		for (int i=0; i<BUFSIZE; i++) {
+			fRec1[0] = (fSlow0 + (0.999f * fRec1[1]));
+			float fTemp0 = (fConst1 * fRec1[0]);
+			float fTemp1 = (1.0f - fTemp0);
+			float fTemp2 = frac32ToFloat(inlet_in[i]);
+			float fTemp3 = ((iSlow1)?0:fTemp2);
+			fRec5[0] = ((fSlow3 * fRec0[1]) + (fTemp3 + (fTemp1 * fRec5[1])));
+			fRec4[0] = (fRec5[0] + (fTemp1 * fRec4[1]));
+			fRec3[0] = (fRec4[0] + (fTemp1 * fRec3[1]));
+			fRec2[0] = (fRec3[0] + (fRec2[1] * fTemp1));
+			fRec0[0] = (fRec2[0] * powf(fTemp0,4.0f));
+			float fTemp4 = tanf((fConst2 * fmaxf((float)20, fminf((float)10000, fRec1[0]))));
+			float fTemp5 = (1.0f / fTemp4);
+			float fTemp6 = (fSlow7 + ((fSlow6 + fTemp5) / fTemp4));
+			float fTemp7 = (1.0f / faustpower2(fTemp4));
+			float fTemp8 = (fSlow9 + ((fSlow8 + fTemp5) / fTemp4));
+			fRec7[0] = (fTemp3 - (((fRec7[2] * (fSlow9 + ((fTemp5 - fSlow8) / fTemp4))) + (2 * (fRec7[1] * (fSlow9 - fTemp7)))) / fTemp8));
+			fRec6[0] = (((fRec7[2] + (fRec7[0] + (2.0f * fRec7[1]))) / fTemp8) - (((fRec6[2] * (fSlow7 + ((fTemp5 - fSlow6) / fTemp4))) + (2 * (fRec6[1] * (fSlow7 - fTemp7)))) / fTemp6));
+			float fTemp9 = tanf((fConst2 * fmaxf(fRec1[0], (float)20)));
+			float fTemp10 = (1.0f / fTemp9);
+			float fTemp11 = (fSlow13 + ((fSlow11 + fTemp10) / fTemp9));
+			float fTemp12 = ((fSlow13 + ((fTemp10 - fSlow11) / fTemp9)) / fTemp11);
+			float fTemp13 = (1.0f / faustpower2(fTemp9));
+			float fTemp14 = (fSlow13 - fTemp13);
+			float fTemp15 = fmaxf(-0.9999f, fminf(0.9999f, (2 * (fTemp14 / (fTemp11 * (1 + fTemp12))))));
+			float fTemp16 = (1 - faustpower2(fTemp15));
+			float fTemp17 = fmaxf(-0.9999f, fminf(0.9999f, fTemp12));
+			float fTemp18 = (1 - faustpower2(fTemp17));
+			float fTemp19 = sqrtf(fTemp18);
+			float fTemp20 = (2.0f - (2.0f * (fTemp14 / fTemp11)));
+			float fTemp21 = sqrtf(fmaxf((float)0, fTemp16));
+			float fTemp22 = (fSlow15 + ((fSlow14 + fTemp10) / fTemp9));
+			float fTemp23 = sqrtf(fmaxf((float)0, fTemp18));
+			float fTemp24 = ((fSlow15 + ((fTemp10 - fSlow14) / fTemp9)) / fTemp22);
+			float fTemp25 = (fSlow15 - fTemp13);
+			float fTemp26 = fmaxf(-0.9999f, fminf(0.9999f, (2 * (fTemp25 / (fTemp22 * (1 + fTemp24))))));
+			float fTemp27 = (1 - faustpower2(fTemp26));
+			float fTemp28 = fmaxf(-0.9999f, fminf(0.9999f, fTemp24));
+			float fTemp29 = (1 - faustpower2(fTemp28));
+			float fTemp30 = sqrtf(fTemp29);
+			float fTemp31 = (2.0f - (2.0f * (fTemp25 / fTemp22)));
+			float fTemp32 = sqrtf(fmaxf((float)0, fTemp27));
+			float fTemp33 = sqrtf(fmaxf((float)0, fTemp29));
+			float fTemp34 = ((fRec11[1] * (0 - fTemp28)) + (fTemp3 * fTemp33));
+			fRec13[0] = ((fRec13[1] * (0 - fTemp26)) + (fTemp34 * fTemp32));
+			fRec11[0] = ((fTemp34 * fTemp26) + (fRec13[1] * fTemp32));
+			float 	fRec12 = fRec13[0];
+			float fTemp35 = ((((fTemp3 * fTemp28) + (fRec11[1] * fTemp33)) + ((fRec11[0] * fTemp31) / fTemp30)) + ((fRec12 * ((1.0f - fTemp24) - (fTemp26 * fTemp31))) / (fTemp30 * sqrtf(fTemp27))));
+			float fTemp36 = ((fRec8[1] * (0 - fTemp17)) + ((fTemp35 * fTemp23) / fTemp22));
+			fRec10[0] = ((fRec10[1] * (0 - fTemp15)) + (fTemp36 * fTemp21));
+			fRec8[0] = ((fTemp36 * fTemp15) + (fRec10[1] * fTemp21));
+			float 	fRec9 = fRec10[0];
+			fRec14[0] = ((0.999f * fRec14[1]) + fSlow18);
+			float fTemp37 = ((iSlow1)?fTemp2:(fRec14[0] * ((iSlow17)?((iSlow16)?((((((fTemp35 * fTemp17) / fTemp22) + (fRec8[1] * fTemp23)) + ((fRec8[0] * fTemp20) / fTemp19)) + ((fRec9 * ((1.0f - fTemp12) - (fTemp15 * fTemp20))) / (fTemp19 * sqrtf(fTemp16)))) / fTemp11):((fRec6[2] + (fRec6[0] + (2.0f * fRec6[1]))) / fTemp6)):fRec0[0])));
+			output0[i] = floatToFrac32(fTemp37);
+			// post processing
+			fRec14[1] = fRec14[0];
+			fRec8[1] = fRec8[0];
+			fRec10[1] = fRec10[0];
+			fRec11[1] = fRec11[0];
+			fRec13[1] = fRec13[0];
+			fRec6[2] = fRec6[1]; fRec6[1] = fRec6[0];
+			fRec7[2] = fRec7[1]; fRec7[1] = fRec7[0];
+			fRec0[1] = fRec0[0];
+			fRec2[1] = fRec2[0];
+			fRec3[1] = fRec3[0];
+			fRec4[1] = fRec4[0];
+			fRec5[1] = fRec5[0];
+			fRec1[1] = fRec1[0];
+		}
+]]></code.krate>
+   </obj.normal>
+</objdefs>
-- 
cgit v1.2.3