Updates (in case my plane crashes)

1 files changed, 449 insertions, 0 deletions

diff --git a/plugins/WinVST/Pressure4/Pressure4Proc.cpp b/plugins/WinVST/Pressure4/Pressure4Proc.cpp
new file mode 100755
index 0000000..02b8a78
--- /dev/null
+++ b/plugins/WinVST/Pressure4/Pressure4Proc.cpp
@@ -0,0 +1,449 @@
+/* ========================================
+ *  Pressure4 - Pressure4.h
+ *  Copyright (c) 2016 airwindows, All rights reserved
+ * ======================================== */
+
+#ifndef __Pressure4_H
+#include "Pressure4.h"
+#endif
+
+void Pressure4::processReplacing(float **inputs, float **outputs, VstInt32 sampleFrames) 
+{
+    float* inputL  =  inputs[0];
+    float* inputR  =  inputs[1];
+    float* outputL = outputs[0];
+    float* outputR = outputs[1];
+
+	double overallscale = 1.0;
+	overallscale /= 44100.0;
+	overallscale *= getSampleRate();
+	double threshold = 1.0 - (A * 0.95);
+	double muMakeupGain = 1.0 / threshold;
+	//gain settings around threshold
+	double release = pow((1.28-B),5)*32768.0;
+	release /= overallscale;
+	double fastest = sqrt(release);
+	//speed settings around release
+	long double bridgerectifier;
+	double coefficient;
+	double inputSense;
+	double mewiness = (C*2.0)-1.0;
+	double unmewiness;
+	double outputGain = D;
+	bool positivemu;
+	if (mewiness >= 0)
+	{
+		positivemu = true;
+		unmewiness = 1.0-mewiness;
+	}
+	else
+	{
+		positivemu = false;
+		mewiness = -mewiness;
+		unmewiness = 1.0-mewiness;
+	}
+	// µ µ µ µ µ µ µ µ µ µ µ µ is the kitten song o/~
+	float fpTemp;
+	long double fpOld = 0.618033988749894848204586; //golden ratio!
+	long double fpNew = 1.0 - fpOld;	
+
+	long double inputSampleL;
+	long double inputSampleR;
+	    
+    while (--sampleFrames >= 0)
+    {
+		inputSampleL = *inputL;
+		inputSampleR = *inputR;
+		if (inputSampleL<1.2e-38 && -inputSampleL<1.2e-38) {
+			static int noisesource = 0;
+			//this declares a variable before anything else is compiled. It won't keep assigning
+			//it to 0 for every sample, it's as if the declaration doesn't exist in this context,
+			//but it lets me add this denormalization fix in a single place rather than updating
+			//it in three different locations. The variable isn't thread-safe but this is only
+			//a random seed and we can share it with whatever.
+			noisesource = noisesource % 1700021; noisesource++;
+			int residue = noisesource * noisesource;
+			residue = residue % 170003; residue *= residue;
+			residue = residue % 17011; residue *= residue;
+			residue = residue % 1709; residue *= residue;
+			residue = residue % 173; residue *= residue;
+			residue = residue % 17;
+			double applyresidue = residue;
+			applyresidue *= 0.00000001;
+			applyresidue *= 0.00000001;
+			inputSampleL = applyresidue;
+		}
+		if (inputSampleR<1.2e-38 && -inputSampleR<1.2e-38) {
+			static int noisesource = 0;
+			noisesource = noisesource % 1700021; noisesource++;
+			int residue = noisesource * noisesource;
+			residue = residue % 170003; residue *= residue;
+			residue = residue % 17011; residue *= residue;
+			residue = residue % 1709; residue *= residue;
+			residue = residue % 173; residue *= residue;
+			residue = residue % 17;
+			double applyresidue = residue;
+			applyresidue *= 0.00000001;
+			applyresidue *= 0.00000001;
+			inputSampleR = applyresidue;
+			//this denormalization routine produces a white noise at -300 dB which the noise
+			//shaping will interact with to produce a bipolar output, but the noise is actually
+			//all positive. That should stop any variables from going denormal, and the routine
+			//only kicks in if digital black is input. As a final touch, if you save to 24-bit
+			//the silence will return to being digital black again.
+		}
+		
+		inputSampleL = inputSampleL * muMakeupGain;
+		inputSampleR = inputSampleR * muMakeupGain;
+		
+		inputSense = fabs(inputSampleL);
+		if (fabs(inputSampleR) > inputSense)
+			inputSense = fabs(inputSampleR);
+		//we will take the greater of either channel and just use that, then apply the result
+		//to both stereo channels.
+		
+		if (flip)
+		{
+			if (inputSense > threshold)
+			{
+				muVary = threshold / inputSense;
+				muAttack = sqrt(fabs(muSpeedA));
+				muCoefficientA = muCoefficientA * (muAttack-1.0);
+				if (muVary < threshold)
+				{
+					muCoefficientA = muCoefficientA + threshold;
+				}
+				else
+				{
+					muCoefficientA = muCoefficientA + muVary;
+				}
+				muCoefficientA = muCoefficientA / muAttack;
+			}
+			else
+			{
+				muCoefficientA = muCoefficientA * ((muSpeedA * muSpeedA)-1.0);
+				muCoefficientA = muCoefficientA + 1.0;
+				muCoefficientA = muCoefficientA / (muSpeedA * muSpeedA);
+			}
+			muNewSpeed = muSpeedA * (muSpeedA-1);
+			muNewSpeed = muNewSpeed + fabs(inputSense*release)+fastest;
+			muSpeedA = muNewSpeed / muSpeedA;
+		}
+		else
+		{
+			if (inputSense > threshold)
+			{
+				muVary = threshold / inputSense;
+				muAttack = sqrt(fabs(muSpeedB));
+				muCoefficientB = muCoefficientB * (muAttack-1);
+				if (muVary < threshold)
+				{
+					muCoefficientB = muCoefficientB + threshold;
+				}
+				else
+				{
+					muCoefficientB = muCoefficientB + muVary;
+				}
+				muCoefficientB = muCoefficientB / muAttack;
+			}
+			else
+			{
+				muCoefficientB = muCoefficientB * ((muSpeedB * muSpeedB)-1.0);
+				muCoefficientB = muCoefficientB + 1.0;
+				muCoefficientB = muCoefficientB / (muSpeedB * muSpeedB);
+			}
+			muNewSpeed = muSpeedB * (muSpeedB-1);
+			muNewSpeed = muNewSpeed + fabs(inputSense*release)+fastest;
+			muSpeedB = muNewSpeed / muSpeedB;
+		}
+		//got coefficients, adjusted speeds
+		
+		if (flip)
+		{
+			if (positivemu) coefficient = pow(muCoefficientA,2);
+			else coefficient = sqrt(muCoefficientA);
+			coefficient = (coefficient*mewiness)+(muCoefficientA*unmewiness);
+			inputSampleL *= coefficient;
+			inputSampleR *= coefficient;
+		}
+		else
+		{
+			if (positivemu) coefficient = pow(muCoefficientB,2);
+			else coefficient = sqrt(muCoefficientB);
+			coefficient = (coefficient*mewiness)+(muCoefficientB*unmewiness);
+			inputSampleL *= coefficient;
+			inputSampleR *= coefficient;
+		}
+		//applied compression with vari-vari-µ-µ-µ-µ-µ-µ-is-the-kitten-song o/~
+		//applied gain correction to control output level- tends to constrain sound rather than inflate it
+		
+		if (outputGain != 1.0) {
+			inputSampleL *= outputGain;
+			inputSampleR *= outputGain;
+		}		
+
+		bridgerectifier = fabs(inputSampleL);
+		if (bridgerectifier > 1.57079633) bridgerectifier = 1.0;
+		else bridgerectifier = sin(bridgerectifier);
+		if (inputSampleL > 0){inputSampleL = bridgerectifier;}
+		else {inputSampleL = -bridgerectifier;}
+		//second stage of overdrive to prevent overs and allow bloody loud extremeness
+		bridgerectifier = fabs(inputSampleR);
+		if (bridgerectifier > 1.57079633) bridgerectifier = 1.0;
+		else bridgerectifier = sin(bridgerectifier);
+		if (inputSampleR > 0){inputSampleR = bridgerectifier;}
+		else {inputSampleR = -bridgerectifier;}
+		//second stage of overdrive to prevent overs and allow bloody loud extremeness
+		
+		//noise shaping to 32-bit floating point
+		if (flip) {
+			fpTemp = inputSampleL;
+			fpNShapeAL = (fpNShapeAL*fpOld)+((inputSampleL-fpTemp)*fpNew);
+			inputSampleL += fpNShapeAL;
+			
+			fpTemp = inputSampleR;
+			fpNShapeAR = (fpNShapeAR*fpOld)+((inputSampleR-fpTemp)*fpNew);
+			inputSampleR += fpNShapeAR;
+		}
+		else {
+			fpTemp = inputSampleL;
+			fpNShapeBL = (fpNShapeBL*fpOld)+((inputSampleL-fpTemp)*fpNew);
+			inputSampleL += fpNShapeBL;
+			
+			fpTemp = inputSampleR;
+			fpNShapeBR = (fpNShapeBR*fpOld)+((inputSampleR-fpTemp)*fpNew);
+			inputSampleR += fpNShapeBR;
+		}
+		flip = !flip;
+		//end noise shaping on 32 bit output
+		
+		*outputL = inputSampleL;
+		*outputR = inputSampleR;
+		
+		*inputL++;
+		*inputR++;
+		*outputL++;
+		*outputR++;
+    }
+}
+
+void Pressure4::processDoubleReplacing(double **inputs, double **outputs, VstInt32 sampleFrames) 
+{
+    double* inputL  =  inputs[0];
+    double* inputR  =  inputs[1];
+    double* outputL = outputs[0];
+    double* outputR = outputs[1];
+
+	double overallscale = 1.0;
+	overallscale /= 44100.0;
+	overallscale *= getSampleRate();
+	double threshold = 1.0 - (A * 0.95);
+	double muMakeupGain = 1.0 / threshold;
+	//gain settings around threshold
+	double release = pow((1.28-B),5)*32768.0;
+	release /= overallscale;
+	double fastest = sqrt(release);
+	//speed settings around release
+	long double bridgerectifier;
+	double coefficient;
+	double inputSense;
+	double mewiness = (C*2.0)-1.0;
+	double unmewiness;
+	double outputGain = D;
+	bool positivemu;
+	if (mewiness >= 0)
+	{
+		positivemu = true;
+		unmewiness = 1.0-mewiness;
+	}
+	else
+	{
+		positivemu = false;
+		mewiness = -mewiness;
+		unmewiness = 1.0-mewiness;
+	}
+	// µ µ µ µ µ µ µ µ µ µ µ µ is the kitten song o/~
+	double fpTemp; //this is different from singlereplacing
+	long double fpOld = 0.618033988749894848204586; //golden ratio!
+	long double fpNew = 1.0 - fpOld;	
+
+	long double inputSampleL;
+	long double inputSampleR;
+ 
+
+    while (--sampleFrames >= 0)
+    {
+		inputSampleL = *inputL;
+		inputSampleR = *inputR;
+		if (inputSampleL<1.2e-38 && -inputSampleL<1.2e-38) {
+			static int noisesource = 0;
+			//this declares a variable before anything else is compiled. It won't keep assigning
+			//it to 0 for every sample, it's as if the declaration doesn't exist in this context,
+			//but it lets me add this denormalization fix in a single place rather than updating
+			//it in three different locations. The variable isn't thread-safe but this is only
+			//a random seed and we can share it with whatever.
+			noisesource = noisesource % 1700021; noisesource++;
+			int residue = noisesource * noisesource;
+			residue = residue % 170003; residue *= residue;
+			residue = residue % 17011; residue *= residue;
+			residue = residue % 1709; residue *= residue;
+			residue = residue % 173; residue *= residue;
+			residue = residue % 17;
+			double applyresidue = residue;
+			applyresidue *= 0.00000001;
+			applyresidue *= 0.00000001;
+			inputSampleL = applyresidue;
+		}
+		if (inputSampleR<1.2e-38 && -inputSampleR<1.2e-38) {
+			static int noisesource = 0;
+			noisesource = noisesource % 1700021; noisesource++;
+			int residue = noisesource * noisesource;
+			residue = residue % 170003; residue *= residue;
+			residue = residue % 17011; residue *= residue;
+			residue = residue % 1709; residue *= residue;
+			residue = residue % 173; residue *= residue;
+			residue = residue % 17;
+			double applyresidue = residue;
+			applyresidue *= 0.00000001;
+			applyresidue *= 0.00000001;
+			inputSampleR = applyresidue;
+			//this denormalization routine produces a white noise at -300 dB which the noise
+			//shaping will interact with to produce a bipolar output, but the noise is actually
+			//all positive. That should stop any variables from going denormal, and the routine
+			//only kicks in if digital black is input. As a final touch, if you save to 24-bit
+			//the silence will return to being digital black again.
+		}
+		
+		inputSampleL = inputSampleL * muMakeupGain;
+		inputSampleR = inputSampleR * muMakeupGain;
+		
+		inputSense = fabs(inputSampleL);
+		if (fabs(inputSampleR) > inputSense)
+			inputSense = fabs(inputSampleR);
+		//we will take the greater of either channel and just use that, then apply the result
+		//to both stereo channels.
+		
+		if (flip)
+		{
+			if (inputSense > threshold)
+			{
+				muVary = threshold / inputSense;
+				muAttack = sqrt(fabs(muSpeedA));
+				muCoefficientA = muCoefficientA * (muAttack-1.0);
+				if (muVary < threshold)
+				{
+					muCoefficientA = muCoefficientA + threshold;
+				}
+				else
+				{
+					muCoefficientA = muCoefficientA + muVary;
+				}
+				muCoefficientA = muCoefficientA / muAttack;
+			}
+			else
+			{
+				muCoefficientA = muCoefficientA * ((muSpeedA * muSpeedA)-1.0);
+				muCoefficientA = muCoefficientA + 1.0;
+				muCoefficientA = muCoefficientA / (muSpeedA * muSpeedA);
+			}
+			muNewSpeed = muSpeedA * (muSpeedA-1);
+			muNewSpeed = muNewSpeed + fabs(inputSense*release)+fastest;
+			muSpeedA = muNewSpeed / muSpeedA;
+		}
+		else
+		{
+			if (inputSense > threshold)
+			{
+				muVary = threshold / inputSense;
+				muAttack = sqrt(fabs(muSpeedB));
+				muCoefficientB = muCoefficientB * (muAttack-1);
+				if (muVary < threshold)
+				{
+					muCoefficientB = muCoefficientB + threshold;
+				}
+				else
+				{
+					muCoefficientB = muCoefficientB + muVary;
+				}
+				muCoefficientB = muCoefficientB / muAttack;
+			}
+			else
+			{
+				muCoefficientB = muCoefficientB * ((muSpeedB * muSpeedB)-1.0);
+				muCoefficientB = muCoefficientB + 1.0;
+				muCoefficientB = muCoefficientB / (muSpeedB * muSpeedB);
+			}
+			muNewSpeed = muSpeedB * (muSpeedB-1);
+			muNewSpeed = muNewSpeed + fabs(inputSense*release)+fastest;
+			muSpeedB = muNewSpeed / muSpeedB;
+		}
+		//got coefficients, adjusted speeds
+		
+		if (flip)
+		{
+			if (positivemu) coefficient = pow(muCoefficientA,2);
+			else coefficient = sqrt(muCoefficientA);
+			coefficient = (coefficient*mewiness)+(muCoefficientA*unmewiness);
+			inputSampleL *= coefficient;
+			inputSampleR *= coefficient;
+		}
+		else
+		{
+			if (positivemu) coefficient = pow(muCoefficientB,2);
+			else coefficient = sqrt(muCoefficientB);
+			coefficient = (coefficient*mewiness)+(muCoefficientB*unmewiness);
+			inputSampleL *= coefficient;
+			inputSampleR *= coefficient;
+		}
+		//applied compression with vari-vari-µ-µ-µ-µ-µ-µ-is-the-kitten-song o/~
+		//applied gain correction to control output level- tends to constrain sound rather than inflate it
+		
+		if (outputGain != 1.0) {
+			inputSampleL *= outputGain;
+			inputSampleR *= outputGain;
+		}		
+
+		bridgerectifier = fabs(inputSampleL);
+		if (bridgerectifier > 1.57079633) bridgerectifier = 1.0;
+		else bridgerectifier = sin(bridgerectifier);
+		if (inputSampleL > 0){inputSampleL = bridgerectifier;}
+		else {inputSampleL = -bridgerectifier;}
+		//second stage of overdrive to prevent overs and allow bloody loud extremeness
+		bridgerectifier = fabs(inputSampleR);
+		if (bridgerectifier > 1.57079633) bridgerectifier = 1.0;
+		else bridgerectifier = sin(bridgerectifier);
+		if (inputSampleR > 0){inputSampleR = bridgerectifier;}
+		else {inputSampleR = -bridgerectifier;}
+		//second stage of overdrive to prevent overs and allow bloody loud extremeness
+		
+		//noise shaping to 32-bit floating point
+		if (flip) {
+			fpTemp = inputSampleL;
+			fpNShapeAL = (fpNShapeAL*fpOld)+((inputSampleL-fpTemp)*fpNew);
+			inputSampleL += fpNShapeAL;
+			
+			fpTemp = inputSampleR;
+			fpNShapeAR = (fpNShapeAR*fpOld)+((inputSampleR-fpTemp)*fpNew);
+			inputSampleR += fpNShapeAR;
+		}
+		else {
+			fpTemp = inputSampleL;
+			fpNShapeBL = (fpNShapeBL*fpOld)+((inputSampleL-fpTemp)*fpNew);
+			inputSampleL += fpNShapeBL;
+			
+			fpTemp = inputSampleR;
+			fpNShapeBR = (fpNShapeBR*fpOld)+((inputSampleR-fpTemp)*fpNew);
+			inputSampleR += fpNShapeBR;
+		}
+		flip = !flip;
+		//end noise shaping on 32 bit output
+		
+		*outputL = inputSampleL;
+		*outputR = inputSampleR;
+
+		*inputL++;
+		*inputR++;
+		*outputL++;
+		*outputR++;
+    }
+}
\ No newline at end of file