diff options
author | Chris Johnson <jinx6568@sover.net> | 2018-06-17 21:15:56 -0400 |
---|---|---|
committer | Chris Johnson <jinx6568@sover.net> | 2018-06-17 21:15:56 -0400 |
commit | ca621e061652566046b1d88c8aa570425c36a278 (patch) | |
tree | b39896e732405b9596695bbd87602a8a4ce6ad33 /plugins/LinuxVST/src/Energy | |
parent | 0e17cd43f77cf0c74419a27284e85ceaa109f9ec (diff) | |
download | airwindows-lv2-port-ca621e061652566046b1d88c8aa570425c36a278.tar.gz airwindows-lv2-port-ca621e061652566046b1d88c8aa570425c36a278.tar.bz2 airwindows-lv2-port-ca621e061652566046b1d88c8aa570425c36a278.zip |
Energy
Diffstat (limited to 'plugins/LinuxVST/src/Energy')
-rwxr-xr-x | plugins/LinuxVST/src/Energy/Energy.cpp | 322 | ||||
-rwxr-xr-x | plugins/LinuxVST/src/Energy/Energy.h | 225 | ||||
-rwxr-xr-x | plugins/LinuxVST/src/Energy/EnergyProc.cpp | 1536 |
3 files changed, 2083 insertions, 0 deletions
diff --git a/plugins/LinuxVST/src/Energy/Energy.cpp b/plugins/LinuxVST/src/Energy/Energy.cpp new file mode 100755 index 0000000..8571e56 --- /dev/null +++ b/plugins/LinuxVST/src/Energy/Energy.cpp @@ -0,0 +1,322 @@ +/* ======================================== + * Energy - Energy.h + * Copyright (c) 2016 airwindows, All rights reserved + * ======================================== */ + +#ifndef __Energy_H +#include "Energy.h" +#endif + +AudioEffect* createEffectInstance(audioMasterCallback audioMaster) {return new Energy(audioMaster);} + +Energy::Energy(audioMasterCallback audioMaster) : + AudioEffectX(audioMaster, kNumPrograms, kNumParameters) +{ + A = 0.5; + B = 0.5; + C = 0.5; + D = 0.5; + E = 0.5; + F = 0.5; + G = 0.5; + H = 0.5; + I = 1.0; + + duoEvenL = 0.0; + duoOddL = 0.0; + duoFactorL = 0.0; + duoEvenR = 0.0; + duoOddR = 0.0; + duoFactorR = 0.0; + flip = false; + + tripletAL = 0.0; + tripletBL = 0.0; + tripletCL = 0.0; + tripletFactorL = 0.0; + tripletAR = 0.0; + tripletBR = 0.0; + tripletCR = 0.0; + tripletFactorR = 0.0; + countA = 1; + + quadAL = 0.0; + quadBL = 0.0; + quadCL = 0.0; + quadDL = 0.0; + quadFactorL = 0.0; + quadAR = 0.0; + quadBR = 0.0; + quadCR = 0.0; + quadDR = 0.0; + quadFactorR = 0.0; + countB = 1; + + quintAL = 0.0; + quintBL = 0.0; + quintCL = 0.0; + quintDL = 0.0; + quintEL = 0.0; + quintFactorL = 0.0; + quintAR = 0.0; + quintBR = 0.0; + quintCR = 0.0; + quintDR = 0.0; + quintER = 0.0; + quintFactorR = 0.0; + countC = 1; + + sextAL = 0.0; + sextBL = 0.0; + sextCL = 0.0; + sextDL = 0.0; + sextEL = 0.0; + sextFL = 0.0; + sextFactorL = 0.0; + sextAR = 0.0; + sextBR = 0.0; + sextCR = 0.0; + sextDR = 0.0; + sextER = 0.0; + sextFR = 0.0; + sextFactorR = 0.0; + countD = 1; + + septAL = 0.0; + septBL = 0.0; + septCL = 0.0; + septDL = 0.0; + septEL = 0.0; + septFL = 0.0; + septGL = 0.0; + septFactorL = 0.0; + septAR = 0.0; + septBR = 0.0; + septCR = 0.0; + septDR = 0.0; + septER = 0.0; + septFR = 0.0; + septGR = 0.0; + septFactorR = 0.0; + countE = 1; + + octAL = 0.0; + octBL = 0.0; + octCL = 0.0; + octDL = 0.0; + octEL = 0.0; + octFL = 0.0; + octGL = 0.0; + octHL = 0.0; + octFactorL = 0.0; + octAR = 0.0; + octBR = 0.0; + octCR = 0.0; + octDR = 0.0; + octER = 0.0; + octFR = 0.0; + octGR = 0.0; + octHR = 0.0; + octFactorR = 0.0; + countF = 1; + + nintAL = 0.0; + nintBL = 0.0; + nintCL = 0.0; + nintDL = 0.0; + nintEL = 0.0; + nintFL = 0.0; + nintGL = 0.0; + nintHL = 0.0; + nintIL = 0.0; + nintFactorL = 0.0; + nintAR = 0.0; + nintBR = 0.0; + nintCR = 0.0; + nintDR = 0.0; + nintER = 0.0; + nintFR = 0.0; + nintGR = 0.0; + nintHR = 0.0; + nintIR = 0.0; + nintFactorR = 0.0; + countG = 1; + + PrevHL = 0.0; + PrevGL = 0.0; + PrevFL = 0.0; + PrevEL = 0.0; + PrevDL = 0.0; + PrevCL = 0.0; + PrevBL = 0.0; + PrevAL = 0.0; + PrevHR = 0.0; + PrevGR = 0.0; + PrevFR = 0.0; + PrevER = 0.0; + PrevDR = 0.0; + PrevCR = 0.0; + PrevBR = 0.0; + PrevAR = 0.0; + + + fpNShapeL = 0.0; + fpNShapeR = 0.0; + //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 +} + +Energy::~Energy() {} +VstInt32 Energy::getVendorVersion () {return 1000;} +void Energy::setProgramName(char *name) {vst_strncpy (_programName, name, kVstMaxProgNameLen);} +void Energy::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; +} + +VstInt32 Energy::getChunk (void** data, bool isPreset) +{ + float *chunkData = (float *)calloc(kNumParameters, sizeof(float)); + chunkData[0] = A; + chunkData[1] = B; + chunkData[2] = C; + chunkData[3] = D; + chunkData[4] = E; + chunkData[5] = F; + chunkData[6] = G; + chunkData[7] = H; + chunkData[8] = I; + /* Note: The way this is set up, it will break if you manage to save settings on an Intel + machine and load them on a PPC Mac. However, it's fine if you stick to the machine you + started with. */ + + *data = chunkData; + return kNumParameters * sizeof(float); +} + +VstInt32 Energy::setChunk (void* data, VstInt32 byteSize, bool isPreset) +{ + float *chunkData = (float *)data; + A = pinParameter(chunkData[0]); + B = pinParameter(chunkData[1]); + C = pinParameter(chunkData[2]); + D = pinParameter(chunkData[3]); + E = pinParameter(chunkData[4]); + F = pinParameter(chunkData[5]); + G = pinParameter(chunkData[6]); + H = pinParameter(chunkData[7]); + I = pinParameter(chunkData[8]); + /* We're ignoring byteSize as we found it to be a filthy liar */ + + /* calculate any other fields you need here - you could copy in + code from setParameter() here. */ + return 0; +} + +void Energy::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; + case kParamF: F = value; break; + case kParamG: G = value; break; + case kParamH: H = value; break; + case kParamI: I = value; break; + default: throw; // unknown parameter, shouldn't happen! + } +} + +float Energy::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; + case kParamF: return F; break; + case kParamG: return G; break; + case kParamH: return H; break; + case kParamI: return I; 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 Energy::getParameterName(VstInt32 index, char *text) { + switch (index) { + case kParamA: vst_strncpy (text, "Hiss", kVstMaxParamStrLen); break; + case kParamB: vst_strncpy (text, "Glitter", kVstMaxParamStrLen); break; + case kParamC: vst_strncpy (text, "Rat", kVstMaxParamStrLen); break; + case kParamD: vst_strncpy (text, "Fizz", kVstMaxParamStrLen); break; + case kParamE: vst_strncpy (text, "Scrape", kVstMaxParamStrLen); break; + case kParamF: vst_strncpy (text, "Chug", kVstMaxParamStrLen); break; + case kParamG: vst_strncpy (text, "Yowr", kVstMaxParamStrLen); break; + case kParamH: vst_strncpy (text, "Snarl", kVstMaxParamStrLen); break; + case kParamI: vst_strncpy (text, "I/Dr/Wt", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } //this is our labels for displaying in the VST host +} + +void Energy::getParameterDisplay(VstInt32 index, char *text) { + switch (index) { + case kParamA: float2string ((A*2.0)-1.0, text, kVstMaxParamStrLen); break; + case kParamB: float2string ((B*2.0)-1.0, text, kVstMaxParamStrLen); break; + case kParamC: float2string ((C*2.0)-1.0, text, kVstMaxParamStrLen); break; + case kParamD: float2string ((D*2.0)-1.0, text, kVstMaxParamStrLen); break; + case kParamE: float2string ((E*2.0)-1.0, text, kVstMaxParamStrLen); break; + case kParamF: float2string ((F*2.0)-1.0, text, kVstMaxParamStrLen); break; + case kParamG: float2string ((G*2.0)-1.0, text, kVstMaxParamStrLen); break; + case kParamH: float2string ((H*2.0)-1.0, text, kVstMaxParamStrLen); break; + case kParamI: float2string ((I*2.0)-1.0, text, kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } //this displays the values and handles 'popups' where it's discrete choices +} + +void Energy::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; + case kParamD: vst_strncpy (text, "", kVstMaxParamStrLen); break; + case kParamE: vst_strncpy (text, "", kVstMaxParamStrLen); break; + case kParamF: vst_strncpy (text, "", kVstMaxParamStrLen); break; + case kParamG: vst_strncpy (text, "", kVstMaxParamStrLen); break; + case kParamH: vst_strncpy (text, "", kVstMaxParamStrLen); break; + case kParamI: vst_strncpy (text, "", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } +} + +VstInt32 Energy::canDo(char *text) +{ return (_canDo.find(text) == _canDo.end()) ? -1: 1; } // 1 = yes, -1 = no, 0 = don't know + +bool Energy::getEffectName(char* name) { + vst_strncpy(name, "Energy", kVstMaxProductStrLen); return true; +} + +VstPlugCategory Energy::getPlugCategory() {return kPlugCategEffect;} + +bool Energy::getProductString(char* text) { + vst_strncpy (text, "airwindows Energy", kVstMaxProductStrLen); return true; +} + +bool Energy::getVendorString(char* text) { + vst_strncpy (text, "airwindows", kVstMaxVendorStrLen); return true; +} diff --git a/plugins/LinuxVST/src/Energy/Energy.h b/plugins/LinuxVST/src/Energy/Energy.h new file mode 100755 index 0000000..b039c60 --- /dev/null +++ b/plugins/LinuxVST/src/Energy/Energy.h @@ -0,0 +1,225 @@ +/* ======================================== + * Energy - Energy.h + * Created 8/12/11 by SPIAdmin + * Copyright (c) 2011 __MyCompanyName__, All rights reserved + * ======================================== */ + +#ifndef __Energy_H +#define __Energy_H + +#ifndef __audioeffect__ +#include "audioeffectx.h" +#endif + +#include <set> +#include <string> +#include <math.h> + +enum { + kParamA = 0, + kParamB = 1, + kParamC = 2, + kParamD = 3, + kParamE = 4, + kParamF = 5, + kParamG = 6, + kParamH = 7, + kParamI = 8, + kNumParameters = 9 +}; // + +const int kNumPrograms = 0; +const int kNumInputs = 2; +const int kNumOutputs = 2; +const unsigned long kUniqueId = 'ener'; //Change this to what the AU identity is! + +class Energy : + public AudioEffectX +{ +public: + Energy(audioMasterCallback audioMaster); + ~Energy(); + 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 VstInt32 getChunk (void** data, bool isPreset); + virtual VstInt32 setChunk (void* data, VstInt32 byteSize, bool isPreset); + 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 + virtual VstInt32 canDo(char *text); +private: + char _programName[kVstMaxProgNameLen + 1]; + std::set< std::string > _canDo; + + long double fpNShapeL; + long double fpNShapeR; + //default stuff + + double duoEvenL; + double duoOddL; + double duoFactorL; + bool flip; + + double tripletAL; + double tripletBL; + double tripletCL; + double tripletFactorL; + int countA; + + double quadAL; + double quadBL; + double quadCL; + double quadDL; + double quadFactorL; + int countB; + + double quintAL; + double quintBL; + double quintCL; + double quintDL; + double quintEL; + double quintFactorL; + int countC; + + double sextAL; + double sextBL; + double sextCL; + double sextDL; + double sextEL; + double sextFL; + double sextFactorL; + int countD; + + double septAL; + double septBL; + double septCL; + double septDL; + double septEL; + double septFL; + double septGL; + double septFactorL; + int countE; + + double octAL; + double octBL; + double octCL; + double octDL; + double octEL; + double octFL; + double octGL; + double octHL; + double octFactorL; + int countF; + + double nintAL; + double nintBL; + double nintCL; + double nintDL; + double nintEL; + double nintFL; + double nintGL; + double nintHL; + double nintIL; + double nintFactorL; + int countG; + + double PrevHL; + double PrevGL; + double PrevFL; + double PrevEL; + double PrevDL; + double PrevCL; + double PrevBL; + double PrevAL; + + double duoEvenR; + double duoOddR; + double duoFactorR; + + double tripletAR; + double tripletBR; + double tripletCR; + double tripletFactorR; + + double quadAR; + double quadBR; + double quadCR; + double quadDR; + double quadFactorR; + + double quintAR; + double quintBR; + double quintCR; + double quintDR; + double quintER; + double quintFactorR; + + double sextAR; + double sextBR; + double sextCR; + double sextDR; + double sextER; + double sextFR; + double sextFactorR; + + double septAR; + double septBR; + double septCR; + double septDR; + double septER; + double septFR; + double septGR; + double septFactorR; + + double octAR; + double octBR; + double octCR; + double octDR; + double octER; + double octFR; + double octGR; + double octHR; + double octFactorR; + + double nintAR; + double nintBR; + double nintCR; + double nintDR; + double nintER; + double nintFR; + double nintGR; + double nintHR; + double nintIR; + double nintFactorR; + + double PrevHR; + double PrevGR; + double PrevFR; + double PrevER; + double PrevDR; + double PrevCR; + double PrevBR; + double PrevAR; + + float A; + float B; + float C; + float D; + float E; + float F; + float G; + float H; + float I; + +}; + +#endif diff --git a/plugins/LinuxVST/src/Energy/EnergyProc.cpp b/plugins/LinuxVST/src/Energy/EnergyProc.cpp new file mode 100755 index 0000000..a72b868 --- /dev/null +++ b/plugins/LinuxVST/src/Energy/EnergyProc.cpp @@ -0,0 +1,1536 @@ +/* ======================================== + * Energy - Energy.h + * Copyright (c) 2016 airwindows, All rights reserved + * ======================================== */ + +#ifndef __Energy_H +#include "Energy.h" +#endif + +void Energy::processReplacing(float **inputs, float **outputs, VstInt32 sampleFrames) +{ + float* in1 = inputs[0]; + float* in2 = inputs[1]; + float* out1 = outputs[0]; + float* out2 = outputs[1]; + + double duoIntensity = -pow((A*2.0)-1.0,3); + double tripletIntensity = -pow((B*2.0)-1.0,3); + double quadIntensity = -pow((C*2.0)-1.0,3); + double quintIntensity = -pow((D*2.0)-1.0,3); + double sextIntensity = -pow((E*2.0)-1.0,3); + double septIntensity = -pow((F*2.0)-1.0,3); + double octIntensity = -pow((G*2.0)-1.0,3); + double nintIntensity = -pow((H*2.0)-1.0,3); + double mix = (I*2.0)-1.0; + //all types of air band are running in parallel, not series + + while (--sampleFrames >= 0) + { + long double inputSampleL = *in1; + long double inputSampleR = *in2; + + static int noisesourceL = 0; + static int noisesourceR = 850010; + int residue; + double applyresidue; + + noisesourceL = noisesourceL % 1700021; noisesourceL++; + residue = noisesourceL * noisesourceL; + residue = residue % 170003; residue *= residue; + residue = residue % 17011; residue *= residue; + residue = residue % 1709; residue *= residue; + residue = residue % 173; residue *= residue; + residue = residue % 17; + applyresidue = residue; + applyresidue *= 0.00000001; + applyresidue *= 0.00000001; + inputSampleL += applyresidue; + if (inputSampleL<1.2e-38 && -inputSampleL<1.2e-38) { + inputSampleL -= applyresidue; + } + + noisesourceR = noisesourceR % 1700021; noisesourceR++; + residue = noisesourceR * noisesourceR; + residue = residue % 170003; residue *= residue; + residue = residue % 17011; residue *= residue; + residue = residue % 1709; residue *= residue; + residue = residue % 173; residue *= residue; + residue = residue % 17; + applyresidue = residue; + applyresidue *= 0.00000001; + applyresidue *= 0.00000001; + inputSampleR += applyresidue; + if (inputSampleR<1.2e-38 && -inputSampleR<1.2e-38) { + inputSampleR -= applyresidue; + } + //for live air, we always apply the dither noise. Then, if our result is + //effectively digital black, we'll subtract it again. We want a 'air' hiss + + long double correctionL = 0.0; + long double correctionR = 0.0; + + duoFactorL = PrevAL - inputSampleL; + duoFactorR = PrevAR - inputSampleR; + if (flip) + { + duoEvenL += duoFactorL; + duoOddL -= duoFactorL; + duoFactorL = duoEvenL * duoIntensity; + + duoEvenR += duoFactorR; + duoOddR -= duoFactorR; + duoFactorR = duoEvenR * duoIntensity; + } + else + { + duoOddL += duoFactorL; + duoEvenL -= duoFactorL; + duoFactorL = duoOddL * duoIntensity; + + duoOddR += duoFactorR; + duoEvenR -= duoFactorR; + duoFactorR = duoOddR * duoIntensity; + } + duoOddL = (duoOddL - ((duoOddL - duoEvenL)/256.0)) / 2.0; + duoEvenL = (duoEvenL - ((duoEvenL - duoOddL)/256.0)) / 2.0; + correctionL = correctionL + duoFactorL; + + duoOddR = (duoOddR - ((duoOddR - duoEvenR)/256.0)) / 2.0; + duoEvenR = (duoEvenR - ((duoEvenR - duoOddR)/256.0)) / 2.0; + correctionR = correctionR + duoFactorR; + flip = !flip; + //finished duo section + + + if (countA < 1 || countA > 3) countA = 1; + switch (countA) + { + case 1: + tripletFactorL = PrevBL - inputSampleL; + tripletAL += tripletFactorL; + tripletCL -= tripletFactorL; + tripletFactorL = tripletAL * tripletIntensity; + + tripletFactorR = PrevBR - inputSampleR; + tripletAR += tripletFactorR; + tripletCR -= tripletFactorR; + tripletFactorR = tripletAR * tripletIntensity; + break; + case 2: + tripletFactorL = PrevBL - inputSampleL; + tripletBL += tripletFactorL; + tripletAL -= tripletFactorL; + tripletFactorL = tripletBL * tripletIntensity; + + tripletFactorR = PrevBR - inputSampleR; + tripletBR += tripletFactorR; + tripletAR -= tripletFactorR; + tripletFactorR = tripletBR * tripletIntensity; + break; + case 3: + tripletFactorL = PrevBL - inputSampleL; + tripletCL += tripletFactorL; + tripletBL -= tripletFactorL; + tripletFactorL = tripletCL * tripletIntensity; + + tripletFactorR = PrevBR - inputSampleR; + tripletCR += tripletFactorR; + tripletBR -= tripletFactorR; + tripletFactorR = tripletCR * tripletIntensity; + break; + } + tripletAL /= 2.0; + tripletBL /= 2.0; + tripletCL /= 2.0; + correctionL = correctionL + tripletFactorL; + + tripletAR /= 2.0; + tripletBR /= 2.0; + tripletCR /= 2.0; + correctionR = correctionR + tripletFactorR; + countA++; + //finished triplet section- 15K + + if (countB < 1 || countB > 4) countB = 1; + switch (countB) + { + case 1: + quadFactorL = PrevCL - inputSampleL; + quadAL += quadFactorL; + quadDL -= quadFactorL; + quadFactorL = quadAL * quadIntensity; + + quadFactorR = PrevCR - inputSampleR; + quadAR += quadFactorR; + quadDR -= quadFactorR; + quadFactorR = quadAR * quadIntensity; + break; + case 2: + quadFactorL = PrevCL - inputSampleL; + quadBL += quadFactorL; + quadAL -= quadFactorL; + quadFactorL = quadBL * quadIntensity; + + quadFactorR = PrevCR - inputSampleR; + quadBR += quadFactorR; + quadAR -= quadFactorR; + quadFactorR = quadBR * quadIntensity; + break; + case 3: + quadFactorL = PrevCL - inputSampleL; + quadCL += quadFactorL; + quadBL -= quadFactorL; + quadFactorL = quadCL * quadIntensity; + + quadFactorR = PrevCR - inputSampleR; + quadCR += quadFactorR; + quadBR -= quadFactorR; + quadFactorR = quadCR * quadIntensity; + break; + case 4: + quadFactorL = PrevCL - inputSampleL; + quadDL += quadFactorL; + quadCL -= quadFactorL; + quadFactorL = quadDL * quadIntensity; + + quadFactorR = PrevCR - inputSampleR; + quadDR += quadFactorR; + quadCR -= quadFactorR; + quadFactorR = quadDR * quadIntensity; + break; + } + quadAL /= 2.0; + quadBL /= 2.0; + quadCL /= 2.0; + quadDL /= 2.0; + correctionL = correctionL + quadFactorL; + + quadAR /= 2.0; + quadBR /= 2.0; + quadCR /= 2.0; + quadDR /= 2.0; + correctionR = correctionR + quadFactorR; + countB++; + //finished quad section- 10K + + if (countC < 1 || countC > 5) countC = 1; + switch (countC) + { + case 1: + quintFactorL = PrevDL - inputSampleL; + quintAL += quintFactorL; + quintEL -= quintFactorL; + quintFactorL = quintAL * quintIntensity; + + quintFactorR = PrevDR - inputSampleR; + quintAR += quintFactorR; + quintER -= quintFactorR; + quintFactorR = quintAR * quintIntensity; + break; + case 2: + quintFactorL = PrevDL - inputSampleL; + quintBL += quintFactorL; + quintAL -= quintFactorL; + quintFactorL = quintBL * quintIntensity; + + quintFactorR = PrevDR - inputSampleR; + quintBR += quintFactorR; + quintAR -= quintFactorR; + quintFactorR = quintBR * quintIntensity; + break; + case 3: + quintFactorL = PrevDL - inputSampleL; + quintCL += quintFactorL; + quintBL -= quintFactorL; + quintFactorL = quintCL * quintIntensity; + + quintFactorR = PrevDR - inputSampleR; + quintCR += quintFactorR; + quintBR -= quintFactorR; + quintFactorR = quintCR * quintIntensity; + break; + case 4: + quintFactorL = PrevDL - inputSampleL; + quintDL += quintFactorL; + quintCL -= quintFactorL; + quintFactorL = quintDL * quintIntensity; + + quintFactorR = PrevDR - inputSampleR; + quintDR += quintFactorR; + quintCR -= quintFactorR; + quintFactorR = quintDR * quintIntensity; + break; + case 5: + quintFactorL = PrevDL - inputSampleL; + quintEL += quintFactorL; + quintDL -= quintFactorL; + quintFactorL = quintEL * quintIntensity; + + quintFactorR = PrevDR - inputSampleR; + quintER += quintFactorR; + quintDR -= quintFactorR; + quintFactorR = quintER * quintIntensity; + break; + } + quintAL /= 2.0; + quintBL /= 2.0; + quintCL /= 2.0; + quintDL /= 2.0; + quintEL /= 2.0; + correctionL = correctionL + quintFactorL; + + quintAR /= 2.0; + quintBR /= 2.0; + quintCR /= 2.0; + quintDR /= 2.0; + quintER /= 2.0; + correctionR = correctionR + quintFactorR; + countC++; + //finished quint section- 8K + + if (countD < 1 || countD > 6) countD = 1; + switch (countD) + { + case 1: + sextFactorL = PrevEL - inputSampleL; + sextAL += sextFactorL; + sextFL -= sextFactorL; + sextFactorL = sextAL * sextIntensity; + + sextFactorR = PrevER - inputSampleR; + sextAR += sextFactorR; + sextFR -= sextFactorR; + sextFactorR = sextAR * sextIntensity; + break; + case 2: + sextFactorL = PrevEL - inputSampleL; + sextBL += sextFactorL; + sextAL -= sextFactorL; + sextFactorL = sextBL * sextIntensity; + + sextFactorR = PrevER - inputSampleR; + sextBR += sextFactorR; + sextAR -= sextFactorR; + sextFactorR = sextBR * sextIntensity; + break; + case 3: + sextFactorL = PrevEL - inputSampleL; + sextCL += sextFactorL; + sextBL -= sextFactorL; + sextFactorL = sextCL * sextIntensity; + + sextFactorR = PrevER - inputSampleR; + sextCR += sextFactorR; + sextBR -= sextFactorR; + sextFactorR = sextCR * sextIntensity; + break; + case 4: + sextFactorL = PrevEL - inputSampleL; + sextDL += sextFactorL; + sextCL -= sextFactorL; + sextFactorL = sextDL * sextIntensity; + + sextFactorR = PrevER - inputSampleR; + sextDR += sextFactorR; + sextCR -= sextFactorR; + sextFactorR = sextDR * sextIntensity; + break; + case 5: + sextFactorL = PrevEL - inputSampleL; + sextEL += sextFactorL; + sextDL -= sextFactorL; + sextFactorL = sextEL * sextIntensity; + + sextFactorR = PrevER - inputSampleR; + sextER += sextFactorR; + sextDR -= sextFactorR; + sextFactorR = sextER * sextIntensity; + break; + case 6: + sextFactorL = PrevEL - inputSampleL; + sextFL += sextFactorL; + sextEL -= sextFactorL; + sextFactorL = sextFL * sextIntensity; + + sextFactorR = PrevER - inputSampleR; + sextFR += sextFactorR; + sextER -= sextFactorR; + sextFactorR = sextFR * sextIntensity; + break; + } + sextAL /= 2.0; + sextBL /= 2.0; + sextCL /= 2.0; + sextDL /= 2.0; + sextEL /= 2.0; + sextFL /= 2.0; + correctionL = correctionL + sextFactorL; + + sextAR /= 2.0; + sextBR /= 2.0; + sextCR /= 2.0; + sextDR /= 2.0; + sextER /= 2.0; + sextFR /= 2.0; + correctionR = correctionR + sextFactorR; + countD++; + //finished sext section- 6K + + if (countE < 1 || countE > 7) countE = 1; + switch (countE) + { + case 1: + septFactorL = PrevFL - inputSampleL; + septAL += septFactorL; + septGL -= septFactorL; + septFactorL = septAL * septIntensity; + + septFactorR = PrevFR - inputSampleR; + septAR += septFactorR; + septGR -= septFactorR; + septFactorR = septAR * septIntensity; + break; + case 2: + septFactorL = PrevFL - inputSampleL; + septBL += septFactorL; + septAL -= septFactorL; + septFactorL = septBL * septIntensity; + + septFactorR = PrevFR - inputSampleR; + septBR += septFactorR; + septAR -= septFactorR; + septFactorR = septBR * septIntensity; + break; + case 3: + septFactorL = PrevFL - inputSampleL; + septCL += septFactorL; + septBL -= septFactorL; + septFactorL = septCL * septIntensity; + + septFactorR = PrevFR - inputSampleR; + septCR += septFactorR; + septBR -= septFactorR; + septFactorR = septCR * septIntensity; + break; + case 4: + septFactorL = PrevFL - inputSampleL; + septDL += septFactorL; + septCL -= septFactorL; + septFactorL = septDL * septIntensity; + + septFactorR = PrevFR - inputSampleR; + septDR += septFactorR; + septCR -= septFactorR; + septFactorR = septDR * septIntensity; + break; + case 5: + septFactorL = PrevFL - inputSampleL; + septEL += septFactorL; + septDL -= septFactorL; + septFactorL = septEL * septIntensity; + + septFactorR = PrevFR - inputSampleR; + septER += septFactorR; + septDR -= septFactorR; + septFactorR = septER * septIntensity; + break; + case 6: + septFactorL = PrevFL - inputSampleL; + septFL += septFactorL; + septEL -= septFactorL; + septFactorL = septFL * septIntensity; + + septFactorR = PrevFR - inputSampleR; + septFR += septFactorR; + septER -= septFactorR; + septFactorR = septFR * septIntensity; + break; + case 7: + septFactorL = PrevFL - inputSampleL; + septGL += septFactorL; + septFL -= septFactorL; + septFactorL = septGL * septIntensity; + + septFactorR = PrevFR - inputSampleR; + septGR += septFactorR; + septFR -= septFactorR; + septFactorR = septGR * septIntensity; + break; + } + septAL /= 2.0; + septBL /= 2.0; + septCL /= 2.0; + septDL /= 2.0; + septEL /= 2.0; + septFL /= 2.0; + septGL /= 2.0; + correctionL = correctionL + septFactorL; + + septAR /= 2.0; + septBR /= 2.0; + septCR /= 2.0; + septDR /= 2.0; + septER /= 2.0; + septFR /= 2.0; + septGR /= 2.0; + correctionR = correctionR + septFactorR; + countE++; + //finished sept section- 5K + + if (countF < 1 || countF > 8) countF = 1; + switch (countF) + { + case 1: + octFactorL = PrevGL - inputSampleL; + octAL += octFactorL; + octHL -= octFactorL; + octFactorL = octAL * octIntensity; + + octFactorR = PrevGR - inputSampleR; + octAR += octFactorR; + octHR -= octFactorR; + octFactorR = octAR * octIntensity; + break; + case 2: + octFactorL = PrevGL - inputSampleL; + octBL += octFactorL; + octAL -= octFactorL; + octFactorL = octBL * octIntensity; + + octFactorR = PrevGR - inputSampleR; + octBR += octFactorR; + octAR -= octFactorR; + octFactorR = octBR * octIntensity; + break; + case 3: + octFactorL = PrevGL - inputSampleL; + octCL += octFactorL; + octBL -= octFactorL; + octFactorL = octCL * octIntensity; + + octFactorR = PrevGR - inputSampleR; + octCR += octFactorR; + octBR -= octFactorR; + octFactorR = octCR * octIntensity; + break; + case 4: + octFactorL = PrevGL - inputSampleL; + octDL += octFactorL; + octCL -= octFactorL; + octFactorL = octDL * octIntensity; + + octFactorR = PrevGR - inputSampleR; + octDR += octFactorR; + octCR -= octFactorR; + octFactorR = octDR * octIntensity; + break; + case 5: + octFactorL = PrevGL - inputSampleL; + octEL += octFactorL; + octDL -= octFactorL; + octFactorL = octEL * octIntensity; + + octFactorR = PrevGR - inputSampleR; + octER += octFactorR; + octDR -= octFactorR; + octFactorR = octER * octIntensity; + break; + case 6: + octFactorL = PrevGL - inputSampleL; + octFL += octFactorL; + octEL -= octFactorL; + octFactorL = octFL * octIntensity; + + octFactorR = PrevGR - inputSampleR; + octFR += octFactorR; + octER -= octFactorR; + octFactorR = octFR * octIntensity; + break; + case 7: + octFactorL = PrevGL - inputSampleL; + octGL += octFactorL; + octFL -= octFactorL; + octFactorL = octGL * octIntensity; + + octFactorR = PrevGR - inputSampleR; + octGR += octFactorR; + octFR -= octFactorR; + octFactorR = octGR * octIntensity; + break; + case 8: + octFactorL = PrevGL - inputSampleL; + octHL += octFactorL; + octGL -= octFactorL; + octFactorL = octHL * octIntensity; + + octFactorR = PrevGR - inputSampleR; + octHR += octFactorR; + octGR -= octFactorR; + octFactorR = octHR * octIntensity; + break; + } + octAL /= 2.0; + octBL /= 2.0; + octCL /= 2.0; + octDL /= 2.0; + octEL /= 2.0; + octFL /= 2.0; + octGL /= 2.0; + octHL /= 2.0; + correctionL = correctionL + octFactorL; + + octAR /= 2.0; + octBR /= 2.0; + octCR /= 2.0; + octDR /= 2.0; + octER /= 2.0; + octFR /= 2.0; + octGR /= 2.0; + octHR /= 2.0; + correctionR = correctionR + octFactorR; + countF++; + //finished oct section- 4K + + if (countG < 1 || countG > 9) countG = 1; + switch (countG) + { + case 1: + nintFactorL = PrevHL - inputSampleL; + nintAL += nintFactorL; + nintIL -= nintFactorL; + nintFactorL = nintAL * nintIntensity; + + nintFactorR = PrevHR - inputSampleR; + nintAR += nintFactorR; + nintIR -= nintFactorR; + nintFactorR = nintAR * nintIntensity; + break; + case 2: + nintFactorL = PrevHL - inputSampleL; + nintBL += nintFactorL; + nintAL -= nintFactorL; + nintFactorL = nintBL * nintIntensity; + + nintFactorR = PrevHR - inputSampleR; + nintBR += nintFactorR; + nintAR -= nintFactorR; + nintFactorR = nintBR * nintIntensity; + break; + case 3: + nintFactorL = PrevHL - inputSampleL; + nintCL += nintFactorL; + nintBL -= nintFactorL; + nintFactorL = nintCL * nintIntensity; + + nintFactorR = PrevHR - inputSampleR; + nintCR += nintFactorR; + nintBR -= nintFactorR; + nintFactorR = nintCR * nintIntensity; + break; + case 4: + nintFactorL = PrevHL - inputSampleL; + nintDL += nintFactorL; + nintCL -= nintFactorL; + nintFactorL = nintDL * nintIntensity; + + nintFactorR = PrevHR - inputSampleR; + nintDR += nintFactorR; + nintCR -= nintFactorR; + nintFactorR = nintDR * nintIntensity; + break; + case 5: + nintFactorL = PrevHL - inputSampleL; + nintEL += nintFactorL; + nintDL -= nintFactorL; + nintFactorL = nintEL * nintIntensity; + + nintFactorR = PrevHR - inputSampleR; + nintER += nintFactorR; + nintDR -= nintFactorR; + nintFactorR = nintER * nintIntensity; + break; + case 6: + nintFactorL = PrevHL - inputSampleL; + nintFL += nintFactorL; + nintEL -= nintFactorL; + nintFactorL = nintFL * nintIntensity; + + nintFactorR = PrevHR - inputSampleR; + nintFR += nintFactorR; + nintER -= nintFactorR; + nintFactorR = nintFR * nintIntensity; + break; + case 7: + nintFactorL = PrevHL - inputSampleL; + nintGL += nintFactorL; + nintFL -= nintFactorL; + nintFactorL = nintGL * nintIntensity; + + nintFactorR = PrevHR - inputSampleR; + nintGR += nintFactorR; + nintFR -= nintFactorR; + nintFactorR = nintGR * nintIntensity; + break; + case 8: + nintFactorL = PrevHL - inputSampleL; + nintHL += nintFactorL; + nintGL -= nintFactorL; + nintFactorL = nintHL * nintIntensity; + + nintFactorR = PrevHR - inputSampleR; + nintHR += nintFactorR; + nintGR -= nintFactorR; + nintFactorR = nintHR * nintIntensity; + break; + case 9: + nintFactorL = PrevHL - inputSampleL; + nintIL += nintFactorL; + nintHL -= nintFactorL; + nintFactorL = nintIL * nintIntensity; + + nintFactorR = PrevHR - inputSampleR; + nintIR += nintFactorR; + nintHR -= nintFactorR; + nintFactorR = nintIR * nintIntensity; + break; + } + nintAL /= 2.0; + nintBL /= 2.0; + nintCL /= 2.0; + nintDL /= 2.0; + nintEL /= 2.0; + nintFL /= 2.0; + nintGL /= 2.0; + nintHL /= 2.0; + nintIL /= 2.0; + correctionL = correctionL + nintFactorL; + + nintAR /= 2.0; + nintBR /= 2.0; + nintCR /= 2.0; + nintDR /= 2.0; + nintER /= 2.0; + nintFR /= 2.0; + nintGR /= 2.0; + nintHR /= 2.0; + nintIR /= 2.0; + correctionR = correctionR + nintFactorR; + countG++; + //finished nint section- 3K + + PrevHL = PrevGL; + PrevGL = PrevFL; + PrevFL = PrevEL; + PrevEL = PrevDL; + PrevDL = PrevCL; + PrevCL = PrevBL; + PrevBL = PrevAL; + PrevAL = inputSampleL; + + PrevHR = PrevGR; + PrevGR = PrevFR; + PrevFR = PrevER; + PrevER = PrevDR; + PrevDR = PrevCR; + PrevCR = PrevBR; + PrevBR = PrevAR; + PrevAR = inputSampleR; + + inputSampleL += (correctionL * mix); + inputSampleR += (correctionR * mix); + //we don't need a drySample because we never touched inputSample + //so, this provides the inv/dry/wet control all by itself + + //noise shaping to 32-bit floating point + float fpTemp = inputSampleL; + fpNShapeL += (inputSampleL-fpTemp); + inputSampleL += fpNShapeL; + //if this confuses you look at the wordlength for fpTemp :) + fpTemp = inputSampleR; + fpNShapeR += (inputSampleR-fpTemp); + inputSampleR += fpNShapeR; + //for deeper space and warmth, we try a non-oscillating noise shaping + //that is kind of ruthless: it will forever retain the rounding errors + //except we'll dial it back a hair at the end of every buffer processed + //end noise shaping on 32 bit output + + *out1 = inputSampleL; + *out2 = inputSampleR; + + *in1++; + *in2++; + *out1++; + *out2++; + } + fpNShapeL *= 0.999999; + fpNShapeR *= 0.999999; + //we will just delicately dial back the FP noise shaping, not even every sample + //this is a good place to put subtle 'no runaway' calculations, though bear in mind + //that it will be called more often when you use shorter sample buffers in the DAW. + //So, very low latency operation will call these calculations more often. +} + +void Energy::processDoubleReplacing(double **inputs, double **outputs, VstInt32 sampleFrames) +{ + double* in1 = inputs[0]; + double* in2 = inputs[1]; + double* out1 = outputs[0]; + double* out2 = outputs[1]; + + double duoIntensity = -pow((A*2.0)-1.0,3); + double tripletIntensity = -pow((B*2.0)-1.0,3); + double quadIntensity = -pow((C*2.0)-1.0,3); + double quintIntensity = -pow((D*2.0)-1.0,3); + double sextIntensity = -pow((E*2.0)-1.0,3); + double septIntensity = -pow((F*2.0)-1.0,3); + double octIntensity = -pow((G*2.0)-1.0,3); + double nintIntensity = -pow((H*2.0)-1.0,3); + double mix = (I*2.0)-1.0; + //all types of air band are running in parallel, not series + + while (--sampleFrames >= 0) + { + long double inputSampleL = *in1; + long double inputSampleR = *in2; + + static int noisesourceL = 0; + static int noisesourceR = 850010; + int residue; + double applyresidue; + + noisesourceL = noisesourceL % 1700021; noisesourceL++; + residue = noisesourceL * noisesourceL; + residue = residue % 170003; residue *= residue; + residue = residue % 17011; residue *= residue; + residue = residue % 1709; residue *= residue; + residue = residue % 173; residue *= residue; + residue = residue % 17; + applyresidue = residue; + applyresidue *= 0.00000001; + applyresidue *= 0.00000001; + inputSampleL += applyresidue; + if (inputSampleL<1.2e-38 && -inputSampleL<1.2e-38) { + inputSampleL -= applyresidue; + } + + noisesourceR = noisesourceR % 1700021; noisesourceR++; + residue = noisesourceR * noisesourceR; + residue = residue % 170003; residue *= residue; + residue = residue % 17011; residue *= residue; + residue = residue % 1709; residue *= residue; + residue = residue % 173; residue *= residue; + residue = residue % 17; + applyresidue = residue; + applyresidue *= 0.00000001; + applyresidue *= 0.00000001; + inputSampleR += applyresidue; + if (inputSampleR<1.2e-38 && -inputSampleR<1.2e-38) { + inputSampleR -= applyresidue; + } + //for live air, we always apply the dither noise. Then, if our result is + //effectively digital black, we'll subtract it again. We want a 'air' hiss + + long double correctionL = 0.0; + long double correctionR = 0.0; + + duoFactorL = PrevAL - inputSampleL; + duoFactorR = PrevAR - inputSampleR; + if (flip) + { + duoEvenL += duoFactorL; + duoOddL -= duoFactorL; + duoFactorL = duoEvenL * duoIntensity; + + duoEvenR += duoFactorR; + duoOddR -= duoFactorR; + duoFactorR = duoEvenR * duoIntensity; + } + else + { + duoOddL += duoFactorL; + duoEvenL -= duoFactorL; + duoFactorL = duoOddL * duoIntensity; + + duoOddR += duoFactorR; + duoEvenR -= duoFactorR; + duoFactorR = duoOddR * duoIntensity; + } + duoOddL = (duoOddL - ((duoOddL - duoEvenL)/256.0)) / 2.0; + duoEvenL = (duoEvenL - ((duoEvenL - duoOddL)/256.0)) / 2.0; + correctionL = correctionL + duoFactorL; + + duoOddR = (duoOddR - ((duoOddR - duoEvenR)/256.0)) / 2.0; + duoEvenR = (duoEvenR - ((duoEvenR - duoOddR)/256.0)) / 2.0; + correctionR = correctionR + duoFactorR; + flip = !flip; + //finished duo section + + + if (countA < 1 || countA > 3) countA = 1; + switch (countA) + { + case 1: + tripletFactorL = PrevBL - inputSampleL; + tripletAL += tripletFactorL; + tripletCL -= tripletFactorL; + tripletFactorL = tripletAL * tripletIntensity; + + tripletFactorR = PrevBR - inputSampleR; + tripletAR += tripletFactorR; + tripletCR -= tripletFactorR; + tripletFactorR = tripletAR * tripletIntensity; + break; + case 2: + tripletFactorL = PrevBL - inputSampleL; + tripletBL += tripletFactorL; + tripletAL -= tripletFactorL; + tripletFactorL = tripletBL * tripletIntensity; + + tripletFactorR = PrevBR - inputSampleR; + tripletBR += tripletFactorR; + tripletAR -= tripletFactorR; + tripletFactorR = tripletBR * tripletIntensity; + break; + case 3: + tripletFactorL = PrevBL - inputSampleL; + tripletCL += tripletFactorL; + tripletBL -= tripletFactorL; + tripletFactorL = tripletCL * tripletIntensity; + + tripletFactorR = PrevBR - inputSampleR; + tripletCR += tripletFactorR; + tripletBR -= tripletFactorR; + tripletFactorR = tripletCR * tripletIntensity; + break; + } + tripletAL /= 2.0; + tripletBL /= 2.0; + tripletCL /= 2.0; + correctionL = correctionL + tripletFactorL; + + tripletAR /= 2.0; + tripletBR /= 2.0; + tripletCR /= 2.0; + correctionR = correctionR + tripletFactorR; + countA++; + //finished triplet section- 15K + + if (countB < 1 || countB > 4) countB = 1; + switch (countB) + { + case 1: + quadFactorL = PrevCL - inputSampleL; + quadAL += quadFactorL; + quadDL -= quadFactorL; + quadFactorL = quadAL * quadIntensity; + + quadFactorR = PrevCR - inputSampleR; + quadAR += quadFactorR; + quadDR -= quadFactorR; + quadFactorR = quadAR * quadIntensity; + break; + case 2: + quadFactorL = PrevCL - inputSampleL; + quadBL += quadFactorL; + quadAL -= quadFactorL; + quadFactorL = quadBL * quadIntensity; + + quadFactorR = PrevCR - inputSampleR; + quadBR += quadFactorR; + quadAR -= quadFactorR; + quadFactorR = quadBR * quadIntensity; + break; + case 3: + quadFactorL = PrevCL - inputSampleL; + quadCL += quadFactorL; + quadBL -= quadFactorL; + quadFactorL = quadCL * quadIntensity; + + quadFactorR = PrevCR - inputSampleR; + quadCR += quadFactorR; + quadBR -= quadFactorR; + quadFactorR = quadCR * quadIntensity; + break; + case 4: + quadFactorL = PrevCL - inputSampleL; + quadDL += quadFactorL; + quadCL -= quadFactorL; + quadFactorL = quadDL * quadIntensity; + + quadFactorR = PrevCR - inputSampleR; + quadDR += quadFactorR; + quadCR -= quadFactorR; + quadFactorR = quadDR * quadIntensity; + break; + } + quadAL /= 2.0; + quadBL /= 2.0; + quadCL /= 2.0; + quadDL /= 2.0; + correctionL = correctionL + quadFactorL; + + quadAR /= 2.0; + quadBR /= 2.0; + quadCR /= 2.0; + quadDR /= 2.0; + correctionR = correctionR + quadFactorR; + countB++; + //finished quad section- 10K + + if (countC < 1 || countC > 5) countC = 1; + switch (countC) + { + case 1: + quintFactorL = PrevDL - inputSampleL; + quintAL += quintFactorL; + quintEL -= quintFactorL; + quintFactorL = quintAL * quintIntensity; + + quintFactorR = PrevDR - inputSampleR; + quintAR += quintFactorR; + quintER -= quintFactorR; + quintFactorR = quintAR * quintIntensity; + break; + case 2: + quintFactorL = PrevDL - inputSampleL; + quintBL += quintFactorL; + quintAL -= quintFactorL; + quintFactorL = quintBL * quintIntensity; + + quintFactorR = PrevDR - inputSampleR; + quintBR += quintFactorR; + quintAR -= quintFactorR; + quintFactorR = quintBR * quintIntensity; + break; + case 3: + quintFactorL = PrevDL - inputSampleL; + quintCL += quintFactorL; + quintBL -= quintFactorL; + quintFactorL = quintCL * quintIntensity; + + quintFactorR = PrevDR - inputSampleR; + quintCR += quintFactorR; + quintBR -= quintFactorR; + quintFactorR = quintCR * quintIntensity; + break; + case 4: + quintFactorL = PrevDL - inputSampleL; + quintDL += quintFactorL; + quintCL -= quintFactorL; + quintFactorL = quintDL * quintIntensity; + + quintFactorR = PrevDR - inputSampleR; + quintDR += quintFactorR; + quintCR -= quintFactorR; + quintFactorR = quintDR * quintIntensity; + break; + case 5: + quintFactorL = PrevDL - inputSampleL; + quintEL += quintFactorL; + quintDL -= quintFactorL; + quintFactorL = quintEL * quintIntensity; + + quintFactorR = PrevDR - inputSampleR; + quintER += quintFactorR; + quintDR -= quintFactorR; + quintFactorR = quintER * quintIntensity; + break; + } + quintAL /= 2.0; + quintBL /= 2.0; + quintCL /= 2.0; + quintDL /= 2.0; + quintEL /= 2.0; + correctionL = correctionL + quintFactorL; + + quintAR /= 2.0; + quintBR /= 2.0; + quintCR /= 2.0; + quintDR /= 2.0; + quintER /= 2.0; + correctionR = correctionR + quintFactorR; + countC++; + //finished quint section- 8K + + if (countD < 1 || countD > 6) countD = 1; + switch (countD) + { + case 1: + sextFactorL = PrevEL - inputSampleL; + sextAL += sextFactorL; + sextFL -= sextFactorL; + sextFactorL = sextAL * sextIntensity; + + sextFactorR = PrevER - inputSampleR; + sextAR += sextFactorR; + sextFR -= sextFactorR; + sextFactorR = sextAR * sextIntensity; + break; + case 2: + sextFactorL = PrevEL - inputSampleL; + sextBL += sextFactorL; + sextAL -= sextFactorL; + sextFactorL = sextBL * sextIntensity; + + sextFactorR = PrevER - inputSampleR; + sextBR += sextFactorR; + sextAR -= sextFactorR; + sextFactorR = sextBR * sextIntensity; + break; + case 3: + sextFactorL = PrevEL - inputSampleL; + sextCL += sextFactorL; + sextBL -= sextFactorL; + sextFactorL = sextCL * sextIntensity; + + sextFactorR = PrevER - inputSampleR; + sextCR += sextFactorR; + sextBR -= sextFactorR; + sextFactorR = sextCR * sextIntensity; + break; + case 4: + sextFactorL = PrevEL - inputSampleL; + sextDL += sextFactorL; + sextCL -= sextFactorL; + sextFactorL = sextDL * sextIntensity; + + sextFactorR = PrevER - inputSampleR; + sextDR += sextFactorR; + sextCR -= sextFactorR; + sextFactorR = sextDR * sextIntensity; + break; + case 5: + sextFactorL = PrevEL - inputSampleL; + sextEL += sextFactorL; + sextDL -= sextFactorL; + sextFactorL = sextEL * sextIntensity; + + sextFactorR = PrevER - inputSampleR; + sextER += sextFactorR; + sextDR -= sextFactorR; + sextFactorR = sextER * sextIntensity; + break; + case 6: + sextFactorL = PrevEL - inputSampleL; + sextFL += sextFactorL; + sextEL -= sextFactorL; + sextFactorL = sextFL * sextIntensity; + + sextFactorR = PrevER - inputSampleR; + sextFR += sextFactorR; + sextER -= sextFactorR; + sextFactorR = sextFR * sextIntensity; + break; + } + sextAL /= 2.0; + sextBL /= 2.0; + sextCL /= 2.0; + sextDL /= 2.0; + sextEL /= 2.0; + sextFL /= 2.0; + correctionL = correctionL + sextFactorL; + + sextAR /= 2.0; + sextBR /= 2.0; + sextCR /= 2.0; + sextDR /= 2.0; + sextER /= 2.0; + sextFR /= 2.0; + correctionR = correctionR + sextFactorR; + countD++; + //finished sext section- 6K + + if (countE < 1 || countE > 7) countE = 1; + switch (countE) + { + case 1: + septFactorL = PrevFL - inputSampleL; + septAL += septFactorL; + septGL -= septFactorL; + septFactorL = septAL * septIntensity; + + septFactorR = PrevFR - inputSampleR; + septAR += septFactorR; + septGR -= septFactorR; + septFactorR = septAR * septIntensity; + break; + case 2: + septFactorL = PrevFL - inputSampleL; + septBL += septFactorL; + septAL -= septFactorL; + septFactorL = septBL * septIntensity; + + septFactorR = PrevFR - inputSampleR; + septBR += septFactorR; + septAR -= septFactorR; + septFactorR = septBR * septIntensity; + break; + case 3: + septFactorL = PrevFL - inputSampleL; + septCL += septFactorL; + septBL -= septFactorL; + septFactorL = septCL * septIntensity; + + septFactorR = PrevFR - inputSampleR; + septCR += septFactorR; + septBR -= septFactorR; + septFactorR = septCR * septIntensity; + break; + case 4: + septFactorL = PrevFL - inputSampleL; + septDL += septFactorL; + septCL -= septFactorL; + septFactorL = septDL * septIntensity; + + septFactorR = PrevFR - inputSampleR; + septDR += septFactorR; + septCR -= septFactorR; + septFactorR = septDR * septIntensity; + break; + case 5: + septFactorL = PrevFL - inputSampleL; + septEL += septFactorL; + septDL -= septFactorL; + septFactorL = septEL * septIntensity; + + septFactorR = PrevFR - inputSampleR; + septER += septFactorR; + septDR -= septFactorR; + septFactorR = septER * septIntensity; + break; + case 6: + septFactorL = PrevFL - inputSampleL; + septFL += septFactorL; + septEL -= septFactorL; + septFactorL = septFL * septIntensity; + + septFactorR = PrevFR - inputSampleR; + septFR += septFactorR; + septER -= septFactorR; + septFactorR = septFR * septIntensity; + break; + case 7: + septFactorL = PrevFL - inputSampleL; + septGL += septFactorL; + septFL -= septFactorL; + septFactorL = septGL * septIntensity; + + septFactorR = PrevFR - inputSampleR; + septGR += septFactorR; + septFR -= septFactorR; + septFactorR = septGR * septIntensity; + break; + } + septAL /= 2.0; + septBL /= 2.0; + septCL /= 2.0; + septDL /= 2.0; + septEL /= 2.0; + septFL /= 2.0; + septGL /= 2.0; + correctionL = correctionL + septFactorL; + + septAR /= 2.0; + septBR /= 2.0; + septCR /= 2.0; + septDR /= 2.0; + septER /= 2.0; + septFR /= 2.0; + septGR /= 2.0; + correctionR = correctionR + septFactorR; + countE++; + //finished sept section- 5K + + if (countF < 1 || countF > 8) countF = 1; + switch (countF) + { + case 1: + octFactorL = PrevGL - inputSampleL; + octAL += octFactorL; + octHL -= octFactorL; + octFactorL = octAL * octIntensity; + + octFactorR = PrevGR - inputSampleR; + octAR += octFactorR; + octHR -= octFactorR; + octFactorR = octAR * octIntensity; + break; + case 2: + octFactorL = PrevGL - inputSampleL; + octBL += octFactorL; + octAL -= octFactorL; + octFactorL = octBL * octIntensity; + + octFactorR = PrevGR - inputSampleR; + octBR += octFactorR; + octAR -= octFactorR; + octFactorR = octBR * octIntensity; + break; + case 3: + octFactorL = PrevGL - inputSampleL; + octCL += octFactorL; + octBL -= octFactorL; + octFactorL = octCL * octIntensity; + + octFactorR = PrevGR - inputSampleR; + octCR += octFactorR; + octBR -= octFactorR; + octFactorR = octCR * octIntensity; + break; + case 4: + octFactorL = PrevGL - inputSampleL; + octDL += octFactorL; + octCL -= octFactorL; + octFactorL = octDL * octIntensity; + + octFactorR = PrevGR - inputSampleR; + octDR += octFactorR; + octCR -= octFactorR; + octFactorR = octDR * octIntensity; + break; + case 5: + octFactorL = PrevGL - inputSampleL; + octEL += octFactorL; + octDL -= octFactorL; + octFactorL = octEL * octIntensity; + + octFactorR = PrevGR - inputSampleR; + octER += octFactorR; + octDR -= octFactorR; + octFactorR = octER * octIntensity; + break; + case 6: + octFactorL = PrevGL - inputSampleL; + octFL += octFactorL; + octEL -= octFactorL; + octFactorL = octFL * octIntensity; + + octFactorR = PrevGR - inputSampleR; + octFR += octFactorR; + octER -= octFactorR; + octFactorR = octFR * octIntensity; + break; + case 7: + octFactorL = PrevGL - inputSampleL; + octGL += octFactorL; + octFL -= octFactorL; + octFactorL = octGL * octIntensity; + + octFactorR = PrevGR - inputSampleR; + octGR += octFactorR; + octFR -= octFactorR; + octFactorR = octGR * octIntensity; + break; + case 8: + octFactorL = PrevGL - inputSampleL; + octHL += octFactorL; + octGL -= octFactorL; + octFactorL = octHL * octIntensity; + + octFactorR = PrevGR - inputSampleR; + octHR += octFactorR; + octGR -= octFactorR; + octFactorR = octHR * octIntensity; + break; + } + octAL /= 2.0; + octBL /= 2.0; + octCL /= 2.0; + octDL /= 2.0; + octEL /= 2.0; + octFL /= 2.0; + octGL /= 2.0; + octHL /= 2.0; + correctionL = correctionL + octFactorL; + + octAR /= 2.0; + octBR /= 2.0; + octCR /= 2.0; + octDR /= 2.0; + octER /= 2.0; + octFR /= 2.0; + octGR /= 2.0; + octHR /= 2.0; + correctionR = correctionR + octFactorR; + countF++; + //finished oct section- 4K + + if (countG < 1 || countG > 9) countG = 1; + switch (countG) + { + case 1: + nintFactorL = PrevHL - inputSampleL; + nintAL += nintFactorL; + nintIL -= nintFactorL; + nintFactorL = nintAL * nintIntensity; + + nintFactorR = PrevHR - inputSampleR; + nintAR += nintFactorR; + nintIR -= nintFactorR; + nintFactorR = nintAR * nintIntensity; + break; + case 2: + nintFactorL = PrevHL - inputSampleL; + nintBL += nintFactorL; + nintAL -= nintFactorL; + nintFactorL = nintBL * nintIntensity; + + nintFactorR = PrevHR - inputSampleR; + nintBR += nintFactorR; + nintAR -= nintFactorR; + nintFactorR = nintBR * nintIntensity; + break; + case 3: + nintFactorL = PrevHL - inputSampleL; + nintCL += nintFactorL; + nintBL -= nintFactorL; + nintFactorL = nintCL * nintIntensity; + + nintFactorR = PrevHR - inputSampleR; + nintCR += nintFactorR; + nintBR -= nintFactorR; + nintFactorR = nintCR * nintIntensity; + break; + case 4: + nintFactorL = PrevHL - inputSampleL; + nintDL += nintFactorL; + nintCL -= nintFactorL; + nintFactorL = nintDL * nintIntensity; + + nintFactorR = PrevHR - inputSampleR; + nintDR += nintFactorR; + nintCR -= nintFactorR; + nintFactorR = nintDR * nintIntensity; + break; + case 5: + nintFactorL = PrevHL - inputSampleL; + nintEL += nintFactorL; + nintDL -= nintFactorL; + nintFactorL = nintEL * nintIntensity; + + nintFactorR = PrevHR - inputSampleR; + nintER += nintFactorR; + nintDR -= nintFactorR; + nintFactorR = nintER * nintIntensity; + break; + case 6: + nintFactorL = PrevHL - inputSampleL; + nintFL += nintFactorL; + nintEL -= nintFactorL; + nintFactorL = nintFL * nintIntensity; + + nintFactorR = PrevHR - inputSampleR; + nintFR += nintFactorR; + nintER -= nintFactorR; + nintFactorR = nintFR * nintIntensity; + break; + case 7: + nintFactorL = PrevHL - inputSampleL; + nintGL += nintFactorL; + nintFL -= nintFactorL; + nintFactorL = nintGL * nintIntensity; + + nintFactorR = PrevHR - inputSampleR; + nintGR += nintFactorR; + nintFR -= nintFactorR; + nintFactorR = nintGR * nintIntensity; + break; + case 8: + nintFactorL = PrevHL - inputSampleL; + nintHL += nintFactorL; + nintGL -= nintFactorL; + nintFactorL = nintHL * nintIntensity; + + nintFactorR = PrevHR - inputSampleR; + nintHR += nintFactorR; + nintGR -= nintFactorR; + nintFactorR = nintHR * nintIntensity; + break; + case 9: + nintFactorL = PrevHL - inputSampleL; + nintIL += nintFactorL; + nintHL -= nintFactorL; + nintFactorL = nintIL * nintIntensity; + + nintFactorR = PrevHR - inputSampleR; + nintIR += nintFactorR; + nintHR -= nintFactorR; + nintFactorR = nintIR * nintIntensity; + break; + } + nintAL /= 2.0; + nintBL /= 2.0; + nintCL /= 2.0; + nintDL /= 2.0; + nintEL /= 2.0; + nintFL /= 2.0; + nintGL /= 2.0; + nintHL /= 2.0; + nintIL /= 2.0; + correctionL = correctionL + nintFactorL; + + nintAR /= 2.0; + nintBR /= 2.0; + nintCR /= 2.0; + nintDR /= 2.0; + nintER /= 2.0; + nintFR /= 2.0; + nintGR /= 2.0; + nintHR /= 2.0; + nintIR /= 2.0; + correctionR = correctionR + nintFactorR; + countG++; + //finished nint section- 3K + + PrevHL = PrevGL; + PrevGL = PrevFL; + PrevFL = PrevEL; + PrevEL = PrevDL; + PrevDL = PrevCL; + PrevCL = PrevBL; + PrevBL = PrevAL; + PrevAL = inputSampleL; + + PrevHR = PrevGR; + PrevGR = PrevFR; + PrevFR = PrevER; + PrevER = PrevDR; + PrevDR = PrevCR; + PrevCR = PrevBR; + PrevBR = PrevAR; + PrevAR = inputSampleR; + + inputSampleL += (correctionL * mix); + inputSampleR += (correctionR * mix); + //we don't need a drySample because we never touched inputSample + //so, this provides the inv/dry/wet control all by itself + + //noise shaping to 64-bit floating point + double fpTemp = inputSampleL; + fpNShapeL += (inputSampleL-fpTemp); + inputSampleL += fpNShapeL; + //if this confuses you look at the wordlength for fpTemp :) + fpTemp = inputSampleR; + fpNShapeR += (inputSampleR-fpTemp); + inputSampleR += fpNShapeR; + //for deeper space and warmth, we try a non-oscillating noise shaping + //that is kind of ruthless: it will forever retain the rounding errors + //except we'll dial it back a hair at the end of every buffer processed + //end noise shaping on 64 bit output + + *out1 = inputSampleL; + *out2 = inputSampleR; + + *in1++; + *in2++; + *out1++; + *out2++; + } + fpNShapeL *= 0.999999; + fpNShapeR *= 0.999999; + //we will just delicately dial back the FP noise shaping, not even every sample + //this is a good place to put subtle 'no runaway' calculations, though bear in mind + //that it will be called more often when you use shorter sample buffers in the DAW. + //So, very low latency operation will call these calculations more often. +} |