From b20f153c842e685d87607e903804596d01f9da3b Mon Sep 17 00:00:00 2001 From: Roland Rabien Date: Sun, 8 Oct 2023 22:44:56 -0700 Subject: [PATCH] Add more fx --- modules/gin | 2 +- plugin/Resources/layout.json | 41 +- plugin/Source/FX/DeRez2.cpp | 156 +++ plugin/Source/FX/DeRez2.h | 79 ++ plugin/Source/FX/DeRez2Proc.cpp | 366 ++++++ plugin/Source/FX/FXBase.h | 108 ++ plugin/Source/FX/FireAmp.cpp | 238 ++++ plugin/Source/FX/FireAmp.h | 168 +++ plugin/Source/FX/FireAmpProc.cpp | 1709 +++++++++++++++++++++++++++++ plugin/Source/FX/GrindAmp.cpp | 258 +++++ plugin/Source/FX/GrindAmp.h | 190 ++++ plugin/Source/FX/GrindAmpProc.cpp | 1652 ++++++++++++++++++++++++++++ plugin/Source/Panels.h | 115 +- plugin/Source/PluginProcessor.cpp | 107 +- plugin/Source/PluginProcessor.h | 44 +- 15 files changed, 5211 insertions(+), 22 deletions(-) create mode 100755 plugin/Source/FX/DeRez2.cpp create mode 100755 plugin/Source/FX/DeRez2.h create mode 100755 plugin/Source/FX/DeRez2Proc.cpp create mode 100755 plugin/Source/FX/FXBase.h create mode 100755 plugin/Source/FX/FireAmp.cpp create mode 100755 plugin/Source/FX/FireAmp.h create mode 100755 plugin/Source/FX/FireAmpProc.cpp create mode 100755 plugin/Source/FX/GrindAmp.cpp create mode 100755 plugin/Source/FX/GrindAmp.h create mode 100755 plugin/Source/FX/GrindAmpProc.cpp diff --git a/modules/gin b/modules/gin index f79efd9..33a6a30 160000 --- a/modules/gin +++ b/modules/gin @@ -1 +1 @@ -Subproject commit f79efd9b83a7a546df4ba8c437cc7d487144aa89 +Subproject commit 33a6a308642734c70746c025290398e550b04858 diff --git a/plugin/Resources/layout.json b/plugin/Resources/layout.json index dd9e6ac..0bccae0 100644 --- a/plugin/Resources/layout.json +++ b/plugin/Resources/layout.json @@ -106,9 +106,9 @@ }, { "id": "fx", "x": 0, "y": "prevB()+1", "w": "parW() - 169", "h": 137, "children": [ - { "id": "gate", "x": "0", "y": 0, "w": 290, "h": 137, "children": + { "id": "gate", "x": "0", "y": 0, "w": 306, "h": 137, "children": [ - { "id": "Beat", "x": 61, "y": 30, "w": 42, "h": 57 }, + { "id": "Beat", "x": 69, "y": 30, "w": 42, "h": 57 }, { "id": "Length", "x": "prevR()", "y": "prevY()", "w": 42, "h": 57 }, { "id": "A", "x": "prevR()", "y": "prevY()", "w": 42, "h": 57 }, { "id": "R", "x": "prevR()", "y": "prevY()", "w": 42, "h": 57 }, @@ -124,9 +124,42 @@ { "id": "Width", "x": "prevR()", "y": "prevY()", "w": 42, "h": 57 } ] }, - { "id": "distort", "x": "prevR()+1", "y": "prevY()", "w": 100, "h": 137, "children": + { "id": "distort", "x": "prevR()+1", "y": "prevY()", "w": 84, "h": 137, "children": [ - { "id": "Amount", "x": 22, "y": "23 + 22", "w": 56, "h": 70 } + { "id": "Distort", "children": + [ + { "id": "mode", "r": "parW() - 4", "y": 4, "w": 16, "h": 16 } + ] + }, + { "id": "page1", "bounds": "parent", "children": + [ + { "id": "Amount", "x": 14, "y": "23 + 22", "w": 56, "h": 70 } + ] + }, + { "id": "page2", "bounds": "parent", "children": + [ + { "id": "Rate", "x": 0, "y": 23, "w": 42, "h": 57 }, + { "id": "Rez", "x": "prevR()", "y": "prevY()", "w": 42, "h": 57 }, + { "id": "Hard", "x": 0, "y": "prevB()", "w": 42, "h": 57 }, + { "id": "Mix", "x": "prevR()", "y": "prevY()", "w": 42, "h": 57 } + ] + }, + { "id": "page3", "bounds": "parent", "children": + [ + { "id": "Gain", "x": 0, "y": 23, "w": 42, "h": 57 }, + { "id": "Tone", "x": "prevR()", "y": "prevY()", "w": 42, "h": 57 }, + { "id": "Output", "x": 0, "y": "prevB()", "w": 42, "h": 57 }, + { "id": "Mix", "x": "prevR()", "y": "prevY()", "w": 42, "h": 57 } + ] + }, + { "id": "page4", "bounds": "parent", "children": + [ + { "id": "Gain", "x": 0, "y": 23, "w": 42, "h": 57 }, + { "id": "Tone", "x": "prevR()", "y": "prevY()", "w": 42, "h": 57 }, + { "id": "Output", "x": 0, "y": "prevB()", "w": 42, "h": 57 }, + { "id": "Mix", "x": "prevR()", "y": "prevY()", "w": 42, "h": 57 } + ] + } ] }, { "id": "delay", "x": "prevR()+1", "y": "prevY()", "w": 126, "h": 137, "children": diff --git a/plugin/Source/FX/DeRez2.cpp b/plugin/Source/FX/DeRez2.cpp new file mode 100755 index 0000000..1240479 --- /dev/null +++ b/plugin/Source/FX/DeRez2.cpp @@ -0,0 +1,156 @@ +/* ======================================== + * DeRez2 - DeRez2.h + * Copyright (c) 2016 airwindows, Airwindows uses the MIT license + * ======================================== */ + +#ifndef __DeRez2_H +#include "DeRez2.h" +#endif + +JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wfloat-conversion", "-Wimplicit-float-conversion", "-Wunused-parameter") + +DeRez2::DeRez2(audioMasterCallback audioMaster) : + AudioEffectX(audioMaster, kNumPrograms, kNumParameters) +{ + A = 1.0; + B = 1.0; + C = 1.0; + D = 1.0; + lastSampleL = 0.0; + heldSampleL = 0.0; + lastDrySampleL = 0.0; + lastOutputSampleL = 0.0; + + lastSampleR = 0.0; + heldSampleR = 0.0; + lastDrySampleR = 0.0; + lastOutputSampleR = 0.0; + + position = 0.0; + incrementA = 0.0; + incrementB = 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 +} + +DeRez2::~DeRez2() {} +VstInt32 DeRez2::getVendorVersion () {return 1000;} +void DeRez2::setProgramName(char *name) {vst_strncpy (_programName, name, kVstMaxProgNameLen);} +void DeRez2::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 DeRez2::getChunk (void** data, bool isPreset) +{ + float *chunkData = (float *)calloc(kNumParameters, sizeof(float)); + chunkData[0] = A; + chunkData[1] = B; + chunkData[2] = C; + chunkData[3] = D; + /* 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 DeRez2::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]); + /* 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 DeRez2::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; + default: throw; // unknown parameter, shouldn't happen! + } +} + +float DeRez2::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; + default: break; // unknown parameter, shouldn't happen! + } return 0.0; //we only need to update the relevant name, this is simple to manage +} + +void DeRez2::getParameterName(VstInt32 index, char *text) { + switch (index) { + case kParamA: vst_strncpy (text, "Rate", kVstMaxParamStrLen); break; + case kParamB: vst_strncpy (text, "Rez", kVstMaxParamStrLen); break; + case kParamC: vst_strncpy (text, "Hard", kVstMaxParamStrLen); break; + case kParamD: 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 DeRez2::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; + case kParamD: float2string (D, text, kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } //this displays the values and handles 'popups' where it's discrete choices +} + +void DeRez2::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; + default: break; // unknown parameter, shouldn't happen! + } +} + +VstInt32 DeRez2::canDo(char *text) +{ return (_canDo.find(text) == _canDo.end()) ? -1: 1; } // 1 = yes, -1 = no, 0 = don't know + +bool DeRez2::getEffectName(char* name) { + vst_strncpy(name, "DeRez2", kVstMaxProductStrLen); return true; +} + +VstPlugCategory DeRez2::getPlugCategory() {return kPlugCategEffect;} + +bool DeRez2::getProductString(char* text) { + vst_strncpy (text, "airwindows DeRez2", kVstMaxProductStrLen); return true; +} + +bool DeRez2::getVendorString(char* text) { + vst_strncpy (text, "airwindows", kVstMaxVendorStrLen); return true; +} diff --git a/plugin/Source/FX/DeRez2.h b/plugin/Source/FX/DeRez2.h new file mode 100755 index 0000000..b8dde03 --- /dev/null +++ b/plugin/Source/FX/DeRez2.h @@ -0,0 +1,79 @@ +/* ======================================== + * DeRez2 - DeRez2.h + * Created 8/12/11 by SPIAdmin + * Copyright (c) 2011 __MyCompanyName__, Airwindows uses the MIT license + * ======================================== */ + +#pragma once + +#include "FXBase.h" + +#include +#include +#include + +class DeRez2 : + public AudioEffectX +{ +public: + enum { + kParamA = 0, + kParamB = 1, + kParamC = 2, + kParamD = 3, + kNumParameters = 4 + }; // + + static constexpr int kNumPrograms = 0; + static constexpr int kNumInputs = 2; + static constexpr int kNumOutputs = 2; + static constexpr unsigned long kUniqueId = 'eerz'; //Change this to what the AU identity is! + + DeRez2(audioMasterCallback audioMaster); + ~DeRez2(); + 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; + + double lastSampleL; + double heldSampleL; + double lastDrySampleL; + double lastOutputSampleL; + + double lastSampleR; + double heldSampleR; + double lastDrySampleR; + double lastOutputSampleR; + + double position; + double incrementA; + double incrementB; + + uint32_t fpdL; + uint32_t fpdR; + //default stuff + + float A; + float B; + float C; + float D; + +}; + diff --git a/plugin/Source/FX/DeRez2Proc.cpp b/plugin/Source/FX/DeRez2Proc.cpp new file mode 100755 index 0000000..3a9b270 --- /dev/null +++ b/plugin/Source/FX/DeRez2Proc.cpp @@ -0,0 +1,366 @@ +/* ======================================== + * DeRez2 - DeRez2.h + * Copyright (c) 2016 airwindows, Airwindows uses the MIT license + * ======================================== */ + +#ifndef __DeRez2_H +#include "DeRez2.h" +#endif + +JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wfloat-conversion", "-Wimplicit-float-conversion", "-Wunused-parameter", "-Wunused-value") + +void DeRez2::processReplacing(float **inputs, float **outputs, VstInt32 sampleFrames) +{ + float* in1 = inputs[0]; + float* in2 = inputs[1]; + float* out1 = outputs[0]; + float* out2 = outputs[1]; + + double targetA = pow(A,3)+0.0005; + if (targetA > 1.0) targetA = 1.0; + double soften = (1.0 + targetA)/2; + double targetB = pow(1.0-B,3) / 3; + double hard = C; + double wet = D; + + double overallscale = 1.0; + overallscale /= 44100.0; + overallscale *= getSampleRate(); + targetA /= overallscale; + + while (--sampleFrames >= 0) + { + double inputSampleL = *in1; + double inputSampleR = *in2; + if (fabs(inputSampleL)<1.18e-23) inputSampleL = fpdL * 1.18e-17; + if (fabs(inputSampleR)<1.18e-23) inputSampleR = fpdR * 1.18e-17; + double drySampleL = inputSampleL; + double drySampleR = inputSampleR; + + + incrementA = ((incrementA*999.0)+targetA)/1000.0; + incrementB = ((incrementB*999.0)+targetB)/1000.0; + //incrementA is the frequency derez + //incrementB is the bit depth derez + position += incrementA; + + double outputSampleL = heldSampleL; + double outputSampleR = heldSampleR; + if (position > 1.0) + { + position -= 1.0; + heldSampleL = (lastSampleL * position) + (inputSampleL * (1.0-position)); + outputSampleL = (outputSampleL * (1.0-soften)) + (heldSampleL * soften); + //softens the edge of the derez + heldSampleR = (lastSampleR * position) + (inputSampleR * (1.0-position)); + outputSampleR = (outputSampleR * (1.0-soften)) + (heldSampleR * soften); + //softens the edge of the derez + } + inputSampleL = outputSampleL; + inputSampleR = outputSampleR; + + double tempL = inputSampleL; + double tempR = inputSampleR; + + if (inputSampleL != lastOutputSampleL) { + tempL = inputSampleL; + inputSampleL = (inputSampleL * hard) + (lastDrySampleL * (1.0-hard)); + //transitions get an intermediate dry sample + lastOutputSampleL = tempL; //only one intermediate sample + } else { + lastOutputSampleL = inputSampleL; + } + + if (inputSampleR != lastOutputSampleR) { + tempR = inputSampleR; + inputSampleR = (inputSampleR * hard) + (lastDrySampleR * (1.0-hard)); + //transitions get an intermediate dry sample + lastOutputSampleR = tempR; //only one intermediate sample + } else { + lastOutputSampleR = inputSampleR; + } + + lastDrySampleL = drySampleL; + lastDrySampleR = drySampleR; + //freq section of soft/hard interpolates dry samples + + tempL = inputSampleL; + tempR = inputSampleR; + + if (inputSampleL > 1.0) inputSampleL = 1.0; + if (inputSampleL < -1.0) inputSampleL = -1.0; + + if (inputSampleR > 1.0) inputSampleR = 1.0; + if (inputSampleR < -1.0) inputSampleR = -1.0; + + if (inputSampleL > 0) inputSampleL = log(1.0+(255*fabs(inputSampleL))) / log(256); + if (inputSampleL < 0) inputSampleL = -log(1.0+(255*fabs(inputSampleL))) / log(256); + + if (inputSampleR > 0) inputSampleR = log(1.0+(255*fabs(inputSampleR))) / log(256); + if (inputSampleR < 0) inputSampleR = -log(1.0+(255*fabs(inputSampleR))) / log(256); + + inputSampleL = (tempL * hard) + (inputSampleL * (1.0-hard)); + inputSampleR = (tempR * hard) + (inputSampleR * (1.0-hard)); //uLaw encode as part of soft/hard + + tempL = inputSampleL; + tempR = inputSampleR; + + if (incrementB > 0.0005) + { + if (inputSampleL > 0) + { + tempL = inputSampleL; + while (tempL > 0) {tempL -= incrementB;} + inputSampleL -= tempL; + //it's below 0 so subtracting adds the remainder + } + if (inputSampleR > 0) + { + tempR = inputSampleR; + while (tempR > 0) {tempR -= incrementB;} + inputSampleR -= tempR; + //it's below 0 so subtracting adds the remainder + } + + if (inputSampleL < 0) + { + tempL = inputSampleL; + while (tempL < 0) {tempL += incrementB;} + inputSampleL -= tempL; + //it's above 0 so subtracting subtracts the remainder + } + if (inputSampleR < 0) + { + tempR = inputSampleR; + while (tempR < 0) {tempR += incrementB;} + inputSampleR -= tempR; + //it's above 0 so subtracting subtracts the remainder + } + + inputSampleL *= (1.0 - incrementB); + inputSampleR *= (1.0 - incrementB); + } + + tempL = inputSampleL; + tempR = inputSampleR; + + if (inputSampleL > 1.0) inputSampleL = 1.0; + if (inputSampleL < -1.0) inputSampleL = -1.0; + + if (inputSampleR > 1.0) inputSampleR = 1.0; + if (inputSampleR < -1.0) inputSampleR = -1.0; + + if (inputSampleL > 0) inputSampleL = (pow(256,fabs(inputSampleL))-1.0) / 255; + if (inputSampleL < 0) inputSampleL = -(pow(256,fabs(inputSampleL))-1.0) / 255; + + if (inputSampleR > 0) inputSampleR = (pow(256,fabs(inputSampleR))-1.0) / 255; + if (inputSampleR < 0) inputSampleR = -(pow(256,fabs(inputSampleR))-1.0) / 255; + + inputSampleL = (tempL * hard) + (inputSampleL * (1.0-hard)); + inputSampleR = (tempR * hard) + (inputSampleR * (1.0-hard)); //uLaw decode as part of soft/hard + + if (wet !=1.0) { + inputSampleL = (inputSampleL * wet) + (drySampleL * (1.0-wet)); + inputSampleR = (inputSampleR * wet) + (drySampleR * (1.0-wet)); + } + //Dry/Wet control, defaults to the last slider + + lastSampleL = drySampleL; + lastSampleR = drySampleR; + + //begin 32 bit stereo floating point dither + int expon; frexpf((float)inputSampleL, &expon); + fpdL ^= fpdL << 13; fpdL ^= fpdL >> 17; fpdL ^= fpdL << 5; + inputSampleL += ((double(fpdL)-uint32_t(0x7fffffff)) * 5.5e-36l * pow(2,expon+62)); + frexpf((float)inputSampleR, &expon); + fpdR ^= fpdR << 13; fpdR ^= fpdR >> 17; fpdR ^= fpdR << 5; + inputSampleR += ((double(fpdR)-uint32_t(0x7fffffff)) * 5.5e-36l * pow(2,expon+62)); + //end 32 bit stereo floating point dither + + *out1 = inputSampleL; + *out2 = inputSampleR; + + *in1++; + *in2++; + *out1++; + *out2++; + } +} + +void DeRez2::processDoubleReplacing(double **inputs, double **outputs, VstInt32 sampleFrames) +{ + double* in1 = inputs[0]; + double* in2 = inputs[1]; + double* out1 = outputs[0]; + double* out2 = outputs[1]; + + double targetA = pow(A,3)+0.0005; + if (targetA > 1.0) targetA = 1.0; + double soften = (1.0 + targetA)/2; + double targetB = pow(1.0-B,3) / 3; + double hard = C; + double wet = D; + + double overallscale = 1.0; + overallscale /= 44100.0; + overallscale *= getSampleRate(); + targetA /= overallscale; + + while (--sampleFrames >= 0) + { + double inputSampleL = *in1; + double inputSampleR = *in2; + if (fabs(inputSampleL)<1.18e-23) inputSampleL = fpdL * 1.18e-17; + if (fabs(inputSampleR)<1.18e-23) inputSampleR = fpdR * 1.18e-17; + double drySampleL = inputSampleL; + double drySampleR = inputSampleR; + + + incrementA = ((incrementA*999.0)+targetA)/1000.0; + incrementB = ((incrementB*999.0)+targetB)/1000.0; + //incrementA is the frequency derez + //incrementB is the bit depth derez + position += incrementA; + + double outputSampleL = heldSampleL; + double outputSampleR = heldSampleR; + if (position > 1.0) + { + position -= 1.0; + heldSampleL = (lastSampleL * position) + (inputSampleL * (1.0-position)); + outputSampleL = (outputSampleL * (1.0-soften)) + (heldSampleL * soften); + //softens the edge of the derez + heldSampleR = (lastSampleR * position) + (inputSampleR * (1.0-position)); + outputSampleR = (outputSampleR * (1.0-soften)) + (heldSampleR * soften); + //softens the edge of the derez + } + inputSampleL = outputSampleL; + inputSampleR = outputSampleR; + + double tempL = inputSampleL; + double tempR = inputSampleR; + + if (inputSampleL != lastOutputSampleL) { + tempL = inputSampleL; + inputSampleL = (inputSampleL * hard) + (lastDrySampleL * (1.0-hard)); + //transitions get an intermediate dry sample + lastOutputSampleL = tempL; //only one intermediate sample + } else { + lastOutputSampleL = inputSampleL; + } + + if (inputSampleR != lastOutputSampleR) { + tempR = inputSampleR; + inputSampleR = (inputSampleR * hard) + (lastDrySampleR * (1.0-hard)); + //transitions get an intermediate dry sample + lastOutputSampleR = tempR; //only one intermediate sample + } else { + lastOutputSampleR = inputSampleR; + } + + lastDrySampleL = drySampleL; + lastDrySampleR = drySampleR; + //freq section of soft/hard interpolates dry samples + + tempL = inputSampleL; + tempR = inputSampleR; + + if (inputSampleL > 1.0) inputSampleL = 1.0; + if (inputSampleL < -1.0) inputSampleL = -1.0; + + if (inputSampleR > 1.0) inputSampleR = 1.0; + if (inputSampleR < -1.0) inputSampleR = -1.0; + + if (inputSampleL > 0) inputSampleL = log(1.0+(255*fabs(inputSampleL))) / log(256); + if (inputSampleL < 0) inputSampleL = -log(1.0+(255*fabs(inputSampleL))) / log(256); + + if (inputSampleR > 0) inputSampleR = log(1.0+(255*fabs(inputSampleR))) / log(256); + if (inputSampleR < 0) inputSampleR = -log(1.0+(255*fabs(inputSampleR))) / log(256); + + inputSampleL = (tempL * hard) + (inputSampleL * (1.0-hard)); + inputSampleR = (tempR * hard) + (inputSampleR * (1.0-hard)); //uLaw encode as part of soft/hard + + tempL = inputSampleL; + tempR = inputSampleR; + + if (incrementB > 0.0005) + { + if (inputSampleL > 0) + { + tempL = inputSampleL; + while (tempL > 0) {tempL -= incrementB;} + inputSampleL -= tempL; + //it's below 0 so subtracting adds the remainder + } + if (inputSampleR > 0) + { + tempR = inputSampleR; + while (tempR > 0) {tempR -= incrementB;} + inputSampleR -= tempR; + //it's below 0 so subtracting adds the remainder + } + + if (inputSampleL < 0) + { + tempL = inputSampleL; + while (tempL < 0) {tempL += incrementB;} + inputSampleL -= tempL; + //it's above 0 so subtracting subtracts the remainder + } + if (inputSampleR < 0) + { + tempR = inputSampleR; + while (tempR < 0) {tempR += incrementB;} + inputSampleR -= tempR; + //it's above 0 so subtracting subtracts the remainder + } + + inputSampleL *= (1.0 - incrementB); + inputSampleR *= (1.0 - incrementB); + } + + tempL = inputSampleL; + tempR = inputSampleR; + + if (inputSampleL > 1.0) inputSampleL = 1.0; + if (inputSampleL < -1.0) inputSampleL = -1.0; + + if (inputSampleR > 1.0) inputSampleR = 1.0; + if (inputSampleR < -1.0) inputSampleR = -1.0; + + if (inputSampleL > 0) inputSampleL = (pow(256,fabs(inputSampleL))-1.0) / 255; + if (inputSampleL < 0) inputSampleL = -(pow(256,fabs(inputSampleL))-1.0) / 255; + + if (inputSampleR > 0) inputSampleR = (pow(256,fabs(inputSampleR))-1.0) / 255; + if (inputSampleR < 0) inputSampleR = -(pow(256,fabs(inputSampleR))-1.0) / 255; + + inputSampleL = (tempL * hard) + (inputSampleL * (1.0-hard)); + inputSampleR = (tempR * hard) + (inputSampleR * (1.0-hard)); //uLaw decode as part of soft/hard + + if (wet !=1.0) { + inputSampleL = (inputSampleL * wet) + (drySampleL * (1.0-wet)); + inputSampleR = (inputSampleR * wet) + (drySampleR * (1.0-wet)); + } + //Dry/Wet control, defaults to the last slider + + lastSampleL = drySampleL; + lastSampleR = drySampleR; + + //begin 64 bit stereo floating point dither + //int expon; frexp((double)inputSampleL, &expon); + fpdL ^= fpdL << 13; fpdL ^= fpdL >> 17; fpdL ^= fpdL << 5; + //inputSampleL += ((double(fpdL)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62)); + //frexp((double)inputSampleR, &expon); + fpdR ^= fpdR << 13; fpdR ^= fpdR >> 17; fpdR ^= fpdR << 5; + //inputSampleR += ((double(fpdR)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62)); + //end 64 bit stereo floating point dither + + *out1 = inputSampleL; + *out2 = inputSampleR; + + *in1++; + *in2++; + *out1++; + *out2++; + } +} diff --git a/plugin/Source/FX/FXBase.h b/plugin/Source/FX/FXBase.h new file mode 100755 index 0000000..468fed8 --- /dev/null +++ b/plugin/Source/FX/FXBase.h @@ -0,0 +1,108 @@ +#pragma once + +#include + +#define VstInt32 int32_t +#define AudioEffect FXBase +#define AudioEffectX FXBase +#define audioMasterCallback FXBaseCallback +#define VstPlugCategory int +#define kPlugCategEffect 1 +#define kVstMaxProgNameLen 32 +#define kVstMaxParamStrLen 32 +#define kVstMaxProductStrLen 32 +#define kVstMaxVendorStrLen 32 +#define vst_strncpy strncpy + +inline void float2string (float f, char* text, int len) +{ + int decimals = 0; + if (std::fabs (f) >= 10.0f) + decimals = 1; + else if (std::fabs (f) > 1.0f) + decimals = 2; + else + decimals = 3; + + juce::String str (f, decimals); + str.copyToUTF8 (text, (size_t)len); +} + +inline void int2string (float i, char* text, int len) +{ + juce::String str (i); + str.copyToUTF8 (text, (size_t)len); +} + +inline void dB2string (float value, char* text, int maxLen) +{ + if (value <= 0) + vst_strncpy (text, "-oo", (size_t) maxLen); + else + float2string (20.0f * log10 (value), text, maxLen); +} + +//============================================================================== +class FXBaseCallback +{ +public: + FXBaseCallback (std::function cb_) : cb (cb_) {} + + double getSampleRate() + { + return cb(); + } + + std::function cb; +}; + +//============================================================================== +class FXBase +{ +public: + //============================================================================== + FXBase (FXBaseCallback c, int numPrograms_, int numParams_) + : numPrograms (numPrograms_), numParams (numParams_), callback (c) + { + } + + virtual ~FXBase() = default; + + int getNumInputs() { return numInputs; } + int getNumOutputs() { return numOutputs; } + int getNumParameters() { return numParams; } + + //============================================================================== + virtual bool getEffectName(char* name) = 0; + virtual VstPlugCategory getPlugCategory() = 0; + virtual bool getProductString(char* text) = 0; + virtual bool getVendorString(char* text) = 0; + virtual VstInt32 getVendorVersion() = 0; + virtual void processReplacing (float** inputs, float** outputs, VstInt32 sampleFrames) = 0; + virtual void processDoubleReplacing (double** inputs, double** outputs, VstInt32 sampleFrames) = 0; + virtual void getProgramName(char* name) = 0; + virtual void setProgramName(char* name) = 0; + virtual VstInt32 getChunk (void** data, bool isPreset) { juce::ignoreUnused (data, isPreset); return 0; } + virtual VstInt32 setChunk (void* data, VstInt32 byteSize, bool isPreset) { juce::ignoreUnused (data, byteSize, isPreset); return 0; } + virtual float getParameter(VstInt32 index) { juce::ignoreUnused (index); return 0; } + virtual void setParameter(VstInt32 index, float value) { juce::ignoreUnused (index, value); } + virtual void getParameterLabel(VstInt32 index, char* text) { juce::ignoreUnused (index, text); } + virtual void getParameterName(VstInt32 index, char* text) { juce::ignoreUnused (index, text); } + virtual void getParameterDisplay(VstInt32 index, char* text) { juce::ignoreUnused (index, text); } + virtual VstInt32 canDo(char *text) = 0; + +protected: + //============================================================================== + void setNumInputs (int numIn) { numInputs = numIn; } + void setNumOutputs (int numOut) { numOutputs = numOut; } + void setUniqueID (int) {} + void canProcessReplacing() {} + void canDoubleReplacing() {} + void programsAreChunks (bool) {} + + int numInputs = 0, numOutputs = 0, numPrograms = 0, numParams = 0; + + FXBaseCallback callback; + + double getSampleRate() { return callback.getSampleRate(); } +}; diff --git a/plugin/Source/FX/FireAmp.cpp b/plugin/Source/FX/FireAmp.cpp new file mode 100755 index 0000000..dfefd44 --- /dev/null +++ b/plugin/Source/FX/FireAmp.cpp @@ -0,0 +1,238 @@ +/* ======================================== + * FireAmp - FireAmp.h + * Copyright (c) 2016 airwindows, Airwindows uses the MIT license + * ======================================== */ + +#ifndef __Gain_H +#include "FireAmp.h" +#endif + +JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wfloat-conversion", "-Wimplicit-float-conversion", "-Wunused-parameter") + +FireAmp::FireAmp(audioMasterCallback audioMaster) : + AudioEffectX(audioMaster, kNumPrograms, kNumParameters) +{ + A = 0.5; + B = 0.5; + C = 0.8; + D = 1.0; + + lastSampleL = 0.0; + storeSampleL = 0.0; + smoothAL = 0.0; + smoothBL = 0.0; + smoothCL = 0.0; + smoothDL = 0.0; + smoothEL = 0.0; + smoothFL = 0.0; + smoothGL = 0.0; + smoothHL = 0.0; + smoothIL = 0.0; + smoothJL = 0.0; + smoothKL = 0.0; + smoothLL = 0.0; + iirSampleAL = 0.0; + iirSampleBL = 0.0; + iirSampleCL = 0.0; + iirSampleDL = 0.0; + iirSampleEL = 0.0; + iirSampleFL = 0.0; + iirSampleGL = 0.0; + iirSampleHL = 0.0; + iirSampleIL = 0.0; + iirSampleJL = 0.0; + iirSampleKL = 0.0; + iirSampleLL = 0.0; + iirLowpassL = 0.0; + iirSpkAL = 0.0; + iirSpkBL = 0.0; + iirSubL = 0.0; + + lastSampleR = 0.0; + storeSampleR = 0.0; + smoothAR = 0.0; + smoothBR = 0.0; + smoothCR = 0.0; + smoothDR = 0.0; + smoothER = 0.0; + smoothFR = 0.0; + smoothGR = 0.0; + smoothHR = 0.0; + smoothIR = 0.0; + smoothJR = 0.0; + smoothKR = 0.0; + smoothLR = 0.0; + iirSampleAR = 0.0; + iirSampleBR = 0.0; + iirSampleCR = 0.0; + iirSampleDR = 0.0; + iirSampleER = 0.0; + iirSampleFR = 0.0; + iirSampleGR = 0.0; + iirSampleHR = 0.0; + iirSampleIR = 0.0; + iirSampleJR = 0.0; + iirSampleKR = 0.0; + iirSampleLR = 0.0; + iirLowpassR = 0.0; + iirSpkAR = 0.0; + iirSpkBR = 0.0; + iirSubR = 0.0; + + for (int fcount = 0; fcount < 257; fcount++) { + OddL[fcount] = 0.0; + EvenL[fcount] = 0.0; + OddR[fcount] = 0.0; + EvenR[fcount] = 0.0; + } + + count = 0; + flip = false; //amp + + for(int fcount = 0; fcount < 90; fcount++) { + bL[fcount] = 0; + bR[fcount] = 0; + } + smoothCabAL = 0.0; smoothCabBL = 0.0; lastCabSampleL = 0.0; //cab + smoothCabAR = 0.0; smoothCabBR = 0.0; lastCabSampleR = 0.0; //cab + + for (int fcount = 0; fcount < 9; fcount++) { + lastRefL[fcount] = 0.0; + lastRefR[fcount] = 0.0; + } + cycle = 0; //undersampling + + for (int x = 0; x < fix_total; x++) { + fixA[x] = 0.0; + fixB[x] = 0.0; + fixC[x] = 0.0; + fixD[x] = 0.0; + fixE[x] = 0.0; + fixF[x] = 0.0; + } //filtering + + 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 +} + +FireAmp::~FireAmp() {} +VstInt32 FireAmp::getVendorVersion () {return 1000;} +void FireAmp::setProgramName(char *name) {vst_strncpy (_programName, name, kVstMaxProgNameLen);} +void FireAmp::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 FireAmp::getChunk (void** data, bool isPreset) +{ + float *chunkData = (float *)calloc(kNumParameters, sizeof(float)); + chunkData[0] = A; + chunkData[1] = B; + chunkData[2] = C; + chunkData[3] = D; + /* 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 FireAmp::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]); + /* 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 FireAmp::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; + default: throw; // unknown parameter, shouldn't happen! + } +} + +float FireAmp::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; + default: break; // unknown parameter, shouldn't happen! + } return 0.0; //we only need to update the relevant name, this is simple to manage +} + +void FireAmp::getParameterName(VstInt32 index, char *text) { + switch (index) { + case kParamA: vst_strncpy (text, "Gain", kVstMaxParamStrLen); break; + case kParamB: vst_strncpy (text, "Tone", kVstMaxParamStrLen); break; + case kParamC: vst_strncpy (text, "Output", kVstMaxParamStrLen); break; + case kParamD: 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 FireAmp::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; + case kParamD: float2string (D, text, kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } //this displays the values and handles 'popups' where it's discrete choices +} + +void FireAmp::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; + default: break; // unknown parameter, shouldn't happen! + } +} + +VstInt32 FireAmp::canDo(char *text) +{ return (_canDo.find(text) == _canDo.end()) ? -1: 1; } // 1 = yes, -1 = no, 0 = don't know + +bool FireAmp::getEffectName(char* name) { + vst_strncpy(name, "FireAmp", kVstMaxProductStrLen); return true; +} + +VstPlugCategory FireAmp::getPlugCategory() {return kPlugCategEffect;} + +bool FireAmp::getProductString(char* text) { + vst_strncpy (text, "airwindows FireAmp", kVstMaxProductStrLen); return true; +} + +bool FireAmp::getVendorString(char* text) { + vst_strncpy (text, "airwindows", kVstMaxVendorStrLen); return true; +} diff --git a/plugin/Source/FX/FireAmp.h b/plugin/Source/FX/FireAmp.h new file mode 100755 index 0000000..b9c0043 --- /dev/null +++ b/plugin/Source/FX/FireAmp.h @@ -0,0 +1,168 @@ +/* ======================================== + * FireAmp - FireAmp.h + * Created 8/12/11 by SPIAdmin + * Copyright (c) 2011 __MyCompanyName__, Airwindows uses the MIT license + * ======================================== */ + +#pragma once + +#include "FXBase.h" + +#include +#include +#include + +class FireAmp : + public AudioEffectX +{ +public: + enum { + kParamA = 0, + kParamB = 1, + kParamC = 2, + kParamD = 3, + kNumParameters = 4 + }; // + + static constexpr int kNumPrograms = 0; + static constexpr int kNumInputs = 2; + static constexpr int kNumOutputs = 2; + static constexpr unsigned long kUniqueId = 'fira'; //Change this to what the AU identity is! + + FireAmp(audioMasterCallback audioMaster); + ~FireAmp(); + 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; + + + double lastSampleL; + double storeSampleL; + double smoothAL; + double smoothBL; + double smoothCL; + double smoothDL; + double smoothEL; + double smoothFL; + double smoothGL; + double smoothHL; + double smoothIL; + double smoothJL; + double smoothKL; + double smoothLL; + double iirSampleAL; + double iirSampleBL; + double iirSampleCL; + double iirSampleDL; + double iirSampleEL; + double iirSampleFL; + double iirSampleGL; + double iirSampleHL; + double iirSampleIL; + double iirSampleJL; + double iirSampleKL; + double iirSampleLL; + double iirLowpassL; + double iirSpkAL; + double iirSpkBL; + double iirSubL; + double OddL[257]; + double EvenL[257]; + + double lastSampleR; + double storeSampleR; + double smoothAR; + double smoothBR; + double smoothCR; + double smoothDR; + double smoothER; + double smoothFR; + double smoothGR; + double smoothHR; + double smoothIR; + double smoothJR; + double smoothKR; + double smoothLR; + double iirSampleAR; + double iirSampleBR; + double iirSampleCR; + double iirSampleDR; + double iirSampleER; + double iirSampleFR; + double iirSampleGR; + double iirSampleHR; + double iirSampleIR; + double iirSampleJR; + double iirSampleKR; + double iirSampleLR; + double iirLowpassR; + double iirSpkAR; + double iirSpkBR; + double iirSubR; + double OddR[257]; + double EvenR[257]; + + bool flip; + int count; //amp + + double bL[90]; + double lastCabSampleL; + double smoothCabAL; + double smoothCabBL; //cab + + double bR[90]; + double lastCabSampleR; + double smoothCabAR; + double smoothCabBR; //cab + + double lastRefL[10]; + double lastRefR[10]; + int cycle; //undersampling + + enum { + fix_freq, + fix_reso, + fix_a0, + fix_a1, + fix_a2, + fix_b1, + fix_b2, + fix_sL1, + fix_sL2, + fix_sR1, + fix_sR2, + fix_total + }; //fixed frequency biquad filter for ultrasonics, stereo + double fixA[fix_total]; + double fixB[fix_total]; + double fixC[fix_total]; + double fixD[fix_total]; + double fixE[fix_total]; + double fixF[fix_total]; //filtering + + uint32_t fpdL; + uint32_t fpdR; + //default stuff + + float A; + float B; + float C; + float D; +}; diff --git a/plugin/Source/FX/FireAmpProc.cpp b/plugin/Source/FX/FireAmpProc.cpp new file mode 100755 index 0000000..60dcc63 --- /dev/null +++ b/plugin/Source/FX/FireAmpProc.cpp @@ -0,0 +1,1709 @@ +/* ======================================== + * FireAmp - FireAmp.h + * Copyright (c) 2016 airwindows, Airwindows uses the MIT license + * ======================================== */ + +#ifndef __Gain_H +#include "FireAmp.h" +#endif + +JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wfloat-conversion", "-Wimplicit-float-conversion", "-Wunused-parameter") + +void FireAmp::processReplacing(float **inputs, float **outputs, VstInt32 sampleFrames) +{ + float* in1 = inputs[0]; + float* in2 = inputs[1]; + float* out1 = outputs[0]; + float* out2 = outputs[1]; + + double bassfill = A; + double outputlevel = C; + double wet = D; + + double overallscale = 1.0; + overallscale /= 44100.0; + overallscale *= getSampleRate(); + int cycleEnd = floor(overallscale); + if (cycleEnd < 1) cycleEnd = 1; + if (cycleEnd > 4) cycleEnd = 4; + //this is going to be 2 for 88.1 or 96k, 3 for silly people, 4 for 176 or 192k + if (cycle > cycleEnd-1) cycle = cycleEnd-1; //sanity check + + double startlevel = bassfill; + double samplerate = getSampleRate(); + double basstrim = bassfill / 16.0; + double toneEQ = (B / samplerate)*22050.0; + double EQ = (basstrim / samplerate)*22050.0; + double bleed = outputlevel/16.0; + double bassfactor = 1.0-(basstrim*basstrim); + double BEQ = (bleed / samplerate)*22050.0; + int diagonal = (int)(0.000861678*samplerate); + if (diagonal > 127) diagonal = 127; + int side = (int)(diagonal/1.4142135623730951); + int down = (side + diagonal)/2; + //now we've got down, side and diagonal as offsets and we also use three successive samples upfront + + double cutoff = (15000.0+(B*10000.0)) / getSampleRate(); + if (cutoff > 0.49) cutoff = 0.49; //don't crash if run at 44.1k + if (cutoff < 0.001) cutoff = 0.001; //or if cutoff's too low + + fixF[fix_freq] = fixE[fix_freq] = fixD[fix_freq] = fixC[fix_freq] = fixB[fix_freq] = fixA[fix_freq] = cutoff; + + fixA[fix_reso] = 4.46570214; + fixB[fix_reso] = 1.51387132; + fixC[fix_reso] = 0.93979296; + fixD[fix_reso] = 0.70710678; + fixE[fix_reso] = 0.52972649; + fixF[fix_reso] = 0.50316379; + + double K = tan(M_PI * fixA[fix_freq]); //lowpass + double norm = 1.0 / (1.0 + K / fixA[fix_reso] + K * K); + fixA[fix_a0] = K * K * norm; + fixA[fix_a1] = 2.0 * fixA[fix_a0]; + fixA[fix_a2] = fixA[fix_a0]; + fixA[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixA[fix_b2] = (1.0 - K / fixA[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixB[fix_freq]); + norm = 1.0 / (1.0 + K / fixB[fix_reso] + K * K); + fixB[fix_a0] = K * K * norm; + fixB[fix_a1] = 2.0 * fixB[fix_a0]; + fixB[fix_a2] = fixB[fix_a0]; + fixB[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixB[fix_b2] = (1.0 - K / fixB[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixC[fix_freq]); + norm = 1.0 / (1.0 + K / fixC[fix_reso] + K * K); + fixC[fix_a0] = K * K * norm; + fixC[fix_a1] = 2.0 * fixC[fix_a0]; + fixC[fix_a2] = fixC[fix_a0]; + fixC[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixC[fix_b2] = (1.0 - K / fixC[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixD[fix_freq]); + norm = 1.0 / (1.0 + K / fixD[fix_reso] + K * K); + fixD[fix_a0] = K * K * norm; + fixD[fix_a1] = 2.0 * fixD[fix_a0]; + fixD[fix_a2] = fixD[fix_a0]; + fixD[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixD[fix_b2] = (1.0 - K / fixD[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixE[fix_freq]); + norm = 1.0 / (1.0 + K / fixE[fix_reso] + K * K); + fixE[fix_a0] = K * K * norm; + fixE[fix_a1] = 2.0 * fixE[fix_a0]; + fixE[fix_a2] = fixE[fix_a0]; + fixE[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixE[fix_b2] = (1.0 - K / fixE[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixF[fix_freq]); + norm = 1.0 / (1.0 + K / fixF[fix_reso] + K * K); + fixF[fix_a0] = K * K * norm; + fixF[fix_a1] = 2.0 * fixF[fix_a0]; + fixF[fix_a2] = fixF[fix_a0]; + fixF[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixF[fix_b2] = (1.0 - K / fixF[fix_reso] + K * K) * norm; + + while (--sampleFrames >= 0) + { + double inputSampleL = *in1; + double inputSampleR = *in2; + if (fabs(inputSampleL)<1.18e-23) inputSampleL = fpdL * 1.18e-17; + if (fabs(inputSampleR)<1.18e-23) inputSampleR = fpdR * 1.18e-17; + double drySampleL = inputSampleL; + double drySampleR = inputSampleR; + + + double outSample = (inputSampleL * fixA[fix_a0]) + fixA[fix_sL1]; + fixA[fix_sL1] = (inputSampleL * fixA[fix_a1]) - (outSample * fixA[fix_b1]) + fixA[fix_sL2]; + fixA[fix_sL2] = (inputSampleL * fixA[fix_a2]) - (outSample * fixA[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixA[fix_a0]) + fixA[fix_sR1]; + fixA[fix_sR1] = (inputSampleR * fixA[fix_a1]) - (outSample * fixA[fix_b1]) + fixA[fix_sR2]; + fixA[fix_sR2] = (inputSampleR * fixA[fix_a2]) - (outSample * fixA[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + if (inputSampleL > 1.0) inputSampleL = 1.0; + if (inputSampleL < -1.0) inputSampleL = -1.0; + double basscutL = 0.98; + //we're going to be shifting this as the stages progress + double inputlevelL = startlevel; + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleAL = (iirSampleAL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleAL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + double bridgerectifier = (smoothAL + inputSampleL); + smoothAL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleBL = (iirSampleBL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleBL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothBL + inputSampleL); + smoothBL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + + if (inputSampleR > 1.0) inputSampleR = 1.0; + if (inputSampleR < -1.0) inputSampleR = -1.0; + double basscutR = 0.98; + //we're going to be shifting this as the stages progress + double inputlevelR = startlevel; + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleAR = (iirSampleAR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleAR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654) ); + //overdrive + bridgerectifier = (smoothAR + inputSampleR); + smoothAR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleBR = (iirSampleBR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleBR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654) ); + //overdrive + bridgerectifier = (smoothBR + inputSampleR); + smoothBR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + + + outSample = (inputSampleL * fixB[fix_a0]) + fixB[fix_sL1]; + fixB[fix_sL1] = (inputSampleL * fixB[fix_a1]) - (outSample * fixB[fix_b1]) + fixB[fix_sL2]; + fixB[fix_sL2] = (inputSampleL * fixB[fix_a2]) - (outSample * fixB[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixB[fix_a0]) + fixB[fix_sR1]; + fixB[fix_sR1] = (inputSampleR * fixB[fix_a1]) - (outSample * fixB[fix_b1]) + fixB[fix_sR2]; + fixB[fix_sR2] = (inputSampleR * fixB[fix_a2]) - (outSample * fixB[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleCL = (iirSampleCL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleCL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothCL + inputSampleL); + smoothCL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleDL = (iirSampleDL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleDL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654) ); + //overdrive + bridgerectifier = (smoothDL + inputSampleL); + smoothDL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + + + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleCR = (iirSampleCR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleCR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654)); + //overdrive + bridgerectifier = (smoothCR + inputSampleR); + smoothCR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleDR = (iirSampleDR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleDR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654) ); + //overdrive + bridgerectifier = (smoothDR + inputSampleR); + smoothDR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + + outSample = (inputSampleL * fixC[fix_a0]) + fixC[fix_sL1]; + fixC[fix_sL1] = (inputSampleL * fixC[fix_a1]) - (outSample * fixC[fix_b1]) + fixC[fix_sL2]; + fixC[fix_sL2] = (inputSampleL * fixC[fix_a2]) - (outSample * fixC[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixC[fix_a0]) + fixC[fix_sR1]; + fixC[fix_sR1] = (inputSampleR * fixC[fix_a1]) - (outSample * fixC[fix_b1]) + fixC[fix_sR2]; + fixC[fix_sR2] = (inputSampleR * fixC[fix_a2]) - (outSample * fixC[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleEL = (iirSampleEL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleEL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothEL + inputSampleL); + smoothEL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleFL = (iirSampleFL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleFL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothFL + inputSampleL); + smoothFL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + + + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleER = (iirSampleER * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleER*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654)); + //overdrive + bridgerectifier = (smoothER + inputSampleR); + smoothER = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleFR = (iirSampleFR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleFR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654)); + //overdrive + bridgerectifier = (smoothFR + inputSampleR); + smoothFR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + + outSample = (inputSampleL * fixD[fix_a0]) + fixD[fix_sL1]; + fixD[fix_sL1] = (inputSampleL * fixD[fix_a1]) - (outSample * fixD[fix_b1]) + fixD[fix_sL2]; + fixD[fix_sL2] = (inputSampleL * fixD[fix_a2]) - (outSample * fixD[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixD[fix_a0]) + fixD[fix_sR1]; + fixD[fix_sR1] = (inputSampleR * fixD[fix_a1]) - (outSample * fixD[fix_b1]) + fixD[fix_sR2]; + fixD[fix_sR2] = (inputSampleR * fixD[fix_a2]) - (outSample * fixD[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleGL = (iirSampleGL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleGL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothGL + inputSampleL); + smoothGL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleHL = (iirSampleHL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleHL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothHL + inputSampleL); + smoothHL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + + + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleGR = (iirSampleGR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleGR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654)); + //overdrive + bridgerectifier = (smoothGR + inputSampleR); + smoothGR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleHR = (iirSampleHR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleHR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654)); + //overdrive + bridgerectifier = (smoothHR + inputSampleR); + smoothHR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + + outSample = (inputSampleL * fixE[fix_a0]) + fixE[fix_sL1]; + fixE[fix_sL1] = (inputSampleL * fixE[fix_a1]) - (outSample * fixE[fix_b1]) + fixE[fix_sL2]; + fixE[fix_sL2] = (inputSampleL * fixE[fix_a2]) - (outSample * fixE[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixE[fix_a0]) + fixE[fix_sR1]; + fixE[fix_sR1] = (inputSampleR * fixE[fix_a1]) - (outSample * fixE[fix_b1]) + fixE[fix_sR2]; + fixE[fix_sR2] = (inputSampleR * fixE[fix_a2]) - (outSample * fixE[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleIL = (iirSampleIL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleIL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothIL + inputSampleL); + smoothIL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleJL = (iirSampleJL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleJL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothJL + inputSampleL); + smoothJL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + + + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleIR = (iirSampleIR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleIR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654)); + //overdrive + bridgerectifier = (smoothIR + inputSampleR); + smoothIR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleJR = (iirSampleJR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleJR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654)); + //overdrive + bridgerectifier = (smoothJR + inputSampleR); + smoothJR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + + outSample = (inputSampleL * fixF[fix_a0]) + fixF[fix_sL1]; + fixF[fix_sL1] = (inputSampleL * fixF[fix_a1]) - (outSample * fixF[fix_b1]) + fixF[fix_sL2]; + fixF[fix_sL2] = (inputSampleL * fixF[fix_a2]) - (outSample * fixF[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixF[fix_a0]) + fixF[fix_sR1]; + fixF[fix_sR1] = (inputSampleR * fixF[fix_a1]) - (outSample * fixF[fix_b1]) + fixF[fix_sR2]; + fixF[fix_sR2] = (inputSampleR * fixF[fix_a2]) - (outSample * fixF[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleKL = (iirSampleKL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleKL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothKL + inputSampleL); + smoothKL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleLL = (iirSampleLL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleLL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothLL + inputSampleL); + smoothLL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + + + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleKR = (iirSampleKR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleKR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654)); + //overdrive + bridgerectifier = (smoothKR + inputSampleR); + smoothKR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleLR = (iirSampleLR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleLR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654)); + //overdrive + bridgerectifier = (smoothLR + inputSampleR); + smoothLR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + + iirLowpassL = (iirLowpassL * (1.0 - toneEQ)) + (inputSampleL * toneEQ); + inputSampleL = iirLowpassL; + //lowpass. The only one of this type. + iirLowpassR = (iirLowpassR * (1.0 - toneEQ)) + (inputSampleR * toneEQ); + inputSampleR = iirLowpassR; + //lowpass. The only one of this type. + + iirSpkAL = (iirSpkAL * (1.0 - BEQ)) + (inputSampleL * BEQ); + //extra lowpass for 4*12" speakers + iirSpkAR = (iirSpkAR * (1.0 - BEQ)) + (inputSampleR * BEQ); + //extra lowpass for 4*12" speakers + + if (count < 0 || count > 128) {count = 128;} + double resultBL = 0.0; + double resultBR = 0.0; + if (flip) + { + OddL[count+128] = OddL[count] = iirSpkAL; + resultBL = (OddL[count+down] + OddL[count+side] + OddL[count+diagonal]); + OddR[count+128] = OddR[count] = iirSpkAR; + resultBR = (OddR[count+down] + OddR[count+side] + OddR[count+diagonal]); + } + else + { + EvenL[count+128] = EvenL[count] = iirSpkAL; + resultBL = (EvenL[count+down] + EvenL[count+side] + EvenL[count+diagonal]); + EvenR[count+128] = EvenR[count] = iirSpkAR; + resultBR = (EvenR[count+down] + EvenR[count+side] + EvenR[count+diagonal]); + } + count--; + iirSpkBL = (iirSpkBL * (1.0 - BEQ)) + (resultBL * BEQ); + inputSampleL += (iirSpkBL * bleed); + //extra lowpass for 4*12" speakers + iirSpkBR = (iirSpkBR * (1.0 - BEQ)) + (resultBR * BEQ); + inputSampleR += (iirSpkBR * bleed); + //extra lowpass for 4*12" speakers + + bridgerectifier = fabs(inputSampleL*outputlevel); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (inputSampleL > 0) inputSampleL = bridgerectifier; + else inputSampleL = -bridgerectifier; + + bridgerectifier = fabs(inputSampleR*outputlevel); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (inputSampleR > 0) inputSampleR = bridgerectifier; + else inputSampleR = -bridgerectifier; + + iirSubL = (iirSubL * (1.0 - BEQ)) + (inputSampleL * BEQ); + inputSampleL += (iirSubL * bassfill * outputlevel); + + iirSubR = (iirSubR * (1.0 - BEQ)) + (inputSampleR * BEQ); + inputSampleR += (iirSubR * bassfill * outputlevel); + + double randy = ((double(fpdL)/UINT32_MAX)*0.053); + inputSampleL = ((inputSampleL*(1.0-randy))+(storeSampleL*randy))*outputlevel; + storeSampleL = inputSampleL; + + randy = ((double(fpdR)/UINT32_MAX)*0.053); + inputSampleR = ((inputSampleR*(1.0-randy))+(storeSampleR*randy))*outputlevel; + storeSampleR = inputSampleR; + + flip = !flip; + + if (wet !=1.0) { + inputSampleL = (inputSampleL * wet) + (drySampleL * (1.0-wet)); + inputSampleR = (inputSampleR * wet) + (drySampleR * (1.0-wet)); + } + //Dry/Wet control, defaults to the last slider + //amp + + cycle++; + if (cycle == cycleEnd) { + double temp = (inputSampleL + smoothCabAL)/3.0; + smoothCabAL = inputSampleL; + inputSampleL = temp; + + bL[84] = bL[83]; bL[83] = bL[82]; bL[82] = bL[81]; bL[81] = bL[80]; bL[80] = bL[79]; + bL[79] = bL[78]; bL[78] = bL[77]; bL[77] = bL[76]; bL[76] = bL[75]; bL[75] = bL[74]; bL[74] = bL[73]; bL[73] = bL[72]; bL[72] = bL[71]; + bL[71] = bL[70]; bL[70] = bL[69]; bL[69] = bL[68]; bL[68] = bL[67]; bL[67] = bL[66]; bL[66] = bL[65]; bL[65] = bL[64]; bL[64] = bL[63]; + bL[63] = bL[62]; bL[62] = bL[61]; bL[61] = bL[60]; bL[60] = bL[59]; bL[59] = bL[58]; bL[58] = bL[57]; bL[57] = bL[56]; bL[56] = bL[55]; + bL[55] = bL[54]; bL[54] = bL[53]; bL[53] = bL[52]; bL[52] = bL[51]; bL[51] = bL[50]; bL[50] = bL[49]; bL[49] = bL[48]; bL[48] = bL[47]; + bL[47] = bL[46]; bL[46] = bL[45]; bL[45] = bL[44]; bL[44] = bL[43]; bL[43] = bL[42]; bL[42] = bL[41]; bL[41] = bL[40]; bL[40] = bL[39]; + bL[39] = bL[38]; bL[38] = bL[37]; bL[37] = bL[36]; bL[36] = bL[35]; bL[35] = bL[34]; bL[34] = bL[33]; bL[33] = bL[32]; bL[32] = bL[31]; + bL[31] = bL[30]; bL[30] = bL[29]; bL[29] = bL[28]; bL[28] = bL[27]; bL[27] = bL[26]; bL[26] = bL[25]; bL[25] = bL[24]; bL[24] = bL[23]; + bL[23] = bL[22]; bL[22] = bL[21]; bL[21] = bL[20]; bL[20] = bL[19]; bL[19] = bL[18]; bL[18] = bL[17]; bL[17] = bL[16]; bL[16] = bL[15]; + bL[15] = bL[14]; bL[14] = bL[13]; bL[13] = bL[12]; bL[12] = bL[11]; bL[11] = bL[10]; bL[10] = bL[9]; bL[9] = bL[8]; bL[8] = bL[7]; + bL[7] = bL[6]; bL[6] = bL[5]; bL[5] = bL[4]; bL[4] = bL[3]; bL[3] = bL[2]; bL[2] = bL[1]; bL[1] = bL[0]; bL[0] = inputSampleL; + inputSampleL += (bL[1] * (1.31698250313308396 - (0.08140616497621633*fabs(bL[1])))); + inputSampleL += (bL[2] * (1.47229016949915326 - (0.27680278993637253*fabs(bL[2])))); + inputSampleL += (bL[3] * (1.30410109086044956 - (0.35629113432046489*fabs(bL[3])))); + inputSampleL += (bL[4] * (0.81766210474551260 - (0.26808782337659753*fabs(bL[4])))); + inputSampleL += (bL[5] * (0.19868872545506663 - (0.11105517193919669*fabs(bL[5])))); + inputSampleL -= (bL[6] * (0.39115909132567039 - (0.12630622002682679*fabs(bL[6])))); + inputSampleL -= (bL[7] * (0.76881891559343574 - (0.40879849500403143*fabs(bL[7])))); + inputSampleL -= (bL[8] * (0.87146861782680340 - (0.59529560488000599*fabs(bL[8])))); + inputSampleL -= (bL[9] * (0.79504575932563670 - (0.60877047551611796*fabs(bL[9])))); + inputSampleL -= (bL[10] * (0.61653017622406314 - (0.47662851438557335*fabs(bL[10])))); + inputSampleL -= (bL[11] * (0.40718195794382067 - (0.24955839378539713*fabs(bL[11])))); + inputSampleL -= (bL[12] * (0.31794900040616203 - (0.04169792259600613*fabs(bL[12])))); + inputSampleL -= (bL[13] * (0.41075032540217843 + (0.00368483996076280*fabs(bL[13])))); + inputSampleL -= (bL[14] * (0.56901352922170667 - (0.11027360805893105*fabs(bL[14])))); + inputSampleL -= (bL[15] * (0.62443222391889264 - (0.22198075154245228*fabs(bL[15])))); + inputSampleL -= (bL[16] * (0.53462856723129204 - (0.22933544545324852*fabs(bL[16])))); + inputSampleL -= (bL[17] * (0.34441703361995046 - (0.12956809502269492*fabs(bL[17])))); + inputSampleL -= (bL[18] * (0.13947052337867882 + (0.00339775055962799*fabs(bL[18])))); + inputSampleL += (bL[19] * (0.03771252648928484 - (0.10863931549251718*fabs(bL[19])))); + inputSampleL += (bL[20] * (0.18280210770271693 - (0.17413646599296417*fabs(bL[20])))); + inputSampleL += (bL[21] * (0.24621986701761467 - (0.14547053270435095*fabs(bL[21])))); + inputSampleL += (bL[22] * (0.22347075142737360 - (0.02493869490104031*fabs(bL[22])))); + inputSampleL += (bL[23] * (0.14346348482123716 + (0.11284054747963246*fabs(bL[23])))); + inputSampleL += (bL[24] * (0.00834364862916028 + (0.24284684053733926*fabs(bL[24])))); + inputSampleL -= (bL[25] * (0.11559740296078347 - (0.32623054435304538*fabs(bL[25])))); + inputSampleL -= (bL[26] * (0.18067604561283060 - (0.32311481551122478*fabs(bL[26])))); + inputSampleL -= (bL[27] * (0.22927997789035612 - (0.26991539052832925*fabs(bL[27])))); + inputSampleL -= (bL[28] * (0.28487666578669446 - (0.22437227250279349*fabs(bL[28])))); + inputSampleL -= (bL[29] * (0.31992973037153838 - (0.15289876100963865*fabs(bL[29])))); + inputSampleL -= (bL[30] * (0.35174606303520733 - (0.05656293023086628*fabs(bL[30])))); + inputSampleL -= (bL[31] * (0.36894898011375254 + (0.04333925421463558*fabs(bL[31])))); + inputSampleL -= (bL[32] * (0.32567576055307507 + (0.14594589410921388*fabs(bL[32])))); + inputSampleL -= (bL[33] * (0.27440135050585784 + (0.15529667398122521*fabs(bL[33])))); + inputSampleL -= (bL[34] * (0.21998973785078091 + (0.05083553737157104*fabs(bL[34])))); + inputSampleL -= (bL[35] * (0.10323624876862457 - (0.04651829594199963*fabs(bL[35])))); + inputSampleL += (bL[36] * (0.02091603687851074 + (0.12000046818439322*fabs(bL[36])))); + inputSampleL += (bL[37] * (0.11344930914138468 + (0.17697142512225839*fabs(bL[37])))); + inputSampleL += (bL[38] * (0.22766779627643968 + (0.13645102964003858*fabs(bL[38])))); + inputSampleL += (bL[39] * (0.38378309953638229 - (0.01997653307333791*fabs(bL[39])))); + inputSampleL += (bL[40] * (0.52789400804568076 - (0.21409137428422448*fabs(bL[40])))); + inputSampleL += (bL[41] * (0.55444630296938280 - (0.32331980931576626*fabs(bL[41])))); + inputSampleL += (bL[42] * (0.42333237669264601 - (0.26855847463044280*fabs(bL[42])))); + inputSampleL += (bL[43] * (0.21942831522035078 - (0.12051365248820624*fabs(bL[43])))); + inputSampleL -= (bL[44] * (0.00584169427830633 - (0.03706970171280329*fabs(bL[44])))); + inputSampleL -= (bL[45] * (0.24279799124660351 - (0.17296440491477982*fabs(bL[45])))); + inputSampleL -= (bL[46] * (0.40173760787507085 - (0.21717989835163351*fabs(bL[46])))); + inputSampleL -= (bL[47] * (0.43930035724188155 - (0.16425928481378199*fabs(bL[47])))); + inputSampleL -= (bL[48] * (0.41067765934041811 - (0.10390115786636855*fabs(bL[48])))); + inputSampleL -= (bL[49] * (0.34409235547165967 - (0.07268159377411920*fabs(bL[49])))); + inputSampleL -= (bL[50] * (0.26542883122568151 - (0.05483457497365785*fabs(bL[50])))); + inputSampleL -= (bL[51] * (0.22024754776138800 - (0.06484897950087598*fabs(bL[51])))); + inputSampleL -= (bL[52] * (0.20394367993632415 - (0.08746309731952180*fabs(bL[52])))); + inputSampleL -= (bL[53] * (0.17565242431124092 - (0.07611309538078760*fabs(bL[53])))); + inputSampleL -= (bL[54] * (0.10116623231246825 - (0.00642818706295112*fabs(bL[54])))); + inputSampleL -= (bL[55] * (0.00782648272053632 + (0.08004141267685004*fabs(bL[55])))); + inputSampleL += (bL[56] * (0.05059046006747323 - (0.12436676387548490*fabs(bL[56])))); + inputSampleL += (bL[57] * (0.06241531553254467 - (0.11530779547021434*fabs(bL[57])))); + inputSampleL += (bL[58] * (0.04952694587101836 - (0.08340945324333944*fabs(bL[58])))); + inputSampleL += (bL[59] * (0.00843873294401687 - (0.03279659052562903*fabs(bL[59])))); + inputSampleL -= (bL[60] * (0.05161338949440241 - (0.03428181149163798*fabs(bL[60])))); + inputSampleL -= (bL[61] * (0.08165520146902012 - (0.08196746092283110*fabs(bL[61])))); + inputSampleL -= (bL[62] * (0.06639532849935320 - (0.09797462781896329*fabs(bL[62])))); + inputSampleL -= (bL[63] * (0.02953430910661621 - (0.09175612938515763*fabs(bL[63])))); + inputSampleL += (bL[64] * (0.00741058547442938 + (0.05442091048731967*fabs(bL[64])))); + inputSampleL += (bL[65] * (0.01832866125391727 + (0.00306243693643687*fabs(bL[65])))); + inputSampleL += (bL[66] * (0.00526964230373573 - (0.04364102661136410*fabs(bL[66])))); + inputSampleL -= (bL[67] * (0.00300984373848200 + (0.09742737841278880*fabs(bL[67])))); + inputSampleL -= (bL[68] * (0.00413616769576694 + (0.14380661694523073*fabs(bL[68])))); + inputSampleL -= (bL[69] * (0.00588769034931419 + (0.16012843578892538*fabs(bL[69])))); + inputSampleL -= (bL[70] * (0.00688588239450581 + (0.14074464279305798*fabs(bL[70])))); + inputSampleL -= (bL[71] * (0.02277307992926315 + (0.07914752191801366*fabs(bL[71])))); + inputSampleL -= (bL[72] * (0.04627166091180877 - (0.00192787268067208*fabs(bL[72])))); + inputSampleL -= (bL[73] * (0.05562045897455786 - (0.05932868727665747*fabs(bL[73])))); + inputSampleL -= (bL[74] * (0.05134243784922165 - (0.08245334798868090*fabs(bL[74])))); + inputSampleL -= (bL[75] * (0.04719409472239919 - (0.07498680629253825*fabs(bL[75])))); + inputSampleL -= (bL[76] * (0.05889738914266415 - (0.06116127018043697*fabs(bL[76])))); + inputSampleL -= (bL[77] * (0.09428363535111127 - (0.06535868867863834*fabs(bL[77])))); + inputSampleL -= (bL[78] * (0.15181756953225126 - (0.08982979655234427*fabs(bL[78])))); + inputSampleL -= (bL[79] * (0.20878969456036670 - (0.10761070891499538*fabs(bL[79])))); + inputSampleL -= (bL[80] * (0.22647885581813790 - (0.08462542510349125*fabs(bL[80])))); + inputSampleL -= (bL[81] * (0.19723482443646323 - (0.02665160920736287*fabs(bL[81])))); + inputSampleL -= (bL[82] * (0.16441643451155163 + (0.02314691954338197*fabs(bL[82])))); + inputSampleL -= (bL[83] * (0.15201914054931515 + (0.04424903493886839*fabs(bL[83])))); + inputSampleL -= (bL[84] * (0.15454370641307855 + (0.04223203797913008*fabs(bL[84])))); + + temp = (inputSampleL + smoothCabBL)/3.0; + smoothCabBL = inputSampleL; + inputSampleL = temp/4.0; + + randy = ((double(fpdL)/UINT32_MAX)*0.057); + drySampleL = ((((inputSampleL*(1-randy))+(lastCabSampleL*randy))*wet)+(drySampleL*(1.0-wet)))*outputlevel; + lastCabSampleL = inputSampleL; + inputSampleL = drySampleL; //cab L + + temp = (inputSampleR + smoothCabAR)/3.0; + smoothCabAR = inputSampleR; + inputSampleR = temp; + + bR[84] = bR[83]; bR[83] = bR[82]; bR[82] = bR[81]; bR[81] = bR[80]; bR[80] = bR[79]; + bR[79] = bR[78]; bR[78] = bR[77]; bR[77] = bR[76]; bR[76] = bR[75]; bR[75] = bR[74]; bR[74] = bR[73]; bR[73] = bR[72]; bR[72] = bR[71]; + bR[71] = bR[70]; bR[70] = bR[69]; bR[69] = bR[68]; bR[68] = bR[67]; bR[67] = bR[66]; bR[66] = bR[65]; bR[65] = bR[64]; bR[64] = bR[63]; + bR[63] = bR[62]; bR[62] = bR[61]; bR[61] = bR[60]; bR[60] = bR[59]; bR[59] = bR[58]; bR[58] = bR[57]; bR[57] = bR[56]; bR[56] = bR[55]; + bR[55] = bR[54]; bR[54] = bR[53]; bR[53] = bR[52]; bR[52] = bR[51]; bR[51] = bR[50]; bR[50] = bR[49]; bR[49] = bR[48]; bR[48] = bR[47]; + bR[47] = bR[46]; bR[46] = bR[45]; bR[45] = bR[44]; bR[44] = bR[43]; bR[43] = bR[42]; bR[42] = bR[41]; bR[41] = bR[40]; bR[40] = bR[39]; + bR[39] = bR[38]; bR[38] = bR[37]; bR[37] = bR[36]; bR[36] = bR[35]; bR[35] = bR[34]; bR[34] = bR[33]; bR[33] = bR[32]; bR[32] = bR[31]; + bR[31] = bR[30]; bR[30] = bR[29]; bR[29] = bR[28]; bR[28] = bR[27]; bR[27] = bR[26]; bR[26] = bR[25]; bR[25] = bR[24]; bR[24] = bR[23]; + bR[23] = bR[22]; bR[22] = bR[21]; bR[21] = bR[20]; bR[20] = bR[19]; bR[19] = bR[18]; bR[18] = bR[17]; bR[17] = bR[16]; bR[16] = bR[15]; + bR[15] = bR[14]; bR[14] = bR[13]; bR[13] = bR[12]; bR[12] = bR[11]; bR[11] = bR[10]; bR[10] = bR[9]; bR[9] = bR[8]; bR[8] = bR[7]; + bR[7] = bR[6]; bR[6] = bR[5]; bR[5] = bR[4]; bR[4] = bR[3]; bR[3] = bR[2]; bR[2] = bR[1]; bR[1] = bR[0]; bR[0] = inputSampleR; + inputSampleR += (bR[1] * (1.31698250313308396 - (0.08140616497621633*fabs(bR[1])))); + inputSampleR += (bR[2] * (1.47229016949915326 - (0.27680278993637253*fabs(bR[2])))); + inputSampleR += (bR[3] * (1.30410109086044956 - (0.35629113432046489*fabs(bR[3])))); + inputSampleR += (bR[4] * (0.81766210474551260 - (0.26808782337659753*fabs(bR[4])))); + inputSampleR += (bR[5] * (0.19868872545506663 - (0.11105517193919669*fabs(bR[5])))); + inputSampleR -= (bR[6] * (0.39115909132567039 - (0.12630622002682679*fabs(bR[6])))); + inputSampleR -= (bR[7] * (0.76881891559343574 - (0.40879849500403143*fabs(bR[7])))); + inputSampleR -= (bR[8] * (0.87146861782680340 - (0.59529560488000599*fabs(bR[8])))); + inputSampleR -= (bR[9] * (0.79504575932563670 - (0.60877047551611796*fabs(bR[9])))); + inputSampleR -= (bR[10] * (0.61653017622406314 - (0.47662851438557335*fabs(bR[10])))); + inputSampleR -= (bR[11] * (0.40718195794382067 - (0.24955839378539713*fabs(bR[11])))); + inputSampleR -= (bR[12] * (0.31794900040616203 - (0.04169792259600613*fabs(bR[12])))); + inputSampleR -= (bR[13] * (0.41075032540217843 + (0.00368483996076280*fabs(bR[13])))); + inputSampleR -= (bR[14] * (0.56901352922170667 - (0.11027360805893105*fabs(bR[14])))); + inputSampleR -= (bR[15] * (0.62443222391889264 - (0.22198075154245228*fabs(bR[15])))); + inputSampleR -= (bR[16] * (0.53462856723129204 - (0.22933544545324852*fabs(bR[16])))); + inputSampleR -= (bR[17] * (0.34441703361995046 - (0.12956809502269492*fabs(bR[17])))); + inputSampleR -= (bR[18] * (0.13947052337867882 + (0.00339775055962799*fabs(bR[18])))); + inputSampleR += (bR[19] * (0.03771252648928484 - (0.10863931549251718*fabs(bR[19])))); + inputSampleR += (bR[20] * (0.18280210770271693 - (0.17413646599296417*fabs(bR[20])))); + inputSampleR += (bR[21] * (0.24621986701761467 - (0.14547053270435095*fabs(bR[21])))); + inputSampleR += (bR[22] * (0.22347075142737360 - (0.02493869490104031*fabs(bR[22])))); + inputSampleR += (bR[23] * (0.14346348482123716 + (0.11284054747963246*fabs(bR[23])))); + inputSampleR += (bR[24] * (0.00834364862916028 + (0.24284684053733926*fabs(bR[24])))); + inputSampleR -= (bR[25] * (0.11559740296078347 - (0.32623054435304538*fabs(bR[25])))); + inputSampleR -= (bR[26] * (0.18067604561283060 - (0.32311481551122478*fabs(bR[26])))); + inputSampleR -= (bR[27] * (0.22927997789035612 - (0.26991539052832925*fabs(bR[27])))); + inputSampleR -= (bR[28] * (0.28487666578669446 - (0.22437227250279349*fabs(bR[28])))); + inputSampleR -= (bR[29] * (0.31992973037153838 - (0.15289876100963865*fabs(bR[29])))); + inputSampleR -= (bR[30] * (0.35174606303520733 - (0.05656293023086628*fabs(bR[30])))); + inputSampleR -= (bR[31] * (0.36894898011375254 + (0.04333925421463558*fabs(bR[31])))); + inputSampleR -= (bR[32] * (0.32567576055307507 + (0.14594589410921388*fabs(bR[32])))); + inputSampleR -= (bR[33] * (0.27440135050585784 + (0.15529667398122521*fabs(bR[33])))); + inputSampleR -= (bR[34] * (0.21998973785078091 + (0.05083553737157104*fabs(bR[34])))); + inputSampleR -= (bR[35] * (0.10323624876862457 - (0.04651829594199963*fabs(bR[35])))); + inputSampleR += (bR[36] * (0.02091603687851074 + (0.12000046818439322*fabs(bR[36])))); + inputSampleR += (bR[37] * (0.11344930914138468 + (0.17697142512225839*fabs(bR[37])))); + inputSampleR += (bR[38] * (0.22766779627643968 + (0.13645102964003858*fabs(bR[38])))); + inputSampleR += (bR[39] * (0.38378309953638229 - (0.01997653307333791*fabs(bR[39])))); + inputSampleR += (bR[40] * (0.52789400804568076 - (0.21409137428422448*fabs(bR[40])))); + inputSampleR += (bR[41] * (0.55444630296938280 - (0.32331980931576626*fabs(bR[41])))); + inputSampleR += (bR[42] * (0.42333237669264601 - (0.26855847463044280*fabs(bR[42])))); + inputSampleR += (bR[43] * (0.21942831522035078 - (0.12051365248820624*fabs(bR[43])))); + inputSampleR -= (bR[44] * (0.00584169427830633 - (0.03706970171280329*fabs(bR[44])))); + inputSampleR -= (bR[45] * (0.24279799124660351 - (0.17296440491477982*fabs(bR[45])))); + inputSampleR -= (bR[46] * (0.40173760787507085 - (0.21717989835163351*fabs(bR[46])))); + inputSampleR -= (bR[47] * (0.43930035724188155 - (0.16425928481378199*fabs(bR[47])))); + inputSampleR -= (bR[48] * (0.41067765934041811 - (0.10390115786636855*fabs(bR[48])))); + inputSampleR -= (bR[49] * (0.34409235547165967 - (0.07268159377411920*fabs(bR[49])))); + inputSampleR -= (bR[50] * (0.26542883122568151 - (0.05483457497365785*fabs(bR[50])))); + inputSampleR -= (bR[51] * (0.22024754776138800 - (0.06484897950087598*fabs(bR[51])))); + inputSampleR -= (bR[52] * (0.20394367993632415 - (0.08746309731952180*fabs(bR[52])))); + inputSampleR -= (bR[53] * (0.17565242431124092 - (0.07611309538078760*fabs(bR[53])))); + inputSampleR -= (bR[54] * (0.10116623231246825 - (0.00642818706295112*fabs(bR[54])))); + inputSampleR -= (bR[55] * (0.00782648272053632 + (0.08004141267685004*fabs(bR[55])))); + inputSampleR += (bR[56] * (0.05059046006747323 - (0.12436676387548490*fabs(bR[56])))); + inputSampleR += (bR[57] * (0.06241531553254467 - (0.11530779547021434*fabs(bR[57])))); + inputSampleR += (bR[58] * (0.04952694587101836 - (0.08340945324333944*fabs(bR[58])))); + inputSampleR += (bR[59] * (0.00843873294401687 - (0.03279659052562903*fabs(bR[59])))); + inputSampleR -= (bR[60] * (0.05161338949440241 - (0.03428181149163798*fabs(bR[60])))); + inputSampleR -= (bR[61] * (0.08165520146902012 - (0.08196746092283110*fabs(bR[61])))); + inputSampleR -= (bR[62] * (0.06639532849935320 - (0.09797462781896329*fabs(bR[62])))); + inputSampleR -= (bR[63] * (0.02953430910661621 - (0.09175612938515763*fabs(bR[63])))); + inputSampleR += (bR[64] * (0.00741058547442938 + (0.05442091048731967*fabs(bR[64])))); + inputSampleR += (bR[65] * (0.01832866125391727 + (0.00306243693643687*fabs(bR[65])))); + inputSampleR += (bR[66] * (0.00526964230373573 - (0.04364102661136410*fabs(bR[66])))); + inputSampleR -= (bR[67] * (0.00300984373848200 + (0.09742737841278880*fabs(bR[67])))); + inputSampleR -= (bR[68] * (0.00413616769576694 + (0.14380661694523073*fabs(bR[68])))); + inputSampleR -= (bR[69] * (0.00588769034931419 + (0.16012843578892538*fabs(bR[69])))); + inputSampleR -= (bR[70] * (0.00688588239450581 + (0.14074464279305798*fabs(bR[70])))); + inputSampleR -= (bR[71] * (0.02277307992926315 + (0.07914752191801366*fabs(bR[71])))); + inputSampleR -= (bR[72] * (0.04627166091180877 - (0.00192787268067208*fabs(bR[72])))); + inputSampleR -= (bR[73] * (0.05562045897455786 - (0.05932868727665747*fabs(bR[73])))); + inputSampleR -= (bR[74] * (0.05134243784922165 - (0.08245334798868090*fabs(bR[74])))); + inputSampleR -= (bR[75] * (0.04719409472239919 - (0.07498680629253825*fabs(bR[75])))); + inputSampleR -= (bR[76] * (0.05889738914266415 - (0.06116127018043697*fabs(bR[76])))); + inputSampleR -= (bR[77] * (0.09428363535111127 - (0.06535868867863834*fabs(bR[77])))); + inputSampleR -= (bR[78] * (0.15181756953225126 - (0.08982979655234427*fabs(bR[78])))); + inputSampleR -= (bR[79] * (0.20878969456036670 - (0.10761070891499538*fabs(bR[79])))); + inputSampleR -= (bR[80] * (0.22647885581813790 - (0.08462542510349125*fabs(bR[80])))); + inputSampleR -= (bR[81] * (0.19723482443646323 - (0.02665160920736287*fabs(bR[81])))); + inputSampleR -= (bR[82] * (0.16441643451155163 + (0.02314691954338197*fabs(bR[82])))); + inputSampleR -= (bR[83] * (0.15201914054931515 + (0.04424903493886839*fabs(bR[83])))); + inputSampleR -= (bR[84] * (0.15454370641307855 + (0.04223203797913008*fabs(bR[84])))); + + temp = (inputSampleR + smoothCabBR)/3.0; + smoothCabBR = inputSampleR; + inputSampleR = temp/4.0; + + randy = ((double(fpdR)/UINT32_MAX)*0.057); + drySampleR = ((((inputSampleR*(1.0-randy))+(lastCabSampleR*randy))*wet)+(drySampleR*(1.0-wet)))*outputlevel; + lastCabSampleR = inputSampleR; + inputSampleR = drySampleR; //cab + + if (cycleEnd == 4) { + lastRefL[0] = lastRefL[4]; //start from previous last + lastRefL[2] = (lastRefL[0] + inputSampleL)/2; //half + lastRefL[1] = (lastRefL[0] + lastRefL[2])/2; //one quarter + lastRefL[3] = (lastRefL[2] + inputSampleL)/2; //three quarters + lastRefL[4] = inputSampleL; //full + lastRefR[0] = lastRefR[4]; //start from previous last + lastRefR[2] = (lastRefR[0] + inputSampleR)/2; //half + lastRefR[1] = (lastRefR[0] + lastRefR[2])/2; //one quarter + lastRefR[3] = (lastRefR[2] + inputSampleR)/2; //three quarters + lastRefR[4] = inputSampleR; //full + } + if (cycleEnd == 3) { + lastRefL[0] = lastRefL[3]; //start from previous last + lastRefL[2] = (lastRefL[0]+lastRefL[0]+inputSampleL)/3; //third + lastRefL[1] = (lastRefL[0]+inputSampleL+inputSampleL)/3; //two thirds + lastRefL[3] = inputSampleL; //full + lastRefR[0] = lastRefR[3]; //start from previous last + lastRefR[2] = (lastRefR[0]+lastRefR[0]+inputSampleR)/3; //third + lastRefR[1] = (lastRefR[0]+inputSampleR+inputSampleR)/3; //two thirds + lastRefR[3] = inputSampleR; //full + } + if (cycleEnd == 2) { + lastRefL[0] = lastRefL[2]; //start from previous last + lastRefL[1] = (lastRefL[0] + inputSampleL)/2; //half + lastRefL[2] = inputSampleL; //full + lastRefR[0] = lastRefR[2]; //start from previous last + lastRefR[1] = (lastRefR[0] + inputSampleR)/2; //half + lastRefR[2] = inputSampleR; //full + } + if (cycleEnd == 1) { + lastRefL[0] = inputSampleL; + lastRefR[0] = inputSampleR; + } + cycle = 0; //reset + inputSampleL = lastRefL[cycle]; + inputSampleR = lastRefR[cycle]; + } else { + inputSampleL = lastRefL[cycle]; + inputSampleR = lastRefR[cycle]; + //we are going through our references now + } + switch (cycleEnd) //multi-pole average using lastRef[] variables + { + case 4: + lastRefL[8] = inputSampleL; inputSampleL = (inputSampleL+lastRefL[7])*0.5; + lastRefL[7] = lastRefL[8]; //continue, do not break + lastRefR[8] = inputSampleR; inputSampleR = (inputSampleR+lastRefR[7])*0.5; + lastRefR[7] = lastRefR[8]; //continue, do not break + case 3: + lastRefL[8] = inputSampleL; inputSampleL = (inputSampleL+lastRefL[6])*0.5; + lastRefL[6] = lastRefL[8]; //continue, do not break + lastRefR[8] = inputSampleR; inputSampleR = (inputSampleR+lastRefR[6])*0.5; + lastRefR[6] = lastRefR[8]; //continue, do not break + case 2: + lastRefL[8] = inputSampleL; inputSampleL = (inputSampleL+lastRefL[5])*0.5; + lastRefL[5] = lastRefL[8]; //continue, do not break + lastRefR[8] = inputSampleR; inputSampleR = (inputSampleR+lastRefR[5])*0.5; + lastRefR[5] = lastRefR[8]; //continue, do not break + case 1: + break; //no further averaging + } + + //begin 32 bit stereo floating point dither + int expon; frexpf((float)inputSampleL, &expon); + fpdL ^= fpdL << 13; fpdL ^= fpdL >> 17; fpdL ^= fpdL << 5; + inputSampleL += ((double(fpdL)-uint32_t(0x7fffffff)) * 5.5e-36l * pow(2,expon+62)); + frexpf((float)inputSampleR, &expon); + fpdR ^= fpdR << 13; fpdR ^= fpdR >> 17; fpdR ^= fpdR << 5; + inputSampleR += ((double(fpdR)-uint32_t(0x7fffffff)) * 5.5e-36l * pow(2,expon+62)); + //end 32 bit stereo floating point dither + + *out1 = inputSampleL; + *out2 = inputSampleR; + + in1++; + in2++; + out1++; + out2++; + } +} + +void FireAmp::processDoubleReplacing(double **inputs, double **outputs, VstInt32 sampleFrames) +{ + double* in1 = inputs[0]; + double* in2 = inputs[1]; + double* out1 = outputs[0]; + double* out2 = outputs[1]; + + double bassfill = A; + double outputlevel = C; + double wet = D; + + double overallscale = 1.0; + overallscale /= 44100.0; + overallscale *= getSampleRate(); + int cycleEnd = floor(overallscale); + if (cycleEnd < 1) cycleEnd = 1; + if (cycleEnd > 4) cycleEnd = 4; + //this is going to be 2 for 88.1 or 96k, 3 for silly people, 4 for 176 or 192k + if (cycle > cycleEnd-1) cycle = cycleEnd-1; //sanity check + + double startlevel = bassfill; + double samplerate = getSampleRate(); + double basstrim = bassfill / 16.0; + double toneEQ = (B / samplerate)*22050.0; + double EQ = (basstrim / samplerate)*22050.0; + double bleed = outputlevel/16.0; + double bassfactor = 1.0-(basstrim*basstrim); + double BEQ = (bleed / samplerate)*22050.0; + int diagonal = (int)(0.000861678*samplerate); + if (diagonal > 127) diagonal = 127; + int side = (int)(diagonal/1.4142135623730951); + int down = (side + diagonal)/2; + //now we've got down, side and diagonal as offsets and we also use three successive samples upfront + + double cutoff = (15000.0+(B*10000.0)) / getSampleRate(); + if (cutoff > 0.49) cutoff = 0.49; //don't crash if run at 44.1k + if (cutoff < 0.001) cutoff = 0.001; //or if cutoff's too low + + fixF[fix_freq] = fixE[fix_freq] = fixD[fix_freq] = fixC[fix_freq] = fixB[fix_freq] = fixA[fix_freq] = cutoff; + + fixA[fix_reso] = 4.46570214; + fixB[fix_reso] = 1.51387132; + fixC[fix_reso] = 0.93979296; + fixD[fix_reso] = 0.70710678; + fixE[fix_reso] = 0.52972649; + fixF[fix_reso] = 0.50316379; + + double K = tan(M_PI * fixA[fix_freq]); //lowpass + double norm = 1.0 / (1.0 + K / fixA[fix_reso] + K * K); + fixA[fix_a0] = K * K * norm; + fixA[fix_a1] = 2.0 * fixA[fix_a0]; + fixA[fix_a2] = fixA[fix_a0]; + fixA[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixA[fix_b2] = (1.0 - K / fixA[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixB[fix_freq]); + norm = 1.0 / (1.0 + K / fixB[fix_reso] + K * K); + fixB[fix_a0] = K * K * norm; + fixB[fix_a1] = 2.0 * fixB[fix_a0]; + fixB[fix_a2] = fixB[fix_a0]; + fixB[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixB[fix_b2] = (1.0 - K / fixB[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixC[fix_freq]); + norm = 1.0 / (1.0 + K / fixC[fix_reso] + K * K); + fixC[fix_a0] = K * K * norm; + fixC[fix_a1] = 2.0 * fixC[fix_a0]; + fixC[fix_a2] = fixC[fix_a0]; + fixC[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixC[fix_b2] = (1.0 - K / fixC[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixD[fix_freq]); + norm = 1.0 / (1.0 + K / fixD[fix_reso] + K * K); + fixD[fix_a0] = K * K * norm; + fixD[fix_a1] = 2.0 * fixD[fix_a0]; + fixD[fix_a2] = fixD[fix_a0]; + fixD[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixD[fix_b2] = (1.0 - K / fixD[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixE[fix_freq]); + norm = 1.0 / (1.0 + K / fixE[fix_reso] + K * K); + fixE[fix_a0] = K * K * norm; + fixE[fix_a1] = 2.0 * fixE[fix_a0]; + fixE[fix_a2] = fixE[fix_a0]; + fixE[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixE[fix_b2] = (1.0 - K / fixE[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixF[fix_freq]); + norm = 1.0 / (1.0 + K / fixF[fix_reso] + K * K); + fixF[fix_a0] = K * K * norm; + fixF[fix_a1] = 2.0 * fixF[fix_a0]; + fixF[fix_a2] = fixF[fix_a0]; + fixF[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixF[fix_b2] = (1.0 - K / fixF[fix_reso] + K * K) * norm; + + + while (--sampleFrames >= 0) + { + double inputSampleL = *in1; + double inputSampleR = *in2; + if (fabs(inputSampleL)<1.18e-23) inputSampleL = fpdL * 1.18e-17; + if (fabs(inputSampleR)<1.18e-23) inputSampleR = fpdR * 1.18e-17; + double drySampleL = inputSampleL; + double drySampleR = inputSampleR; + + + double outSample = (inputSampleL * fixA[fix_a0]) + fixA[fix_sL1]; + fixA[fix_sL1] = (inputSampleL * fixA[fix_a1]) - (outSample * fixA[fix_b1]) + fixA[fix_sL2]; + fixA[fix_sL2] = (inputSampleL * fixA[fix_a2]) - (outSample * fixA[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixA[fix_a0]) + fixA[fix_sR1]; + fixA[fix_sR1] = (inputSampleR * fixA[fix_a1]) - (outSample * fixA[fix_b1]) + fixA[fix_sR2]; + fixA[fix_sR2] = (inputSampleR * fixA[fix_a2]) - (outSample * fixA[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + if (inputSampleL > 1.0) inputSampleL = 1.0; + if (inputSampleL < -1.0) inputSampleL = -1.0; + double basscutL = 0.98; + //we're going to be shifting this as the stages progress + double inputlevelL = startlevel; + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleAL = (iirSampleAL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleAL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + double bridgerectifier = (smoothAL + inputSampleL); + smoothAL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleBL = (iirSampleBL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleBL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothBL + inputSampleL); + smoothBL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + + if (inputSampleR > 1.0) inputSampleR = 1.0; + if (inputSampleR < -1.0) inputSampleR = -1.0; + double basscutR = 0.98; + //we're going to be shifting this as the stages progress + double inputlevelR = startlevel; + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleAR = (iirSampleAR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleAR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654) ); + //overdrive + bridgerectifier = (smoothAR + inputSampleR); + smoothAR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleBR = (iirSampleBR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleBR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654) ); + //overdrive + bridgerectifier = (smoothBR + inputSampleR); + smoothBR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + + + outSample = (inputSampleL * fixB[fix_a0]) + fixB[fix_sL1]; + fixB[fix_sL1] = (inputSampleL * fixB[fix_a1]) - (outSample * fixB[fix_b1]) + fixB[fix_sL2]; + fixB[fix_sL2] = (inputSampleL * fixB[fix_a2]) - (outSample * fixB[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixB[fix_a0]) + fixB[fix_sR1]; + fixB[fix_sR1] = (inputSampleR * fixB[fix_a1]) - (outSample * fixB[fix_b1]) + fixB[fix_sR2]; + fixB[fix_sR2] = (inputSampleR * fixB[fix_a2]) - (outSample * fixB[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleCL = (iirSampleCL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleCL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothCL + inputSampleL); + smoothCL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleDL = (iirSampleDL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleDL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654) ); + //overdrive + bridgerectifier = (smoothDL + inputSampleL); + smoothDL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + + + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleCR = (iirSampleCR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleCR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654)); + //overdrive + bridgerectifier = (smoothCR + inputSampleR); + smoothCR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleDR = (iirSampleDR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleDR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654) ); + //overdrive + bridgerectifier = (smoothDR + inputSampleR); + smoothDR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + + outSample = (inputSampleL * fixC[fix_a0]) + fixC[fix_sL1]; + fixC[fix_sL1] = (inputSampleL * fixC[fix_a1]) - (outSample * fixC[fix_b1]) + fixC[fix_sL2]; + fixC[fix_sL2] = (inputSampleL * fixC[fix_a2]) - (outSample * fixC[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixC[fix_a0]) + fixC[fix_sR1]; + fixC[fix_sR1] = (inputSampleR * fixC[fix_a1]) - (outSample * fixC[fix_b1]) + fixC[fix_sR2]; + fixC[fix_sR2] = (inputSampleR * fixC[fix_a2]) - (outSample * fixC[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleEL = (iirSampleEL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleEL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothEL + inputSampleL); + smoothEL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleFL = (iirSampleFL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleFL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothFL + inputSampleL); + smoothFL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + + + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleER = (iirSampleER * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleER*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654)); + //overdrive + bridgerectifier = (smoothER + inputSampleR); + smoothER = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleFR = (iirSampleFR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleFR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654)); + //overdrive + bridgerectifier = (smoothFR + inputSampleR); + smoothFR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + + outSample = (inputSampleL * fixD[fix_a0]) + fixD[fix_sL1]; + fixD[fix_sL1] = (inputSampleL * fixD[fix_a1]) - (outSample * fixD[fix_b1]) + fixD[fix_sL2]; + fixD[fix_sL2] = (inputSampleL * fixD[fix_a2]) - (outSample * fixD[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixD[fix_a0]) + fixD[fix_sR1]; + fixD[fix_sR1] = (inputSampleR * fixD[fix_a1]) - (outSample * fixD[fix_b1]) + fixD[fix_sR2]; + fixD[fix_sR2] = (inputSampleR * fixD[fix_a2]) - (outSample * fixD[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleGL = (iirSampleGL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleGL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothGL + inputSampleL); + smoothGL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleHL = (iirSampleHL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleHL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothHL + inputSampleL); + smoothHL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + + + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleGR = (iirSampleGR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleGR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654)); + //overdrive + bridgerectifier = (smoothGR + inputSampleR); + smoothGR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleHR = (iirSampleHR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleHR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654)); + //overdrive + bridgerectifier = (smoothHR + inputSampleR); + smoothHR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + + outSample = (inputSampleL * fixE[fix_a0]) + fixE[fix_sL1]; + fixE[fix_sL1] = (inputSampleL * fixE[fix_a1]) - (outSample * fixE[fix_b1]) + fixE[fix_sL2]; + fixE[fix_sL2] = (inputSampleL * fixE[fix_a2]) - (outSample * fixE[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixE[fix_a0]) + fixE[fix_sR1]; + fixE[fix_sR1] = (inputSampleR * fixE[fix_a1]) - (outSample * fixE[fix_b1]) + fixE[fix_sR2]; + fixE[fix_sR2] = (inputSampleR * fixE[fix_a2]) - (outSample * fixE[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleIL = (iirSampleIL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleIL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothIL + inputSampleL); + smoothIL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleJL = (iirSampleJL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleJL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothJL + inputSampleL); + smoothJL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + + + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleIR = (iirSampleIR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleIR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654)); + //overdrive + bridgerectifier = (smoothIR + inputSampleR); + smoothIR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleJR = (iirSampleJR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleJR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654)); + //overdrive + bridgerectifier = (smoothJR + inputSampleR); + smoothJR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + + outSample = (inputSampleL * fixF[fix_a0]) + fixF[fix_sL1]; + fixF[fix_sL1] = (inputSampleL * fixF[fix_a1]) - (outSample * fixF[fix_b1]) + fixF[fix_sL2]; + fixF[fix_sL2] = (inputSampleL * fixF[fix_a2]) - (outSample * fixF[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixF[fix_a0]) + fixF[fix_sR1]; + fixF[fix_sR1] = (inputSampleR * fixF[fix_a1]) - (outSample * fixF[fix_b1]) + fixF[fix_sR2]; + fixF[fix_sR2] = (inputSampleR * fixF[fix_a2]) - (outSample * fixF[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleKL = (iirSampleKL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleKL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothKL + inputSampleL); + smoothKL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + inputSampleL *= inputlevelL; + inputlevelL = ((inputlevelL * 7.0)+1.0)/8.0; + iirSampleLL = (iirSampleLL * (1.0 - EQ)) + (inputSampleL * EQ); + basscutL *= bassfactor; + inputSampleL = inputSampleL - (iirSampleLL*basscutL); + //highpass + inputSampleL -= (inputSampleL * (fabs(inputSampleL) * 0.654) * (fabs(inputSampleL) * 0.654)); + //overdrive + bridgerectifier = (smoothLL + inputSampleL); + smoothLL = inputSampleL; + inputSampleL = bridgerectifier; + //two-sample averaging lowpass + + + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleKR = (iirSampleKR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleKR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654)); + //overdrive + bridgerectifier = (smoothKR + inputSampleR); + smoothKR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + inputSampleR *= inputlevelR; + inputlevelR = ((inputlevelR * 7.0)+1.0)/8.0; + iirSampleLR = (iirSampleLR * (1.0 - EQ)) + (inputSampleR * EQ); + basscutR *= bassfactor; + inputSampleR = inputSampleR - (iirSampleLR*basscutR); + //highpass + inputSampleR -= (inputSampleR * (fabs(inputSampleR) * 0.654) * (fabs(inputSampleR) * 0.654)); + //overdrive + bridgerectifier = (smoothLR + inputSampleR); + smoothLR = inputSampleR; + inputSampleR = bridgerectifier; + //two-sample averaging lowpass + + iirLowpassL = (iirLowpassL * (1.0 - toneEQ)) + (inputSampleL * toneEQ); + inputSampleL = iirLowpassL; + //lowpass. The only one of this type. + iirLowpassR = (iirLowpassR * (1.0 - toneEQ)) + (inputSampleR * toneEQ); + inputSampleR = iirLowpassR; + //lowpass. The only one of this type. + + iirSpkAL = (iirSpkAL * (1.0 - BEQ)) + (inputSampleL * BEQ); + //extra lowpass for 4*12" speakers + iirSpkAR = (iirSpkAR * (1.0 - BEQ)) + (inputSampleR * BEQ); + //extra lowpass for 4*12" speakers + + if (count < 0 || count > 128) {count = 128;} + double resultBL = 0.0; + double resultBR = 0.0; + if (flip) + { + OddL[count+128] = OddL[count] = iirSpkAL; + resultBL = (OddL[count+down] + OddL[count+side] + OddL[count+diagonal]); + OddR[count+128] = OddR[count] = iirSpkAR; + resultBR = (OddR[count+down] + OddR[count+side] + OddR[count+diagonal]); + } + else + { + EvenL[count+128] = EvenL[count] = iirSpkAL; + resultBL = (EvenL[count+down] + EvenL[count+side] + EvenL[count+diagonal]); + EvenR[count+128] = EvenR[count] = iirSpkAR; + resultBR = (EvenR[count+down] + EvenR[count+side] + EvenR[count+diagonal]); + } + count--; + iirSpkBL = (iirSpkBL * (1.0 - BEQ)) + (resultBL * BEQ); + inputSampleL += (iirSpkBL * bleed); + //extra lowpass for 4*12" speakers + iirSpkBR = (iirSpkBR * (1.0 - BEQ)) + (resultBR * BEQ); + inputSampleR += (iirSpkBR * bleed); + //extra lowpass for 4*12" speakers + + bridgerectifier = fabs(inputSampleL*outputlevel); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (inputSampleL > 0) inputSampleL = bridgerectifier; + else inputSampleL = -bridgerectifier; + + bridgerectifier = fabs(inputSampleR*outputlevel); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (inputSampleR > 0) inputSampleR = bridgerectifier; + else inputSampleR = -bridgerectifier; + + iirSubL = (iirSubL * (1.0 - BEQ)) + (inputSampleL * BEQ); + inputSampleL += (iirSubL * bassfill * outputlevel); + + iirSubR = (iirSubR * (1.0 - BEQ)) + (inputSampleR * BEQ); + inputSampleR += (iirSubR * bassfill * outputlevel); + + double randy = ((double(fpdL)/UINT32_MAX)*0.053); + inputSampleL = ((inputSampleL*(1.0-randy))+(storeSampleL*randy))*outputlevel; + storeSampleL = inputSampleL; + + randy = ((double(fpdR)/UINT32_MAX)*0.053); + inputSampleR = ((inputSampleR*(1.0-randy))+(storeSampleR*randy))*outputlevel; + storeSampleR = inputSampleR; + + flip = !flip; + + if (wet !=1.0) { + inputSampleL = (inputSampleL * wet) + (drySampleL * (1.0-wet)); + inputSampleR = (inputSampleR * wet) + (drySampleR * (1.0-wet)); + } + //Dry/Wet control, defaults to the last slider + //amp + + cycle++; + if (cycle == cycleEnd) { + double temp = (inputSampleL + smoothCabAL)/3.0; + smoothCabAL = inputSampleL; + inputSampleL = temp; + + bL[84] = bL[83]; bL[83] = bL[82]; bL[82] = bL[81]; bL[81] = bL[80]; bL[80] = bL[79]; + bL[79] = bL[78]; bL[78] = bL[77]; bL[77] = bL[76]; bL[76] = bL[75]; bL[75] = bL[74]; bL[74] = bL[73]; bL[73] = bL[72]; bL[72] = bL[71]; + bL[71] = bL[70]; bL[70] = bL[69]; bL[69] = bL[68]; bL[68] = bL[67]; bL[67] = bL[66]; bL[66] = bL[65]; bL[65] = bL[64]; bL[64] = bL[63]; + bL[63] = bL[62]; bL[62] = bL[61]; bL[61] = bL[60]; bL[60] = bL[59]; bL[59] = bL[58]; bL[58] = bL[57]; bL[57] = bL[56]; bL[56] = bL[55]; + bL[55] = bL[54]; bL[54] = bL[53]; bL[53] = bL[52]; bL[52] = bL[51]; bL[51] = bL[50]; bL[50] = bL[49]; bL[49] = bL[48]; bL[48] = bL[47]; + bL[47] = bL[46]; bL[46] = bL[45]; bL[45] = bL[44]; bL[44] = bL[43]; bL[43] = bL[42]; bL[42] = bL[41]; bL[41] = bL[40]; bL[40] = bL[39]; + bL[39] = bL[38]; bL[38] = bL[37]; bL[37] = bL[36]; bL[36] = bL[35]; bL[35] = bL[34]; bL[34] = bL[33]; bL[33] = bL[32]; bL[32] = bL[31]; + bL[31] = bL[30]; bL[30] = bL[29]; bL[29] = bL[28]; bL[28] = bL[27]; bL[27] = bL[26]; bL[26] = bL[25]; bL[25] = bL[24]; bL[24] = bL[23]; + bL[23] = bL[22]; bL[22] = bL[21]; bL[21] = bL[20]; bL[20] = bL[19]; bL[19] = bL[18]; bL[18] = bL[17]; bL[17] = bL[16]; bL[16] = bL[15]; + bL[15] = bL[14]; bL[14] = bL[13]; bL[13] = bL[12]; bL[12] = bL[11]; bL[11] = bL[10]; bL[10] = bL[9]; bL[9] = bL[8]; bL[8] = bL[7]; + bL[7] = bL[6]; bL[6] = bL[5]; bL[5] = bL[4]; bL[4] = bL[3]; bL[3] = bL[2]; bL[2] = bL[1]; bL[1] = bL[0]; bL[0] = inputSampleL; + inputSampleL += (bL[1] * (1.31698250313308396 - (0.08140616497621633*fabs(bL[1])))); + inputSampleL += (bL[2] * (1.47229016949915326 - (0.27680278993637253*fabs(bL[2])))); + inputSampleL += (bL[3] * (1.30410109086044956 - (0.35629113432046489*fabs(bL[3])))); + inputSampleL += (bL[4] * (0.81766210474551260 - (0.26808782337659753*fabs(bL[4])))); + inputSampleL += (bL[5] * (0.19868872545506663 - (0.11105517193919669*fabs(bL[5])))); + inputSampleL -= (bL[6] * (0.39115909132567039 - (0.12630622002682679*fabs(bL[6])))); + inputSampleL -= (bL[7] * (0.76881891559343574 - (0.40879849500403143*fabs(bL[7])))); + inputSampleL -= (bL[8] * (0.87146861782680340 - (0.59529560488000599*fabs(bL[8])))); + inputSampleL -= (bL[9] * (0.79504575932563670 - (0.60877047551611796*fabs(bL[9])))); + inputSampleL -= (bL[10] * (0.61653017622406314 - (0.47662851438557335*fabs(bL[10])))); + inputSampleL -= (bL[11] * (0.40718195794382067 - (0.24955839378539713*fabs(bL[11])))); + inputSampleL -= (bL[12] * (0.31794900040616203 - (0.04169792259600613*fabs(bL[12])))); + inputSampleL -= (bL[13] * (0.41075032540217843 + (0.00368483996076280*fabs(bL[13])))); + inputSampleL -= (bL[14] * (0.56901352922170667 - (0.11027360805893105*fabs(bL[14])))); + inputSampleL -= (bL[15] * (0.62443222391889264 - (0.22198075154245228*fabs(bL[15])))); + inputSampleL -= (bL[16] * (0.53462856723129204 - (0.22933544545324852*fabs(bL[16])))); + inputSampleL -= (bL[17] * (0.34441703361995046 - (0.12956809502269492*fabs(bL[17])))); + inputSampleL -= (bL[18] * (0.13947052337867882 + (0.00339775055962799*fabs(bL[18])))); + inputSampleL += (bL[19] * (0.03771252648928484 - (0.10863931549251718*fabs(bL[19])))); + inputSampleL += (bL[20] * (0.18280210770271693 - (0.17413646599296417*fabs(bL[20])))); + inputSampleL += (bL[21] * (0.24621986701761467 - (0.14547053270435095*fabs(bL[21])))); + inputSampleL += (bL[22] * (0.22347075142737360 - (0.02493869490104031*fabs(bL[22])))); + inputSampleL += (bL[23] * (0.14346348482123716 + (0.11284054747963246*fabs(bL[23])))); + inputSampleL += (bL[24] * (0.00834364862916028 + (0.24284684053733926*fabs(bL[24])))); + inputSampleL -= (bL[25] * (0.11559740296078347 - (0.32623054435304538*fabs(bL[25])))); + inputSampleL -= (bL[26] * (0.18067604561283060 - (0.32311481551122478*fabs(bL[26])))); + inputSampleL -= (bL[27] * (0.22927997789035612 - (0.26991539052832925*fabs(bL[27])))); + inputSampleL -= (bL[28] * (0.28487666578669446 - (0.22437227250279349*fabs(bL[28])))); + inputSampleL -= (bL[29] * (0.31992973037153838 - (0.15289876100963865*fabs(bL[29])))); + inputSampleL -= (bL[30] * (0.35174606303520733 - (0.05656293023086628*fabs(bL[30])))); + inputSampleL -= (bL[31] * (0.36894898011375254 + (0.04333925421463558*fabs(bL[31])))); + inputSampleL -= (bL[32] * (0.32567576055307507 + (0.14594589410921388*fabs(bL[32])))); + inputSampleL -= (bL[33] * (0.27440135050585784 + (0.15529667398122521*fabs(bL[33])))); + inputSampleL -= (bL[34] * (0.21998973785078091 + (0.05083553737157104*fabs(bL[34])))); + inputSampleL -= (bL[35] * (0.10323624876862457 - (0.04651829594199963*fabs(bL[35])))); + inputSampleL += (bL[36] * (0.02091603687851074 + (0.12000046818439322*fabs(bL[36])))); + inputSampleL += (bL[37] * (0.11344930914138468 + (0.17697142512225839*fabs(bL[37])))); + inputSampleL += (bL[38] * (0.22766779627643968 + (0.13645102964003858*fabs(bL[38])))); + inputSampleL += (bL[39] * (0.38378309953638229 - (0.01997653307333791*fabs(bL[39])))); + inputSampleL += (bL[40] * (0.52789400804568076 - (0.21409137428422448*fabs(bL[40])))); + inputSampleL += (bL[41] * (0.55444630296938280 - (0.32331980931576626*fabs(bL[41])))); + inputSampleL += (bL[42] * (0.42333237669264601 - (0.26855847463044280*fabs(bL[42])))); + inputSampleL += (bL[43] * (0.21942831522035078 - (0.12051365248820624*fabs(bL[43])))); + inputSampleL -= (bL[44] * (0.00584169427830633 - (0.03706970171280329*fabs(bL[44])))); + inputSampleL -= (bL[45] * (0.24279799124660351 - (0.17296440491477982*fabs(bL[45])))); + inputSampleL -= (bL[46] * (0.40173760787507085 - (0.21717989835163351*fabs(bL[46])))); + inputSampleL -= (bL[47] * (0.43930035724188155 - (0.16425928481378199*fabs(bL[47])))); + inputSampleL -= (bL[48] * (0.41067765934041811 - (0.10390115786636855*fabs(bL[48])))); + inputSampleL -= (bL[49] * (0.34409235547165967 - (0.07268159377411920*fabs(bL[49])))); + inputSampleL -= (bL[50] * (0.26542883122568151 - (0.05483457497365785*fabs(bL[50])))); + inputSampleL -= (bL[51] * (0.22024754776138800 - (0.06484897950087598*fabs(bL[51])))); + inputSampleL -= (bL[52] * (0.20394367993632415 - (0.08746309731952180*fabs(bL[52])))); + inputSampleL -= (bL[53] * (0.17565242431124092 - (0.07611309538078760*fabs(bL[53])))); + inputSampleL -= (bL[54] * (0.10116623231246825 - (0.00642818706295112*fabs(bL[54])))); + inputSampleL -= (bL[55] * (0.00782648272053632 + (0.08004141267685004*fabs(bL[55])))); + inputSampleL += (bL[56] * (0.05059046006747323 - (0.12436676387548490*fabs(bL[56])))); + inputSampleL += (bL[57] * (0.06241531553254467 - (0.11530779547021434*fabs(bL[57])))); + inputSampleL += (bL[58] * (0.04952694587101836 - (0.08340945324333944*fabs(bL[58])))); + inputSampleL += (bL[59] * (0.00843873294401687 - (0.03279659052562903*fabs(bL[59])))); + inputSampleL -= (bL[60] * (0.05161338949440241 - (0.03428181149163798*fabs(bL[60])))); + inputSampleL -= (bL[61] * (0.08165520146902012 - (0.08196746092283110*fabs(bL[61])))); + inputSampleL -= (bL[62] * (0.06639532849935320 - (0.09797462781896329*fabs(bL[62])))); + inputSampleL -= (bL[63] * (0.02953430910661621 - (0.09175612938515763*fabs(bL[63])))); + inputSampleL += (bL[64] * (0.00741058547442938 + (0.05442091048731967*fabs(bL[64])))); + inputSampleL += (bL[65] * (0.01832866125391727 + (0.00306243693643687*fabs(bL[65])))); + inputSampleL += (bL[66] * (0.00526964230373573 - (0.04364102661136410*fabs(bL[66])))); + inputSampleL -= (bL[67] * (0.00300984373848200 + (0.09742737841278880*fabs(bL[67])))); + inputSampleL -= (bL[68] * (0.00413616769576694 + (0.14380661694523073*fabs(bL[68])))); + inputSampleL -= (bL[69] * (0.00588769034931419 + (0.16012843578892538*fabs(bL[69])))); + inputSampleL -= (bL[70] * (0.00688588239450581 + (0.14074464279305798*fabs(bL[70])))); + inputSampleL -= (bL[71] * (0.02277307992926315 + (0.07914752191801366*fabs(bL[71])))); + inputSampleL -= (bL[72] * (0.04627166091180877 - (0.00192787268067208*fabs(bL[72])))); + inputSampleL -= (bL[73] * (0.05562045897455786 - (0.05932868727665747*fabs(bL[73])))); + inputSampleL -= (bL[74] * (0.05134243784922165 - (0.08245334798868090*fabs(bL[74])))); + inputSampleL -= (bL[75] * (0.04719409472239919 - (0.07498680629253825*fabs(bL[75])))); + inputSampleL -= (bL[76] * (0.05889738914266415 - (0.06116127018043697*fabs(bL[76])))); + inputSampleL -= (bL[77] * (0.09428363535111127 - (0.06535868867863834*fabs(bL[77])))); + inputSampleL -= (bL[78] * (0.15181756953225126 - (0.08982979655234427*fabs(bL[78])))); + inputSampleL -= (bL[79] * (0.20878969456036670 - (0.10761070891499538*fabs(bL[79])))); + inputSampleL -= (bL[80] * (0.22647885581813790 - (0.08462542510349125*fabs(bL[80])))); + inputSampleL -= (bL[81] * (0.19723482443646323 - (0.02665160920736287*fabs(bL[81])))); + inputSampleL -= (bL[82] * (0.16441643451155163 + (0.02314691954338197*fabs(bL[82])))); + inputSampleL -= (bL[83] * (0.15201914054931515 + (0.04424903493886839*fabs(bL[83])))); + inputSampleL -= (bL[84] * (0.15454370641307855 + (0.04223203797913008*fabs(bL[84])))); + + temp = (inputSampleL + smoothCabBL)/3.0; + smoothCabBL = inputSampleL; + inputSampleL = temp/4.0; + + randy = ((double(fpdL)/UINT32_MAX)*0.057); + drySampleL = ((((inputSampleL*(1-randy))+(lastCabSampleL*randy))*wet)+(drySampleL*(1.0-wet)))*outputlevel; + lastCabSampleL = inputSampleL; + inputSampleL = drySampleL; //cab L + + temp = (inputSampleR + smoothCabAR)/3.0; + smoothCabAR = inputSampleR; + inputSampleR = temp; + + bR[84] = bR[83]; bR[83] = bR[82]; bR[82] = bR[81]; bR[81] = bR[80]; bR[80] = bR[79]; + bR[79] = bR[78]; bR[78] = bR[77]; bR[77] = bR[76]; bR[76] = bR[75]; bR[75] = bR[74]; bR[74] = bR[73]; bR[73] = bR[72]; bR[72] = bR[71]; + bR[71] = bR[70]; bR[70] = bR[69]; bR[69] = bR[68]; bR[68] = bR[67]; bR[67] = bR[66]; bR[66] = bR[65]; bR[65] = bR[64]; bR[64] = bR[63]; + bR[63] = bR[62]; bR[62] = bR[61]; bR[61] = bR[60]; bR[60] = bR[59]; bR[59] = bR[58]; bR[58] = bR[57]; bR[57] = bR[56]; bR[56] = bR[55]; + bR[55] = bR[54]; bR[54] = bR[53]; bR[53] = bR[52]; bR[52] = bR[51]; bR[51] = bR[50]; bR[50] = bR[49]; bR[49] = bR[48]; bR[48] = bR[47]; + bR[47] = bR[46]; bR[46] = bR[45]; bR[45] = bR[44]; bR[44] = bR[43]; bR[43] = bR[42]; bR[42] = bR[41]; bR[41] = bR[40]; bR[40] = bR[39]; + bR[39] = bR[38]; bR[38] = bR[37]; bR[37] = bR[36]; bR[36] = bR[35]; bR[35] = bR[34]; bR[34] = bR[33]; bR[33] = bR[32]; bR[32] = bR[31]; + bR[31] = bR[30]; bR[30] = bR[29]; bR[29] = bR[28]; bR[28] = bR[27]; bR[27] = bR[26]; bR[26] = bR[25]; bR[25] = bR[24]; bR[24] = bR[23]; + bR[23] = bR[22]; bR[22] = bR[21]; bR[21] = bR[20]; bR[20] = bR[19]; bR[19] = bR[18]; bR[18] = bR[17]; bR[17] = bR[16]; bR[16] = bR[15]; + bR[15] = bR[14]; bR[14] = bR[13]; bR[13] = bR[12]; bR[12] = bR[11]; bR[11] = bR[10]; bR[10] = bR[9]; bR[9] = bR[8]; bR[8] = bR[7]; + bR[7] = bR[6]; bR[6] = bR[5]; bR[5] = bR[4]; bR[4] = bR[3]; bR[3] = bR[2]; bR[2] = bR[1]; bR[1] = bR[0]; bR[0] = inputSampleR; + inputSampleR += (bR[1] * (1.31698250313308396 - (0.08140616497621633*fabs(bR[1])))); + inputSampleR += (bR[2] * (1.47229016949915326 - (0.27680278993637253*fabs(bR[2])))); + inputSampleR += (bR[3] * (1.30410109086044956 - (0.35629113432046489*fabs(bR[3])))); + inputSampleR += (bR[4] * (0.81766210474551260 - (0.26808782337659753*fabs(bR[4])))); + inputSampleR += (bR[5] * (0.19868872545506663 - (0.11105517193919669*fabs(bR[5])))); + inputSampleR -= (bR[6] * (0.39115909132567039 - (0.12630622002682679*fabs(bR[6])))); + inputSampleR -= (bR[7] * (0.76881891559343574 - (0.40879849500403143*fabs(bR[7])))); + inputSampleR -= (bR[8] * (0.87146861782680340 - (0.59529560488000599*fabs(bR[8])))); + inputSampleR -= (bR[9] * (0.79504575932563670 - (0.60877047551611796*fabs(bR[9])))); + inputSampleR -= (bR[10] * (0.61653017622406314 - (0.47662851438557335*fabs(bR[10])))); + inputSampleR -= (bR[11] * (0.40718195794382067 - (0.24955839378539713*fabs(bR[11])))); + inputSampleR -= (bR[12] * (0.31794900040616203 - (0.04169792259600613*fabs(bR[12])))); + inputSampleR -= (bR[13] * (0.41075032540217843 + (0.00368483996076280*fabs(bR[13])))); + inputSampleR -= (bR[14] * (0.56901352922170667 - (0.11027360805893105*fabs(bR[14])))); + inputSampleR -= (bR[15] * (0.62443222391889264 - (0.22198075154245228*fabs(bR[15])))); + inputSampleR -= (bR[16] * (0.53462856723129204 - (0.22933544545324852*fabs(bR[16])))); + inputSampleR -= (bR[17] * (0.34441703361995046 - (0.12956809502269492*fabs(bR[17])))); + inputSampleR -= (bR[18] * (0.13947052337867882 + (0.00339775055962799*fabs(bR[18])))); + inputSampleR += (bR[19] * (0.03771252648928484 - (0.10863931549251718*fabs(bR[19])))); + inputSampleR += (bR[20] * (0.18280210770271693 - (0.17413646599296417*fabs(bR[20])))); + inputSampleR += (bR[21] * (0.24621986701761467 - (0.14547053270435095*fabs(bR[21])))); + inputSampleR += (bR[22] * (0.22347075142737360 - (0.02493869490104031*fabs(bR[22])))); + inputSampleR += (bR[23] * (0.14346348482123716 + (0.11284054747963246*fabs(bR[23])))); + inputSampleR += (bR[24] * (0.00834364862916028 + (0.24284684053733926*fabs(bR[24])))); + inputSampleR -= (bR[25] * (0.11559740296078347 - (0.32623054435304538*fabs(bR[25])))); + inputSampleR -= (bR[26] * (0.18067604561283060 - (0.32311481551122478*fabs(bR[26])))); + inputSampleR -= (bR[27] * (0.22927997789035612 - (0.26991539052832925*fabs(bR[27])))); + inputSampleR -= (bR[28] * (0.28487666578669446 - (0.22437227250279349*fabs(bR[28])))); + inputSampleR -= (bR[29] * (0.31992973037153838 - (0.15289876100963865*fabs(bR[29])))); + inputSampleR -= (bR[30] * (0.35174606303520733 - (0.05656293023086628*fabs(bR[30])))); + inputSampleR -= (bR[31] * (0.36894898011375254 + (0.04333925421463558*fabs(bR[31])))); + inputSampleR -= (bR[32] * (0.32567576055307507 + (0.14594589410921388*fabs(bR[32])))); + inputSampleR -= (bR[33] * (0.27440135050585784 + (0.15529667398122521*fabs(bR[33])))); + inputSampleR -= (bR[34] * (0.21998973785078091 + (0.05083553737157104*fabs(bR[34])))); + inputSampleR -= (bR[35] * (0.10323624876862457 - (0.04651829594199963*fabs(bR[35])))); + inputSampleR += (bR[36] * (0.02091603687851074 + (0.12000046818439322*fabs(bR[36])))); + inputSampleR += (bR[37] * (0.11344930914138468 + (0.17697142512225839*fabs(bR[37])))); + inputSampleR += (bR[38] * (0.22766779627643968 + (0.13645102964003858*fabs(bR[38])))); + inputSampleR += (bR[39] * (0.38378309953638229 - (0.01997653307333791*fabs(bR[39])))); + inputSampleR += (bR[40] * (0.52789400804568076 - (0.21409137428422448*fabs(bR[40])))); + inputSampleR += (bR[41] * (0.55444630296938280 - (0.32331980931576626*fabs(bR[41])))); + inputSampleR += (bR[42] * (0.42333237669264601 - (0.26855847463044280*fabs(bR[42])))); + inputSampleR += (bR[43] * (0.21942831522035078 - (0.12051365248820624*fabs(bR[43])))); + inputSampleR -= (bR[44] * (0.00584169427830633 - (0.03706970171280329*fabs(bR[44])))); + inputSampleR -= (bR[45] * (0.24279799124660351 - (0.17296440491477982*fabs(bR[45])))); + inputSampleR -= (bR[46] * (0.40173760787507085 - (0.21717989835163351*fabs(bR[46])))); + inputSampleR -= (bR[47] * (0.43930035724188155 - (0.16425928481378199*fabs(bR[47])))); + inputSampleR -= (bR[48] * (0.41067765934041811 - (0.10390115786636855*fabs(bR[48])))); + inputSampleR -= (bR[49] * (0.34409235547165967 - (0.07268159377411920*fabs(bR[49])))); + inputSampleR -= (bR[50] * (0.26542883122568151 - (0.05483457497365785*fabs(bR[50])))); + inputSampleR -= (bR[51] * (0.22024754776138800 - (0.06484897950087598*fabs(bR[51])))); + inputSampleR -= (bR[52] * (0.20394367993632415 - (0.08746309731952180*fabs(bR[52])))); + inputSampleR -= (bR[53] * (0.17565242431124092 - (0.07611309538078760*fabs(bR[53])))); + inputSampleR -= (bR[54] * (0.10116623231246825 - (0.00642818706295112*fabs(bR[54])))); + inputSampleR -= (bR[55] * (0.00782648272053632 + (0.08004141267685004*fabs(bR[55])))); + inputSampleR += (bR[56] * (0.05059046006747323 - (0.12436676387548490*fabs(bR[56])))); + inputSampleR += (bR[57] * (0.06241531553254467 - (0.11530779547021434*fabs(bR[57])))); + inputSampleR += (bR[58] * (0.04952694587101836 - (0.08340945324333944*fabs(bR[58])))); + inputSampleR += (bR[59] * (0.00843873294401687 - (0.03279659052562903*fabs(bR[59])))); + inputSampleR -= (bR[60] * (0.05161338949440241 - (0.03428181149163798*fabs(bR[60])))); + inputSampleR -= (bR[61] * (0.08165520146902012 - (0.08196746092283110*fabs(bR[61])))); + inputSampleR -= (bR[62] * (0.06639532849935320 - (0.09797462781896329*fabs(bR[62])))); + inputSampleR -= (bR[63] * (0.02953430910661621 - (0.09175612938515763*fabs(bR[63])))); + inputSampleR += (bR[64] * (0.00741058547442938 + (0.05442091048731967*fabs(bR[64])))); + inputSampleR += (bR[65] * (0.01832866125391727 + (0.00306243693643687*fabs(bR[65])))); + inputSampleR += (bR[66] * (0.00526964230373573 - (0.04364102661136410*fabs(bR[66])))); + inputSampleR -= (bR[67] * (0.00300984373848200 + (0.09742737841278880*fabs(bR[67])))); + inputSampleR -= (bR[68] * (0.00413616769576694 + (0.14380661694523073*fabs(bR[68])))); + inputSampleR -= (bR[69] * (0.00588769034931419 + (0.16012843578892538*fabs(bR[69])))); + inputSampleR -= (bR[70] * (0.00688588239450581 + (0.14074464279305798*fabs(bR[70])))); + inputSampleR -= (bR[71] * (0.02277307992926315 + (0.07914752191801366*fabs(bR[71])))); + inputSampleR -= (bR[72] * (0.04627166091180877 - (0.00192787268067208*fabs(bR[72])))); + inputSampleR -= (bR[73] * (0.05562045897455786 - (0.05932868727665747*fabs(bR[73])))); + inputSampleR -= (bR[74] * (0.05134243784922165 - (0.08245334798868090*fabs(bR[74])))); + inputSampleR -= (bR[75] * (0.04719409472239919 - (0.07498680629253825*fabs(bR[75])))); + inputSampleR -= (bR[76] * (0.05889738914266415 - (0.06116127018043697*fabs(bR[76])))); + inputSampleR -= (bR[77] * (0.09428363535111127 - (0.06535868867863834*fabs(bR[77])))); + inputSampleR -= (bR[78] * (0.15181756953225126 - (0.08982979655234427*fabs(bR[78])))); + inputSampleR -= (bR[79] * (0.20878969456036670 - (0.10761070891499538*fabs(bR[79])))); + inputSampleR -= (bR[80] * (0.22647885581813790 - (0.08462542510349125*fabs(bR[80])))); + inputSampleR -= (bR[81] * (0.19723482443646323 - (0.02665160920736287*fabs(bR[81])))); + inputSampleR -= (bR[82] * (0.16441643451155163 + (0.02314691954338197*fabs(bR[82])))); + inputSampleR -= (bR[83] * (0.15201914054931515 + (0.04424903493886839*fabs(bR[83])))); + inputSampleR -= (bR[84] * (0.15454370641307855 + (0.04223203797913008*fabs(bR[84])))); + + temp = (inputSampleR + smoothCabBR)/3.0; + smoothCabBR = inputSampleR; + inputSampleR = temp/4.0; + + randy = ((double(fpdR)/UINT32_MAX)*0.057); + drySampleR = ((((inputSampleR*(1.0-randy))+(lastCabSampleR*randy))*wet)+(drySampleR*(1.0-wet)))*outputlevel; + lastCabSampleR = inputSampleR; + inputSampleR = drySampleR; //cab + + if (cycleEnd == 4) { + lastRefL[0] = lastRefL[4]; //start from previous last + lastRefL[2] = (lastRefL[0] + inputSampleL)/2; //half + lastRefL[1] = (lastRefL[0] + lastRefL[2])/2; //one quarter + lastRefL[3] = (lastRefL[2] + inputSampleL)/2; //three quarters + lastRefL[4] = inputSampleL; //full + lastRefR[0] = lastRefR[4]; //start from previous last + lastRefR[2] = (lastRefR[0] + inputSampleR)/2; //half + lastRefR[1] = (lastRefR[0] + lastRefR[2])/2; //one quarter + lastRefR[3] = (lastRefR[2] + inputSampleR)/2; //three quarters + lastRefR[4] = inputSampleR; //full + } + if (cycleEnd == 3) { + lastRefL[0] = lastRefL[3]; //start from previous last + lastRefL[2] = (lastRefL[0]+lastRefL[0]+inputSampleL)/3; //third + lastRefL[1] = (lastRefL[0]+inputSampleL+inputSampleL)/3; //two thirds + lastRefL[3] = inputSampleL; //full + lastRefR[0] = lastRefR[3]; //start from previous last + lastRefR[2] = (lastRefR[0]+lastRefR[0]+inputSampleR)/3; //third + lastRefR[1] = (lastRefR[0]+inputSampleR+inputSampleR)/3; //two thirds + lastRefR[3] = inputSampleR; //full + } + if (cycleEnd == 2) { + lastRefL[0] = lastRefL[2]; //start from previous last + lastRefL[1] = (lastRefL[0] + inputSampleL)/2; //half + lastRefL[2] = inputSampleL; //full + lastRefR[0] = lastRefR[2]; //start from previous last + lastRefR[1] = (lastRefR[0] + inputSampleR)/2; //half + lastRefR[2] = inputSampleR; //full + } + if (cycleEnd == 1) { + lastRefL[0] = inputSampleL; + lastRefR[0] = inputSampleR; + } + cycle = 0; //reset + inputSampleL = lastRefL[cycle]; + inputSampleR = lastRefR[cycle]; + } else { + inputSampleL = lastRefL[cycle]; + inputSampleR = lastRefR[cycle]; + //we are going through our references now + } + switch (cycleEnd) //multi-pole average using lastRef[] variables + { + case 4: + lastRefL[8] = inputSampleL; inputSampleL = (inputSampleL+lastRefL[7])*0.5; + lastRefL[7] = lastRefL[8]; //continue, do not break + lastRefR[8] = inputSampleR; inputSampleR = (inputSampleR+lastRefR[7])*0.5; + lastRefR[7] = lastRefR[8]; //continue, do not break + case 3: + lastRefL[8] = inputSampleL; inputSampleL = (inputSampleL+lastRefL[6])*0.5; + lastRefL[6] = lastRefL[8]; //continue, do not break + lastRefR[8] = inputSampleR; inputSampleR = (inputSampleR+lastRefR[6])*0.5; + lastRefR[6] = lastRefR[8]; //continue, do not break + case 2: + lastRefL[8] = inputSampleL; inputSampleL = (inputSampleL+lastRefL[5])*0.5; + lastRefL[5] = lastRefL[8]; //continue, do not break + lastRefR[8] = inputSampleR; inputSampleR = (inputSampleR+lastRefR[5])*0.5; + lastRefR[5] = lastRefR[8]; //continue, do not break + case 1: + break; //no further averaging + } + + //begin 64 bit stereo floating point dither + //int expon; frexp((double)inputSampleL, &expon); + fpdL ^= fpdL << 13; fpdL ^= fpdL >> 17; fpdL ^= fpdL << 5; + //inputSampleL += ((double(fpdL)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62)); + //frexp((double)inputSampleR, &expon); + fpdR ^= fpdR << 13; fpdR ^= fpdR >> 17; fpdR ^= fpdR << 5; + //inputSampleR += ((double(fpdR)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62)); + //end 64 bit stereo floating point dither + + *out1 = inputSampleL; + *out2 = inputSampleR; + + in1++; + in2++; + out1++; + out2++; + } +} diff --git a/plugin/Source/FX/GrindAmp.cpp b/plugin/Source/FX/GrindAmp.cpp new file mode 100755 index 0000000..ca8d322 --- /dev/null +++ b/plugin/Source/FX/GrindAmp.cpp @@ -0,0 +1,258 @@ +/* ======================================== + * GrindAmp - GrindAmp.h + * Copyright (c) 2016 airwindows, Airwindows uses the MIT license + * ======================================== */ + +#ifndef __Gain_H +#include "GrindAmp.h" +#endif + +JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wfloat-conversion", "-Wimplicit-float-conversion", "-Wunused-parameter") + +GrindAmp::GrindAmp(audioMasterCallback audioMaster) : + AudioEffectX(audioMaster, kNumPrograms, kNumParameters) +{ + A = 0.5; + B = 0.5; + C = 0.8; + D = 1.0; + + smoothAL = 0.0; + smoothBL = 0.0; + smoothCL = 0.0; + smoothDL = 0.0; + smoothEL = 0.0; + smoothFL = 0.0; + smoothGL = 0.0; + smoothHL = 0.0; + smoothIL = 0.0; + smoothJL = 0.0; + smoothKL = 0.0; + secondAL = 0.0; + secondBL = 0.0; + secondCL = 0.0; + secondDL = 0.0; + secondEL = 0.0; + secondFL = 0.0; + secondGL = 0.0; + secondHL = 0.0; + secondIL = 0.0; + secondJL = 0.0; + secondKL = 0.0; + thirdAL = 0.0; + thirdBL = 0.0; + thirdCL = 0.0; + thirdDL = 0.0; + thirdEL = 0.0; + thirdFL = 0.0; + thirdGL = 0.0; + thirdHL = 0.0; + thirdIL = 0.0; + thirdJL = 0.0; + thirdKL = 0.0; + iirSampleAL = 0.0; + iirSampleBL = 0.0; + iirSampleCL = 0.0; + iirSampleDL = 0.0; + iirSampleEL = 0.0; + iirSampleFL = 0.0; + iirSampleGL = 0.0; + iirSampleHL = 0.0; + iirSampleIL = 0.0; + iirLowpassL = 0.0; + iirSubL = 0.0; + storeSampleL = 0.0; //amp + + smoothAR = 0.0; + smoothBR = 0.0; + smoothCR = 0.0; + smoothDR = 0.0; + smoothER = 0.0; + smoothFR = 0.0; + smoothGR = 0.0; + smoothHR = 0.0; + smoothIR = 0.0; + smoothJR = 0.0; + smoothKR = 0.0; + secondAR = 0.0; + secondBR = 0.0; + secondCR = 0.0; + secondDR = 0.0; + secondER = 0.0; + secondFR = 0.0; + secondGR = 0.0; + secondHR = 0.0; + secondIR = 0.0; + secondJR = 0.0; + secondKR = 0.0; + thirdAR = 0.0; + thirdBR = 0.0; + thirdCR = 0.0; + thirdDR = 0.0; + thirdER = 0.0; + thirdFR = 0.0; + thirdGR = 0.0; + thirdHR = 0.0; + thirdIR = 0.0; + thirdJR = 0.0; + thirdKR = 0.0; + iirSampleAR = 0.0; + iirSampleBR = 0.0; + iirSampleCR = 0.0; + iirSampleDR = 0.0; + iirSampleER = 0.0; + iirSampleFR = 0.0; + iirSampleGR = 0.0; + iirSampleHR = 0.0; + iirSampleIR = 0.0; + iirLowpassR = 0.0; + iirSubR = 0.0; + storeSampleR = 0.0; //amp + + for(int fcount = 0; fcount < 90; fcount++) { + bL[fcount] = 0; + bR[fcount] = 0; + } + smoothCabAL = 0.0; smoothCabBL = 0.0; lastCabSampleL = 0.0; //cab + smoothCabAR = 0.0; smoothCabBR = 0.0; lastCabSampleR = 0.0; //cab + + for (int fcount = 0; fcount < 9; fcount++) { + lastRefL[fcount] = 0.0; + lastRefR[fcount] = 0.0; + } + cycle = 0; //undersampling + + for (int x = 0; x < fix_total; x++) { + fixA[x] = 0.0; + fixB[x] = 0.0; + fixC[x] = 0.0; + fixD[x] = 0.0; + fixE[x] = 0.0; + fixF[x] = 0.0; + } //filtering + + 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 +} + +GrindAmp::~GrindAmp() {} +VstInt32 GrindAmp::getVendorVersion () {return 1000;} +void GrindAmp::setProgramName(char *name) {vst_strncpy (_programName, name, kVstMaxProgNameLen);} +void GrindAmp::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 GrindAmp::getChunk (void** data, bool isPreset) +{ + float *chunkData = (float *)calloc(kNumParameters, sizeof(float)); + chunkData[0] = A; + chunkData[1] = B; + chunkData[2] = C; + chunkData[3] = D; + /* 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 GrindAmp::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]); + /* 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 GrindAmp::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; + default: throw; // unknown parameter, shouldn't happen! + } +} + +float GrindAmp::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; + default: break; // unknown parameter, shouldn't happen! + } return 0.0; //we only need to update the relevant name, this is simple to manage +} + +void GrindAmp::getParameterName(VstInt32 index, char *text) { + switch (index) { + case kParamA: vst_strncpy (text, "Gain", kVstMaxParamStrLen); break; + case kParamB: vst_strncpy (text, "Tone", kVstMaxParamStrLen); break; + case kParamC: vst_strncpy (text, "Output", kVstMaxParamStrLen); break; + case kParamD: 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 GrindAmp::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; + case kParamD: float2string (D, text, kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } //this displays the values and handles 'popups' where it's discrete choices +} + +void GrindAmp::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; + default: break; // unknown parameter, shouldn't happen! + } +} + +VstInt32 GrindAmp::canDo(char *text) +{ return (_canDo.find(text) == _canDo.end()) ? -1: 1; } // 1 = yes, -1 = no, 0 = don't know + +bool GrindAmp::getEffectName(char* name) { + vst_strncpy(name, "GrindAmp", kVstMaxProductStrLen); return true; +} + +VstPlugCategory GrindAmp::getPlugCategory() {return kPlugCategEffect;} + +bool GrindAmp::getProductString(char* text) { + vst_strncpy (text, "airwindows GrindAmp", kVstMaxProductStrLen); return true; +} + +bool GrindAmp::getVendorString(char* text) { + vst_strncpy (text, "airwindows", kVstMaxVendorStrLen); return true; +} diff --git a/plugin/Source/FX/GrindAmp.h b/plugin/Source/FX/GrindAmp.h new file mode 100755 index 0000000..59cf043 --- /dev/null +++ b/plugin/Source/FX/GrindAmp.h @@ -0,0 +1,190 @@ +/* ======================================== + * GrindAmp - GrindAmp.h + * Created 8/12/11 by SPIAdmin + * Copyright (c) 2011 __MyCompanyName__, Airwindows uses the MIT license + * ======================================== */ + +#pragma once + +#include "FXBase.h" + +#include +#include +#include + +class GrindAmp : + public AudioEffectX +{ +public: + enum { + kParamA = 0, + kParamB = 1, + kParamC = 2, + kParamD = 3, + kNumParameters = 4 + }; // + + static constexpr int kNumPrograms = 0; + static constexpr int kNumInputs = 2; + static constexpr int kNumOutputs = 2; + static constexpr unsigned long kUniqueId = 'grda'; //Change this to what the AU identity is! + + GrindAmp(audioMasterCallback audioMaster); + ~GrindAmp(); + 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; + + double smoothAL; + double smoothBL; + double smoothCL; + double smoothDL; + double smoothEL; + double smoothFL; + double smoothGL; + double smoothHL; + double smoothIL; + double smoothJL; + double smoothKL; + double secondAL; + double secondBL; + double secondCL; + double secondDL; + double secondEL; + double secondFL; + double secondGL; + double secondHL; + double secondIL; + double secondJL; + double secondKL; + double thirdAL; + double thirdBL; + double thirdCL; + double thirdDL; + double thirdEL; + double thirdFL; + double thirdGL; + double thirdHL; + double thirdIL; + double thirdJL; + double thirdKL; + double iirSampleAL; + double iirSampleBL; + double iirSampleCL; + double iirSampleDL; + double iirSampleEL; + double iirSampleFL; + double iirSampleGL; + double iirSampleHL; + double iirSampleIL; + double iirLowpassL; + double iirSubL; + double storeSampleL; //amp + + double smoothAR; + double smoothBR; + double smoothCR; + double smoothDR; + double smoothER; + double smoothFR; + double smoothGR; + double smoothHR; + double smoothIR; + double smoothJR; + double smoothKR; + double secondAR; + double secondBR; + double secondCR; + double secondDR; + double secondER; + double secondFR; + double secondGR; + double secondHR; + double secondIR; + double secondJR; + double secondKR; + double thirdAR; + double thirdBR; + double thirdCR; + double thirdDR; + double thirdER; + double thirdFR; + double thirdGR; + double thirdHR; + double thirdIR; + double thirdJR; + double thirdKR; + double iirSampleAR; + double iirSampleBR; + double iirSampleCR; + double iirSampleDR; + double iirSampleER; + double iirSampleFR; + double iirSampleGR; + double iirSampleHR; + double iirSampleIR; + double iirLowpassR; + double iirSubR; + double storeSampleR; //amp + + double bL[90]; + double lastCabSampleL; + double smoothCabAL; + double smoothCabBL; //cab + + double bR[90]; + double lastCabSampleR; + double smoothCabAR; + double smoothCabBR; //cab + + double lastRefL[10]; + double lastRefR[10]; + int cycle; //undersampling + + enum { + fix_freq, + fix_reso, + fix_a0, + fix_a1, + fix_a2, + fix_b1, + fix_b2, + fix_sL1, + fix_sL2, + fix_sR1, + fix_sR2, + fix_total + }; //fixed frequency biquad filter for ultrasonics, stereo + double fixA[fix_total]; + double fixB[fix_total]; + double fixC[fix_total]; + double fixD[fix_total]; + double fixE[fix_total]; + double fixF[fix_total]; //filtering + + uint32_t fpdL; + uint32_t fpdR; + //default stuff + + float A; + float B; + float C; + float D; +}; diff --git a/plugin/Source/FX/GrindAmpProc.cpp b/plugin/Source/FX/GrindAmpProc.cpp new file mode 100755 index 0000000..05c8ff7 --- /dev/null +++ b/plugin/Source/FX/GrindAmpProc.cpp @@ -0,0 +1,1652 @@ +/* ======================================== + * GrindAmp - GrindAmp.h + * Copyright (c) 2016 airwindows, Airwindows uses the MIT license + * ======================================== */ + +#ifndef __Gain_H +#include "GrindAmp.h" +#endif + +JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wfloat-conversion", "-Wimplicit-float-conversion", "-Wunused-parameter") + +void GrindAmp::processReplacing(float **inputs, float **outputs, VstInt32 sampleFrames) +{ + float* in1 = inputs[0]; + float* in2 = inputs[1]; + float* out1 = outputs[0]; + float* out2 = outputs[1]; + + double overallscale = 1.0; + overallscale /= 44100.0; + overallscale *= getSampleRate(); + int cycleEnd = floor(overallscale); + if (cycleEnd < 1) cycleEnd = 1; + if (cycleEnd > 4) cycleEnd = 4; + //this is going to be 2 for 88.1 or 96k, 3 for silly people, 4 for 176 or 192k + if (cycle > cycleEnd-1) cycle = cycleEnd-1; //sanity check + + double inputlevel = pow(A,2); + double samplerate = getSampleRate(); + double trimEQ = 1.1-B; + double toneEQ = trimEQ/1.2; + trimEQ /= 50.0; + trimEQ += 0.165; + double EQ = ((trimEQ-(toneEQ/6.1)) / samplerate)*22050.0; + double BEQ = ((trimEQ+(toneEQ/2.1)) / samplerate)*22050.0; + double outputlevel = C; + double wet = D; + double bassdrive = 1.57079633*(2.5-toneEQ); + + double cutoff = (18000.0+(B*1000.0)) / getSampleRate(); + if (cutoff > 0.49) cutoff = 0.49; //don't crash if run at 44.1k + if (cutoff < 0.001) cutoff = 0.001; //or if cutoff's too low + + fixF[fix_freq] = fixE[fix_freq] = fixD[fix_freq] = fixC[fix_freq] = fixB[fix_freq] = fixA[fix_freq] = cutoff; + + fixA[fix_reso] = 4.46570214; + fixB[fix_reso] = 1.51387132; + fixC[fix_reso] = 0.93979296; + fixD[fix_reso] = 0.70710678; + fixE[fix_reso] = 0.52972649; + fixF[fix_reso] = 0.50316379; + + double K = tan(M_PI * fixA[fix_freq]); //lowpass + double norm = 1.0 / (1.0 + K / fixA[fix_reso] + K * K); + fixA[fix_a0] = K * K * norm; + fixA[fix_a1] = 2.0 * fixA[fix_a0]; + fixA[fix_a2] = fixA[fix_a0]; + fixA[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixA[fix_b2] = (1.0 - K / fixA[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixB[fix_freq]); + norm = 1.0 / (1.0 + K / fixB[fix_reso] + K * K); + fixB[fix_a0] = K * K * norm; + fixB[fix_a1] = 2.0 * fixB[fix_a0]; + fixB[fix_a2] = fixB[fix_a0]; + fixB[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixB[fix_b2] = (1.0 - K / fixB[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixC[fix_freq]); + norm = 1.0 / (1.0 + K / fixC[fix_reso] + K * K); + fixC[fix_a0] = K * K * norm; + fixC[fix_a1] = 2.0 * fixC[fix_a0]; + fixC[fix_a2] = fixC[fix_a0]; + fixC[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixC[fix_b2] = (1.0 - K / fixC[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixD[fix_freq]); + norm = 1.0 / (1.0 + K / fixD[fix_reso] + K * K); + fixD[fix_a0] = K * K * norm; + fixD[fix_a1] = 2.0 * fixD[fix_a0]; + fixD[fix_a2] = fixD[fix_a0]; + fixD[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixD[fix_b2] = (1.0 - K / fixD[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixE[fix_freq]); + norm = 1.0 / (1.0 + K / fixE[fix_reso] + K * K); + fixE[fix_a0] = K * K * norm; + fixE[fix_a1] = 2.0 * fixE[fix_a0]; + fixE[fix_a2] = fixE[fix_a0]; + fixE[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixE[fix_b2] = (1.0 - K / fixE[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixF[fix_freq]); + norm = 1.0 / (1.0 + K / fixF[fix_reso] + K * K); + fixF[fix_a0] = K * K * norm; + fixF[fix_a1] = 2.0 * fixF[fix_a0]; + fixF[fix_a2] = fixF[fix_a0]; + fixF[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixF[fix_b2] = (1.0 - K / fixF[fix_reso] + K * K) * norm; + + while (--sampleFrames >= 0) + { + double inputSampleL = *in1; + double inputSampleR = *in2; + if (fabs(inputSampleL)<1.18e-23) inputSampleL = fpdL * 1.18e-17; + if (fabs(inputSampleR)<1.18e-23) inputSampleR = fpdR * 1.18e-17; + double drySampleL = inputSampleL; + double drySampleR = inputSampleR; + + double outSample = (inputSampleL * fixA[fix_a0]) + fixA[fix_sL1]; + fixA[fix_sL1] = (inputSampleL * fixA[fix_a1]) - (outSample * fixA[fix_b1]) + fixA[fix_sL2]; + fixA[fix_sL2] = (inputSampleL * fixA[fix_a2]) - (outSample * fixA[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixA[fix_a0]) + fixA[fix_sR1]; + fixA[fix_sR1] = (inputSampleR * fixA[fix_a1]) - (outSample * fixA[fix_b1]) + fixA[fix_sR2]; + fixA[fix_sR2] = (inputSampleR * fixA[fix_a2]) - (outSample * fixA[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + inputSampleL *= inputlevel; + iirSampleAL = (iirSampleAL * (1.0 - EQ)) + (inputSampleL * EQ); + inputSampleL = inputSampleL - (iirSampleAL*0.92); + //highpass + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; + double bridgerectifier = fabs(inputSampleL); + double inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothAL + (secondAL*inverse) + (thirdAL*bridgerectifier) + inputSampleL); + thirdAL = secondAL; + secondAL = smoothAL; + smoothAL = inputSampleL; + double basscatchL = inputSampleL = bridgerectifier; + //three-sample averaging lowpass + + inputSampleR *= inputlevel; + iirSampleAR = (iirSampleAR * (1.0 - EQ)) + (inputSampleR * EQ); + inputSampleR = inputSampleR - (iirSampleAR*0.92); + //highpass + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; + bridgerectifier = fabs(inputSampleR); + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothAR + (secondAR*inverse) + (thirdAR*bridgerectifier) + inputSampleR); + thirdAR = secondAR; + secondAR = smoothAR; + smoothAR = inputSampleR; + double basscatchR = inputSampleR = bridgerectifier; + //three-sample averaging lowpass + + outSample = (inputSampleL * fixB[fix_a0]) + fixB[fix_sL1]; + fixB[fix_sL1] = (inputSampleL * fixB[fix_a1]) - (outSample * fixB[fix_b1]) + fixB[fix_sL2]; + fixB[fix_sL2] = (inputSampleL * fixB[fix_a2]) - (outSample * fixB[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixB[fix_a0]) + fixB[fix_sR1]; + fixB[fix_sR1] = (inputSampleR * fixB[fix_a1]) - (outSample * fixB[fix_b1]) + fixB[fix_sR2]; + fixB[fix_sR2] = (inputSampleR * fixB[fix_a2]) - (outSample * fixB[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + inputSampleL *= inputlevel; + iirSampleBL = (iirSampleBL * (1.0 - EQ)) + (inputSampleL * EQ); + inputSampleL = inputSampleL - (iirSampleBL*0.79); + //highpass + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; + //overdrive + bridgerectifier = fabs(inputSampleL); + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothBL + (secondBL*inverse) + (thirdBL*bridgerectifier) + inputSampleL); + thirdBL = secondBL; + secondBL = smoothBL; + smoothBL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + + inputSampleR *= inputlevel; + iirSampleBR = (iirSampleBR * (1.0 - EQ)) + (inputSampleR * EQ); + inputSampleR = inputSampleR - (iirSampleBR*0.79); + //highpass + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; + //overdrive + bridgerectifier = fabs(inputSampleR); + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothBR + (secondBR*inverse) + (thirdBR*bridgerectifier) + inputSampleR); + thirdBR = secondBR; + secondBR = smoothBR; + smoothBR = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + + iirSampleCL = (iirSampleCL * (1.0 - BEQ)) + (basscatchL * BEQ); + basscatchL = iirSampleCL*bassdrive; + bridgerectifier = fabs(basscatchL); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchL > 0.0) basscatchL = bridgerectifier; + else basscatchL = -bridgerectifier; + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothCL + (secondCL*inverse) + (thirdCL*bridgerectifier) + inputSampleL); + thirdCL = secondCL; + secondCL = smoothCL; + smoothCL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + + iirSampleCR = (iirSampleCR * (1.0 - BEQ)) + (basscatchR * BEQ); + basscatchR = iirSampleCR*bassdrive; + bridgerectifier = fabs(basscatchR); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchR > 0.0) basscatchR = bridgerectifier; + else basscatchR = -bridgerectifier; + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothCR + (secondCR*inverse) + (thirdCR*bridgerectifier) + inputSampleR); + thirdCR = secondCR; + secondCR = smoothCR; + smoothCR = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + + outSample = (inputSampleL * fixC[fix_a0]) + fixC[fix_sL1]; + fixC[fix_sL1] = (inputSampleL * fixC[fix_a1]) - (outSample * fixC[fix_b1]) + fixC[fix_sL2]; + fixC[fix_sL2] = (inputSampleL * fixC[fix_a2]) - (outSample * fixC[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixC[fix_a0]) + fixC[fix_sR1]; + fixC[fix_sR1] = (inputSampleR * fixC[fix_a1]) - (outSample * fixC[fix_b1]) + fixC[fix_sR2]; + fixC[fix_sR2] = (inputSampleR * fixC[fix_a2]) - (outSample * fixC[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + iirSampleDL = (iirSampleDL * (1.0 - BEQ)) + (basscatchL * BEQ); + basscatchL = iirSampleDL*bassdrive; + bridgerectifier = fabs(basscatchL); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchL > 0.0) basscatchL = bridgerectifier; + else basscatchL = -bridgerectifier; + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothDL + (secondDL*inverse) + (thirdDL*bridgerectifier) + inputSampleL); + thirdDL = secondDL; + secondDL = smoothDL; + smoothDL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + + iirSampleDR = (iirSampleDR * (1.0 - BEQ)) + (basscatchR * BEQ); + basscatchR = iirSampleDR*bassdrive; + bridgerectifier = fabs(basscatchR); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchR > 0.0) basscatchR = bridgerectifier; + else basscatchR = -bridgerectifier; + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothDR + (secondDR*inverse) + (thirdDR*bridgerectifier) + inputSampleR); + thirdDR = secondDR; + secondDR = smoothDR; + smoothDR = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + + outSample = (inputSampleL * fixD[fix_a0]) + fixD[fix_sL1]; + fixD[fix_sL1] = (inputSampleL * fixD[fix_a1]) - (outSample * fixD[fix_b1]) + fixD[fix_sL2]; + fixD[fix_sL2] = (inputSampleL * fixD[fix_a2]) - (outSample * fixD[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixD[fix_a0]) + fixD[fix_sR1]; + fixD[fix_sR1] = (inputSampleR * fixD[fix_a1]) - (outSample * fixD[fix_b1]) + fixD[fix_sR2]; + fixD[fix_sR2] = (inputSampleR * fixD[fix_a2]) - (outSample * fixD[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + iirSampleEL = (iirSampleEL * (1.0 - BEQ)) + (basscatchL * BEQ); + basscatchL = iirSampleEL*bassdrive; + bridgerectifier = fabs(basscatchL); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchL > 0.0) basscatchL = bridgerectifier; + else basscatchL = -bridgerectifier; + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothEL + (secondEL*inverse) + (thirdEL*bridgerectifier) + inputSampleL); + thirdEL = secondEL; + secondEL = smoothEL; + smoothEL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + + iirSampleER = (iirSampleER * (1.0 - BEQ)) + (basscatchR * BEQ); + basscatchR = iirSampleER*bassdrive; + bridgerectifier = fabs(basscatchR); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchR > 0.0) basscatchR = bridgerectifier; + else basscatchR = -bridgerectifier; + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothER + (secondER*inverse) + (thirdER*bridgerectifier) + inputSampleR); + thirdER = secondER; + secondER = smoothER; + smoothER = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + + iirSampleFL = (iirSampleFL * (1.0 - BEQ)) + (basscatchL * BEQ); + basscatchL = iirSampleFL*bassdrive; + bridgerectifier = fabs(basscatchL); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchL > 0.0) basscatchL = bridgerectifier; + else basscatchL = -bridgerectifier; + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothFL + (secondFL*inverse) + (thirdFL*bridgerectifier) + inputSampleL); + thirdFL = secondFL; + secondFL = smoothFL; + smoothFL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + + iirSampleFR = (iirSampleFR * (1.0 - BEQ)) + (basscatchR * BEQ); + basscatchR = iirSampleFR*bassdrive; + bridgerectifier = fabs(basscatchR); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchR > 0.0) basscatchR = bridgerectifier; + else basscatchR = -bridgerectifier; + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothFR + (secondFR*inverse) + (thirdFR*bridgerectifier) + inputSampleR); + thirdFR = secondFR; + secondFR = smoothFR; + smoothFR = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + + outSample = (inputSampleL * fixE[fix_a0]) + fixE[fix_sL1]; + fixE[fix_sL1] = (inputSampleL * fixE[fix_a1]) - (outSample * fixE[fix_b1]) + fixE[fix_sL2]; + fixE[fix_sL2] = (inputSampleL * fixE[fix_a2]) - (outSample * fixE[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixE[fix_a0]) + fixE[fix_sR1]; + fixE[fix_sR1] = (inputSampleR * fixE[fix_a1]) - (outSample * fixE[fix_b1]) + fixE[fix_sR2]; + fixE[fix_sR2] = (inputSampleR * fixE[fix_a2]) - (outSample * fixE[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + iirSampleGL = (iirSampleGL * (1.0 - BEQ)) + (basscatchL * BEQ); + basscatchL = iirSampleGL*bassdrive; + bridgerectifier = fabs(basscatchL); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchL > 0.0) basscatchL = bridgerectifier; + else basscatchL = -bridgerectifier; + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothGL + (secondGL*inverse) + (thirdGL*bridgerectifier) + inputSampleL); + thirdGL = secondGL; + secondGL = smoothGL; + smoothGL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + + iirSampleGR = (iirSampleGR * (1.0 - BEQ)) + (basscatchR * BEQ); + basscatchR = iirSampleGR*bassdrive; + bridgerectifier = fabs(basscatchR); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchR > 0.0) basscatchR = bridgerectifier; + else basscatchR = -bridgerectifier; + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothGR + (secondGR*inverse) + (thirdGR*bridgerectifier) + inputSampleR); + thirdGR = secondGR; + secondGR = smoothGR; + smoothGR = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + + iirSampleHL = (iirSampleHL * (1.0 - BEQ)) + (basscatchL * BEQ); + basscatchL = iirSampleHL*bassdrive; + bridgerectifier = fabs(basscatchL); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchL > 0.0) basscatchL = bridgerectifier; + else basscatchL = -bridgerectifier; + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothHL + (secondHL*inverse) + (thirdHL*bridgerectifier) + inputSampleL); + thirdHL = secondHL; + secondHL = smoothHL; + smoothHL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + + iirSampleHR = (iirSampleHR * (1.0 - BEQ)) + (basscatchR * BEQ); + basscatchR = iirSampleHR*bassdrive; + bridgerectifier = fabs(basscatchR); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchR > 0.0) basscatchR = bridgerectifier; + else basscatchR = -bridgerectifier; + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothHR + (secondHR*inverse) + (thirdHR*bridgerectifier) + inputSampleR); + thirdHR = secondHR; + secondHR = smoothHR; + smoothHR = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + + outSample = (inputSampleL * fixF[fix_a0]) + fixF[fix_sL1]; + fixF[fix_sL1] = (inputSampleL * fixF[fix_a1]) - (outSample * fixF[fix_b1]) + fixF[fix_sL2]; + fixF[fix_sL2] = (inputSampleL * fixF[fix_a2]) - (outSample * fixF[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixF[fix_a0]) + fixF[fix_sR1]; + fixF[fix_sR1] = (inputSampleR * fixF[fix_a1]) - (outSample * fixF[fix_b1]) + fixF[fix_sR2]; + fixF[fix_sR2] = (inputSampleR * fixF[fix_a2]) - (outSample * fixF[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + iirSampleIL = (iirSampleIL * (1.0 - BEQ)) + (basscatchL * BEQ); + basscatchL = iirSampleIL*bassdrive; + bridgerectifier = fabs(basscatchL); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchL > 0.0) basscatchL = bridgerectifier; + else basscatchL = -bridgerectifier; + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothIL + (secondIL*inverse) + (thirdIL*bridgerectifier) + inputSampleL); + thirdIL = secondIL; + secondIL = smoothIL; + smoothIL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + bridgerectifier = fabs(inputSampleL); + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothJL + (secondJL*inverse) + (thirdJL*bridgerectifier) + inputSampleL); + thirdJL = secondJL; + secondJL = smoothJL; + smoothJL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + bridgerectifier = fabs(inputSampleL); + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothKL + (secondKL*inverse) + (thirdKL*bridgerectifier) + inputSampleL); + thirdKL = secondKL; + secondKL = smoothKL; + smoothKL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + + iirSampleIR = (iirSampleIR * (1.0 - BEQ)) + (basscatchR * BEQ); + basscatchR = iirSampleIR*bassdrive; + bridgerectifier = fabs(basscatchR); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchR > 0.0) basscatchR = bridgerectifier; + else basscatchR = -bridgerectifier; + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothIR + (secondIR*inverse) + (thirdIR*bridgerectifier) + inputSampleR); + thirdIR = secondIR; + secondIR = smoothIR; + smoothIR = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + bridgerectifier = fabs(inputSampleR); + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothJR + (secondJR*inverse) + (thirdJR*bridgerectifier) + inputSampleR); + thirdJR = secondJR; + secondJR = smoothJR; + smoothJR = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + bridgerectifier = fabs(inputSampleR); + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothKR + (secondKR*inverse) + (thirdKR*bridgerectifier) + inputSampleR); + thirdKR = secondKR; + secondKR = smoothKR; + smoothKR = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + + basscatchL /= 2.0; + inputSampleL = (inputSampleL*toneEQ)+basscatchL; + //extra lowpass for 4*12" speakers + basscatchR /= 2.0; + inputSampleR = (inputSampleR*toneEQ)+basscatchR; + //extra lowpass for 4*12" speakers + + bridgerectifier = fabs(inputSampleL*outputlevel); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (inputSampleL > 0.0) inputSampleL = bridgerectifier; + else inputSampleL = -bridgerectifier; + inputSampleL += basscatchL; + //split bass between overdrive and clean + inputSampleL /= (1.0+toneEQ); + + bridgerectifier = fabs(inputSampleR*outputlevel); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (inputSampleR > 0.0) inputSampleR = bridgerectifier; + else inputSampleR = -bridgerectifier; + inputSampleR += basscatchR; + //split bass between overdrive and clean + inputSampleR /= (1.0+toneEQ); + + double randy = ((double(fpdL)/UINT32_MAX)*0.061); + inputSampleL = ((inputSampleL*(1-randy))+(storeSampleL*randy))*outputlevel; + storeSampleL = inputSampleL; + + randy = ((double(fpdR)/UINT32_MAX)*0.061); + inputSampleR = ((inputSampleR*(1-randy))+(storeSampleR*randy))*outputlevel; + storeSampleR = inputSampleR; + + if (wet !=1.0) { + inputSampleL = (inputSampleL * wet) + (drySampleL * (1.0-wet)); + inputSampleR = (inputSampleR * wet) + (drySampleR * (1.0-wet)); + } + //Dry/Wet control, defaults to the last slider + //amp + + cycle++; + if (cycle == cycleEnd) { + + double temp = (inputSampleL + smoothCabAL)/3.0; + smoothCabAL = inputSampleL; + inputSampleL = temp; + + bL[83] = bL[82]; bL[82] = bL[81]; bL[81] = bL[80]; bL[80] = bL[79]; + bL[79] = bL[78]; bL[78] = bL[77]; bL[77] = bL[76]; bL[76] = bL[75]; bL[75] = bL[74]; bL[74] = bL[73]; bL[73] = bL[72]; bL[72] = bL[71]; + bL[71] = bL[70]; bL[70] = bL[69]; bL[69] = bL[68]; bL[68] = bL[67]; bL[67] = bL[66]; bL[66] = bL[65]; bL[65] = bL[64]; bL[64] = bL[63]; + bL[63] = bL[62]; bL[62] = bL[61]; bL[61] = bL[60]; bL[60] = bL[59]; bL[59] = bL[58]; bL[58] = bL[57]; bL[57] = bL[56]; bL[56] = bL[55]; + bL[55] = bL[54]; bL[54] = bL[53]; bL[53] = bL[52]; bL[52] = bL[51]; bL[51] = bL[50]; bL[50] = bL[49]; bL[49] = bL[48]; bL[48] = bL[47]; + bL[47] = bL[46]; bL[46] = bL[45]; bL[45] = bL[44]; bL[44] = bL[43]; bL[43] = bL[42]; bL[42] = bL[41]; bL[41] = bL[40]; bL[40] = bL[39]; + bL[39] = bL[38]; bL[38] = bL[37]; bL[37] = bL[36]; bL[36] = bL[35]; bL[35] = bL[34]; bL[34] = bL[33]; bL[33] = bL[32]; bL[32] = bL[31]; + bL[31] = bL[30]; bL[30] = bL[29]; bL[29] = bL[28]; bL[28] = bL[27]; bL[27] = bL[26]; bL[26] = bL[25]; bL[25] = bL[24]; bL[24] = bL[23]; + bL[23] = bL[22]; bL[22] = bL[21]; bL[21] = bL[20]; bL[20] = bL[19]; bL[19] = bL[18]; bL[18] = bL[17]; bL[17] = bL[16]; bL[16] = bL[15]; + bL[15] = bL[14]; bL[14] = bL[13]; bL[13] = bL[12]; bL[12] = bL[11]; bL[11] = bL[10]; bL[10] = bL[9]; bL[9] = bL[8]; bL[8] = bL[7]; + bL[7] = bL[6]; bL[6] = bL[5]; bL[5] = bL[4]; bL[4] = bL[3]; bL[3] = bL[2]; bL[2] = bL[1]; bL[1] = bL[0]; bL[0] = inputSampleL; + inputSampleL += (bL[1] * (1.29550481610475132 + (0.19713872057074355*fabs(bL[1])))); + inputSampleL += (bL[2] * (1.42302569895462616 + (0.30599505521284787*fabs(bL[2])))); + inputSampleL += (bL[3] * (1.28728195804197565 + (0.23168333460446133*fabs(bL[3])))); + inputSampleL += (bL[4] * (0.88553784290822690 + (0.14263256172918892*fabs(bL[4])))); + inputSampleL += (bL[5] * (0.37129054918432319 + (0.00150040944205920*fabs(bL[5])))); + inputSampleL -= (bL[6] * (0.12150959412556320 + (0.32776273620569107*fabs(bL[6])))); + inputSampleL -= (bL[7] * (0.44900065463203775 + (0.74101214925298819*fabs(bL[7])))); + inputSampleL -= (bL[8] * (0.54058781908186482 + (1.07821707459008387*fabs(bL[8])))); + inputSampleL -= (bL[9] * (0.49361966401791391 + (1.23540109014850508*fabs(bL[9])))); + inputSampleL -= (bL[10] * (0.39819495093078133 + (1.11247213730917749*fabs(bL[10])))); + inputSampleL -= (bL[11] * (0.31379279985435521 + (0.80330360359638298*fabs(bL[11])))); + inputSampleL -= (bL[12] * (0.30744359242808555 + (0.42132528876858205*fabs(bL[12])))); + inputSampleL -= (bL[13] * (0.33943170284673974 + (0.09183418349389982*fabs(bL[13])))); + inputSampleL -= (bL[14] * (0.33838775119286391 - (0.06453051658561271*fabs(bL[14])))); + inputSampleL -= (bL[15] * (0.30682305697961665 - (0.09549380253249232*fabs(bL[15])))); + inputSampleL -= (bL[16] * (0.23408741339295336 - (0.08083404732361277*fabs(bL[16])))); + inputSampleL -= (bL[17] * (0.10411746814025019 + (0.00253651281245780*fabs(bL[17])))); + inputSampleL += (bL[18] * (0.00133623776084696 - (0.04447267870865820*fabs(bL[18])))); + inputSampleL += (bL[19] * (0.02461903992114161 + (0.07530671732655550*fabs(bL[19])))); + inputSampleL += (bL[20] * (0.02086715842475373 + (0.22795860236804899*fabs(bL[20])))); + inputSampleL += (bL[21] * (0.02761433637100917 + (0.26108320417844094*fabs(bL[21])))); + inputSampleL += (bL[22] * (0.04475285369162533 + (0.19160705011061663*fabs(bL[22])))); + inputSampleL += (bL[23] * (0.09447338372862381 + (0.03681550508743799*fabs(bL[23])))); + inputSampleL += (bL[24] * (0.13445890343722280 - (0.13713036462146147*fabs(bL[24])))); + inputSampleL += (bL[25] * (0.13872868945088121 - (0.22401242373298191*fabs(bL[25])))); + inputSampleL += (bL[26] * (0.14915650097434549 - (0.26718804981526367*fabs(bL[26])))); + inputSampleL += (bL[27] * (0.12766643217091783 - (0.27745664795660430*fabs(bL[27])))); + inputSampleL += (bL[28] * (0.03675849788393101 - (0.18338278173550679*fabs(bL[28])))); + inputSampleL -= (bL[29] * (0.06307306864232835 + (0.06089480869040766*fabs(bL[29])))); + inputSampleL -= (bL[30] * (0.14947389348962944 + (0.04642103054798480*fabs(bL[30])))); + inputSampleL -= (bL[31] * (0.25235266566401526 + (0.08423062596460507*fabs(bL[31])))); + inputSampleL -= (bL[32] * (0.33496344048679683 + (0.09808328256677995*fabs(bL[32])))); + inputSampleL -= (bL[33] * (0.36590030482175445 + (0.10622650888958179*fabs(bL[33])))); + inputSampleL -= (bL[34] * (0.35015197011464372 + (0.08982043516016047*fabs(bL[34])))); + inputSampleL -= (bL[35] * (0.26808437585665090 + (0.00735561860229533*fabs(bL[35])))); + inputSampleL -= (bL[36] * (0.11624318543291220 - (0.07142484314510467*fabs(bL[36])))); + inputSampleL += (bL[37] * (0.05617084165377551 + (0.11785854050350089*fabs(bL[37])))); + inputSampleL += (bL[38] * (0.20540028692589385 + (0.20479174663329586*fabs(bL[38])))); + inputSampleL += (bL[39] * (0.30455415003043818 + (0.29074864580096849*fabs(bL[39])))); + inputSampleL += (bL[40] * (0.33810750937829476 + (0.29182307921316802*fabs(bL[40])))); + inputSampleL += (bL[41] * (0.31936133365277430 + (0.26535537727394987*fabs(bL[41])))); + inputSampleL += (bL[42] * (0.27388548321981876 + (0.19735049990538350*fabs(bL[42])))); + inputSampleL += (bL[43] * (0.21454597517994098 + (0.06415909270247236*fabs(bL[43])))); + inputSampleL += (bL[44] * (0.15001045817707717 - (0.03831118543404573*fabs(bL[44])))); + inputSampleL += (bL[45] * (0.07283437284653138 - (0.09281952429543777*fabs(bL[45])))); + inputSampleL -= (bL[46] * (0.03917872184241358 + (0.14306291461398810*fabs(bL[46])))); + inputSampleL -= (bL[47] * (0.16695932032148642 + (0.19138995946950504*fabs(bL[47])))); + inputSampleL -= (bL[48] * (0.27055854466909462 + (0.22531296466343192*fabs(bL[48])))); + inputSampleL -= (bL[49] * (0.33256357307578271 + (0.23305840475692102*fabs(bL[49])))); + inputSampleL -= (bL[50] * (0.33459770116834442 + (0.24091822618917569*fabs(bL[50])))); + inputSampleL -= (bL[51] * (0.27156687236338090 + (0.24062938573512443*fabs(bL[51])))); + inputSampleL -= (bL[52] * (0.17197093288412094 + (0.19083085091993421*fabs(bL[52])))); + inputSampleL -= (bL[53] * (0.06738628195910543 + (0.10268609751019808*fabs(bL[53])))); + inputSampleL += (bL[54] * (0.00222429218204290 + (0.01439664435720548*fabs(bL[54])))); + inputSampleL += (bL[55] * (0.01346992803494091 + (0.15947137113534526*fabs(bL[55])))); + inputSampleL -= (bL[56] * (0.02038911881377448 - (0.26763170752416160*fabs(bL[56])))); + inputSampleL -= (bL[57] * (0.08233579178189687 - (0.29415931086406055*fabs(bL[57])))); + inputSampleL -= (bL[58] * (0.15447855089824883 - (0.26489186990840807*fabs(bL[58])))); + inputSampleL -= (bL[59] * (0.20518281113362655 - (0.16135382257522859*fabs(bL[59])))); + inputSampleL -= (bL[60] * (0.22244686050232007 + (0.00847180390247432*fabs(bL[60])))); + inputSampleL -= (bL[61] * (0.21849243134998034 + (0.14460595245753741*fabs(bL[61])))); + inputSampleL -= (bL[62] * (0.20256105734574054 + (0.18932793221831667*fabs(bL[62])))); + inputSampleL -= (bL[63] * (0.18604070054295399 + (0.17250665610927965*fabs(bL[63])))); + inputSampleL -= (bL[64] * (0.17222844322058231 + (0.12992472027850357*fabs(bL[64])))); + inputSampleL -= (bL[65] * (0.14447856616566443 + (0.09089219002147308*fabs(bL[65])))); + inputSampleL -= (bL[66] * (0.10385520794251019 + (0.08600465834570559*fabs(bL[66])))); + inputSampleL -= (bL[67] * (0.07124435678265063 + (0.09071532210549428*fabs(bL[67])))); + inputSampleL -= (bL[68] * (0.05216857461197572 + (0.06794061706070262*fabs(bL[68])))); + inputSampleL -= (bL[69] * (0.05235381920184123 + (0.02818101717909346*fabs(bL[69])))); + inputSampleL -= (bL[70] * (0.07569701245553526 - (0.00634228544764946*fabs(bL[70])))); + inputSampleL -= (bL[71] * (0.10320125382718826 - (0.02751486906644141*fabs(bL[71])))); + inputSampleL -= (bL[72] * (0.12122120969079088 - (0.05434007312178933*fabs(bL[72])))); + inputSampleL -= (bL[73] * (0.13438969117200902 - (0.09135218559713874*fabs(bL[73])))); + inputSampleL -= (bL[74] * (0.13534390437529981 - (0.10437672041458675*fabs(bL[74])))); + inputSampleL -= (bL[75] * (0.11424128854188388 - (0.08693450726462598*fabs(bL[75])))); + inputSampleL -= (bL[76] * (0.08166894518596159 - (0.06949989431475120*fabs(bL[76])))); + inputSampleL -= (bL[77] * (0.04293976378555305 - (0.05718625137421843*fabs(bL[77])))); + inputSampleL += (bL[78] * (0.00933076320644409 + (0.01728285211520138*fabs(bL[78])))); + inputSampleL += (bL[79] * (0.06450430362918153 - (0.02492994833691022*fabs(bL[79])))); + inputSampleL += (bL[80] * (0.10187400687649277 - (0.03578455940532403*fabs(bL[80])))); + inputSampleL += (bL[81] * (0.11039763294094571 - (0.03995523517573508*fabs(bL[81])))); + inputSampleL += (bL[82] * (0.08557960776024547 - (0.03482514309492527*fabs(bL[82])))); + inputSampleL += (bL[83] * (0.02730881850805332 - (0.00514750108411127*fabs(bL[83])))); + + temp = (inputSampleL + smoothCabBL)/3.0; + smoothCabBL = inputSampleL; + inputSampleL = temp/4.0; + + randy = ((double(fpdL)/UINT32_MAX)*0.044); + drySampleL = ((((inputSampleL*(1-randy))+(lastCabSampleL*randy))*wet)+(drySampleL*(1.0-wet)))*outputlevel; + lastCabSampleL = inputSampleL; + inputSampleL = drySampleL; //cab L + + temp = (inputSampleR + smoothCabAR)/3.0; + smoothCabAR = inputSampleR; + inputSampleR = temp; + + bR[83] = bR[82]; bR[82] = bR[81]; bR[81] = bR[80]; bR[80] = bR[79]; + bR[79] = bR[78]; bR[78] = bR[77]; bR[77] = bR[76]; bR[76] = bR[75]; bR[75] = bR[74]; bR[74] = bR[73]; bR[73] = bR[72]; bR[72] = bR[71]; + bR[71] = bR[70]; bR[70] = bR[69]; bR[69] = bR[68]; bR[68] = bR[67]; bR[67] = bR[66]; bR[66] = bR[65]; bR[65] = bR[64]; bR[64] = bR[63]; + bR[63] = bR[62]; bR[62] = bR[61]; bR[61] = bR[60]; bR[60] = bR[59]; bR[59] = bR[58]; bR[58] = bR[57]; bR[57] = bR[56]; bR[56] = bR[55]; + bR[55] = bR[54]; bR[54] = bR[53]; bR[53] = bR[52]; bR[52] = bR[51]; bR[51] = bR[50]; bR[50] = bR[49]; bR[49] = bR[48]; bR[48] = bR[47]; + bR[47] = bR[46]; bR[46] = bR[45]; bR[45] = bR[44]; bR[44] = bR[43]; bR[43] = bR[42]; bR[42] = bR[41]; bR[41] = bR[40]; bR[40] = bR[39]; + bR[39] = bR[38]; bR[38] = bR[37]; bR[37] = bR[36]; bR[36] = bR[35]; bR[35] = bR[34]; bR[34] = bR[33]; bR[33] = bR[32]; bR[32] = bR[31]; + bR[31] = bR[30]; bR[30] = bR[29]; bR[29] = bR[28]; bR[28] = bR[27]; bR[27] = bR[26]; bR[26] = bR[25]; bR[25] = bR[24]; bR[24] = bR[23]; + bR[23] = bR[22]; bR[22] = bR[21]; bR[21] = bR[20]; bR[20] = bR[19]; bR[19] = bR[18]; bR[18] = bR[17]; bR[17] = bR[16]; bR[16] = bR[15]; + bR[15] = bR[14]; bR[14] = bR[13]; bR[13] = bR[12]; bR[12] = bR[11]; bR[11] = bR[10]; bR[10] = bR[9]; bR[9] = bR[8]; bR[8] = bR[7]; + bR[7] = bR[6]; bR[6] = bR[5]; bR[5] = bR[4]; bR[4] = bR[3]; bR[3] = bR[2]; bR[2] = bR[1]; bR[1] = bR[0]; bR[0] = inputSampleR; + inputSampleR += (bR[1] * (1.29550481610475132 + (0.19713872057074355*fabs(bR[1])))); + inputSampleR += (bR[2] * (1.42302569895462616 + (0.30599505521284787*fabs(bR[2])))); + inputSampleR += (bR[3] * (1.28728195804197565 + (0.23168333460446133*fabs(bR[3])))); + inputSampleR += (bR[4] * (0.88553784290822690 + (0.14263256172918892*fabs(bR[4])))); + inputSampleR += (bR[5] * (0.37129054918432319 + (0.00150040944205920*fabs(bR[5])))); + inputSampleR -= (bR[6] * (0.12150959412556320 + (0.32776273620569107*fabs(bR[6])))); + inputSampleR -= (bR[7] * (0.44900065463203775 + (0.74101214925298819*fabs(bR[7])))); + inputSampleR -= (bR[8] * (0.54058781908186482 + (1.07821707459008387*fabs(bR[8])))); + inputSampleR -= (bR[9] * (0.49361966401791391 + (1.23540109014850508*fabs(bR[9])))); + inputSampleR -= (bR[10] * (0.39819495093078133 + (1.11247213730917749*fabs(bR[10])))); + inputSampleR -= (bR[11] * (0.31379279985435521 + (0.80330360359638298*fabs(bR[11])))); + inputSampleR -= (bR[12] * (0.30744359242808555 + (0.42132528876858205*fabs(bR[12])))); + inputSampleR -= (bR[13] * (0.33943170284673974 + (0.09183418349389982*fabs(bR[13])))); + inputSampleR -= (bR[14] * (0.33838775119286391 - (0.06453051658561271*fabs(bR[14])))); + inputSampleR -= (bR[15] * (0.30682305697961665 - (0.09549380253249232*fabs(bR[15])))); + inputSampleR -= (bR[16] * (0.23408741339295336 - (0.08083404732361277*fabs(bR[16])))); + inputSampleR -= (bR[17] * (0.10411746814025019 + (0.00253651281245780*fabs(bR[17])))); + inputSampleR += (bR[18] * (0.00133623776084696 - (0.04447267870865820*fabs(bR[18])))); + inputSampleR += (bR[19] * (0.02461903992114161 + (0.07530671732655550*fabs(bR[19])))); + inputSampleR += (bR[20] * (0.02086715842475373 + (0.22795860236804899*fabs(bR[20])))); + inputSampleR += (bR[21] * (0.02761433637100917 + (0.26108320417844094*fabs(bR[21])))); + inputSampleR += (bR[22] * (0.04475285369162533 + (0.19160705011061663*fabs(bR[22])))); + inputSampleR += (bR[23] * (0.09447338372862381 + (0.03681550508743799*fabs(bR[23])))); + inputSampleR += (bR[24] * (0.13445890343722280 - (0.13713036462146147*fabs(bR[24])))); + inputSampleR += (bR[25] * (0.13872868945088121 - (0.22401242373298191*fabs(bR[25])))); + inputSampleR += (bR[26] * (0.14915650097434549 - (0.26718804981526367*fabs(bR[26])))); + inputSampleR += (bR[27] * (0.12766643217091783 - (0.27745664795660430*fabs(bR[27])))); + inputSampleR += (bR[28] * (0.03675849788393101 - (0.18338278173550679*fabs(bR[28])))); + inputSampleR -= (bR[29] * (0.06307306864232835 + (0.06089480869040766*fabs(bR[29])))); + inputSampleR -= (bR[30] * (0.14947389348962944 + (0.04642103054798480*fabs(bR[30])))); + inputSampleR -= (bR[31] * (0.25235266566401526 + (0.08423062596460507*fabs(bR[31])))); + inputSampleR -= (bR[32] * (0.33496344048679683 + (0.09808328256677995*fabs(bR[32])))); + inputSampleR -= (bR[33] * (0.36590030482175445 + (0.10622650888958179*fabs(bR[33])))); + inputSampleR -= (bR[34] * (0.35015197011464372 + (0.08982043516016047*fabs(bR[34])))); + inputSampleR -= (bR[35] * (0.26808437585665090 + (0.00735561860229533*fabs(bR[35])))); + inputSampleR -= (bR[36] * (0.11624318543291220 - (0.07142484314510467*fabs(bR[36])))); + inputSampleR += (bR[37] * (0.05617084165377551 + (0.11785854050350089*fabs(bR[37])))); + inputSampleR += (bR[38] * (0.20540028692589385 + (0.20479174663329586*fabs(bR[38])))); + inputSampleR += (bR[39] * (0.30455415003043818 + (0.29074864580096849*fabs(bR[39])))); + inputSampleR += (bR[40] * (0.33810750937829476 + (0.29182307921316802*fabs(bR[40])))); + inputSampleR += (bR[41] * (0.31936133365277430 + (0.26535537727394987*fabs(bR[41])))); + inputSampleR += (bR[42] * (0.27388548321981876 + (0.19735049990538350*fabs(bR[42])))); + inputSampleR += (bR[43] * (0.21454597517994098 + (0.06415909270247236*fabs(bR[43])))); + inputSampleR += (bR[44] * (0.15001045817707717 - (0.03831118543404573*fabs(bR[44])))); + inputSampleR += (bR[45] * (0.07283437284653138 - (0.09281952429543777*fabs(bR[45])))); + inputSampleR -= (bR[46] * (0.03917872184241358 + (0.14306291461398810*fabs(bR[46])))); + inputSampleR -= (bR[47] * (0.16695932032148642 + (0.19138995946950504*fabs(bR[47])))); + inputSampleR -= (bR[48] * (0.27055854466909462 + (0.22531296466343192*fabs(bR[48])))); + inputSampleR -= (bR[49] * (0.33256357307578271 + (0.23305840475692102*fabs(bR[49])))); + inputSampleR -= (bR[50] * (0.33459770116834442 + (0.24091822618917569*fabs(bR[50])))); + inputSampleR -= (bR[51] * (0.27156687236338090 + (0.24062938573512443*fabs(bR[51])))); + inputSampleR -= (bR[52] * (0.17197093288412094 + (0.19083085091993421*fabs(bR[52])))); + inputSampleR -= (bR[53] * (0.06738628195910543 + (0.10268609751019808*fabs(bR[53])))); + inputSampleR += (bR[54] * (0.00222429218204290 + (0.01439664435720548*fabs(bR[54])))); + inputSampleR += (bR[55] * (0.01346992803494091 + (0.15947137113534526*fabs(bR[55])))); + inputSampleR -= (bR[56] * (0.02038911881377448 - (0.26763170752416160*fabs(bR[56])))); + inputSampleR -= (bR[57] * (0.08233579178189687 - (0.29415931086406055*fabs(bR[57])))); + inputSampleR -= (bR[58] * (0.15447855089824883 - (0.26489186990840807*fabs(bR[58])))); + inputSampleR -= (bR[59] * (0.20518281113362655 - (0.16135382257522859*fabs(bR[59])))); + inputSampleR -= (bR[60] * (0.22244686050232007 + (0.00847180390247432*fabs(bR[60])))); + inputSampleR -= (bR[61] * (0.21849243134998034 + (0.14460595245753741*fabs(bR[61])))); + inputSampleR -= (bR[62] * (0.20256105734574054 + (0.18932793221831667*fabs(bR[62])))); + inputSampleR -= (bR[63] * (0.18604070054295399 + (0.17250665610927965*fabs(bR[63])))); + inputSampleR -= (bR[64] * (0.17222844322058231 + (0.12992472027850357*fabs(bR[64])))); + inputSampleR -= (bR[65] * (0.14447856616566443 + (0.09089219002147308*fabs(bR[65])))); + inputSampleR -= (bR[66] * (0.10385520794251019 + (0.08600465834570559*fabs(bR[66])))); + inputSampleR -= (bR[67] * (0.07124435678265063 + (0.09071532210549428*fabs(bR[67])))); + inputSampleR -= (bR[68] * (0.05216857461197572 + (0.06794061706070262*fabs(bR[68])))); + inputSampleR -= (bR[69] * (0.05235381920184123 + (0.02818101717909346*fabs(bR[69])))); + inputSampleR -= (bR[70] * (0.07569701245553526 - (0.00634228544764946*fabs(bR[70])))); + inputSampleR -= (bR[71] * (0.10320125382718826 - (0.02751486906644141*fabs(bR[71])))); + inputSampleR -= (bR[72] * (0.12122120969079088 - (0.05434007312178933*fabs(bR[72])))); + inputSampleR -= (bR[73] * (0.13438969117200902 - (0.09135218559713874*fabs(bR[73])))); + inputSampleR -= (bR[74] * (0.13534390437529981 - (0.10437672041458675*fabs(bR[74])))); + inputSampleR -= (bR[75] * (0.11424128854188388 - (0.08693450726462598*fabs(bR[75])))); + inputSampleR -= (bR[76] * (0.08166894518596159 - (0.06949989431475120*fabs(bR[76])))); + inputSampleR -= (bR[77] * (0.04293976378555305 - (0.05718625137421843*fabs(bR[77])))); + inputSampleR += (bR[78] * (0.00933076320644409 + (0.01728285211520138*fabs(bR[78])))); + inputSampleR += (bR[79] * (0.06450430362918153 - (0.02492994833691022*fabs(bR[79])))); + inputSampleR += (bR[80] * (0.10187400687649277 - (0.03578455940532403*fabs(bR[80])))); + inputSampleR += (bR[81] * (0.11039763294094571 - (0.03995523517573508*fabs(bR[81])))); + inputSampleR += (bR[82] * (0.08557960776024547 - (0.03482514309492527*fabs(bR[82])))); + inputSampleR += (bR[83] * (0.02730881850805332 - (0.00514750108411127*fabs(bR[83])))); + + temp = (inputSampleR + smoothCabBR)/3.0; + smoothCabBR = inputSampleR; + inputSampleR = temp/4.0; + + randy = ((double(fpdR)/UINT32_MAX)*0.04); + drySampleR = ((((inputSampleR*(1-randy))+(lastCabSampleR*randy))*wet)+(drySampleR*(1.0-wet)))*outputlevel; + lastCabSampleR = inputSampleR; + inputSampleR = drySampleR; //cab + + if (cycleEnd == 4) { + lastRefL[0] = lastRefL[4]; //start from previous last + lastRefL[2] = (lastRefL[0] + inputSampleL)/2; //half + lastRefL[1] = (lastRefL[0] + lastRefL[2])/2; //one quarter + lastRefL[3] = (lastRefL[2] + inputSampleL)/2; //three quarters + lastRefL[4] = inputSampleL; //full + lastRefR[0] = lastRefR[4]; //start from previous last + lastRefR[2] = (lastRefR[0] + inputSampleR)/2; //half + lastRefR[1] = (lastRefR[0] + lastRefR[2])/2; //one quarter + lastRefR[3] = (lastRefR[2] + inputSampleR)/2; //three quarters + lastRefR[4] = inputSampleR; //full + } + if (cycleEnd == 3) { + lastRefL[0] = lastRefL[3]; //start from previous last + lastRefL[2] = (lastRefL[0]+lastRefL[0]+inputSampleL)/3; //third + lastRefL[1] = (lastRefL[0]+inputSampleL+inputSampleL)/3; //two thirds + lastRefL[3] = inputSampleL; //full + lastRefR[0] = lastRefR[3]; //start from previous last + lastRefR[2] = (lastRefR[0]+lastRefR[0]+inputSampleR)/3; //third + lastRefR[1] = (lastRefR[0]+inputSampleR+inputSampleR)/3; //two thirds + lastRefR[3] = inputSampleR; //full + } + if (cycleEnd == 2) { + lastRefL[0] = lastRefL[2]; //start from previous last + lastRefL[1] = (lastRefL[0] + inputSampleL)/2; //half + lastRefL[2] = inputSampleL; //full + lastRefR[0] = lastRefR[2]; //start from previous last + lastRefR[1] = (lastRefR[0] + inputSampleR)/2; //half + lastRefR[2] = inputSampleR; //full + } + if (cycleEnd == 1) { + lastRefL[0] = inputSampleL; + lastRefR[0] = inputSampleR; + } + cycle = 0; //reset + inputSampleL = lastRefL[cycle]; + inputSampleR = lastRefR[cycle]; + } else { + inputSampleL = lastRefL[cycle]; + inputSampleR = lastRefR[cycle]; + //we are going through our references now + } + switch (cycleEnd) //multi-pole average using lastRef[] variables + { + case 4: + lastRefL[8] = inputSampleL; inputSampleL = (inputSampleL+lastRefL[7])*0.5; + lastRefL[7] = lastRefL[8]; //continue, do not break + lastRefR[8] = inputSampleR; inputSampleR = (inputSampleR+lastRefR[7])*0.5; + lastRefR[7] = lastRefR[8]; //continue, do not break + case 3: + lastRefL[8] = inputSampleL; inputSampleL = (inputSampleL+lastRefL[6])*0.5; + lastRefL[6] = lastRefL[8]; //continue, do not break + lastRefR[8] = inputSampleR; inputSampleR = (inputSampleR+lastRefR[6])*0.5; + lastRefR[6] = lastRefR[8]; //continue, do not break + case 2: + lastRefL[8] = inputSampleL; inputSampleL = (inputSampleL+lastRefL[5])*0.5; + lastRefL[5] = lastRefL[8]; //continue, do not break + lastRefR[8] = inputSampleR; inputSampleR = (inputSampleR+lastRefR[5])*0.5; + lastRefR[5] = lastRefR[8]; //continue, do not break + case 1: + break; //no further averaging + } + + //begin 32 bit stereo floating point dither + int expon; frexpf((float)inputSampleL, &expon); + fpdL ^= fpdL << 13; fpdL ^= fpdL >> 17; fpdL ^= fpdL << 5; + inputSampleL += ((double(fpdL)-uint32_t(0x7fffffff)) * 5.5e-36l * pow(2,expon+62)); + frexpf((float)inputSampleR, &expon); + fpdR ^= fpdR << 13; fpdR ^= fpdR >> 17; fpdR ^= fpdR << 5; + inputSampleR += ((double(fpdR)-uint32_t(0x7fffffff)) * 5.5e-36l * pow(2,expon+62)); + //end 32 bit stereo floating point dither + + *out1 = inputSampleL; + *out2 = inputSampleR; + + in1++; + in2++; + out1++; + out2++; + } +} + +void GrindAmp::processDoubleReplacing(double **inputs, double **outputs, VstInt32 sampleFrames) +{ + double* in1 = inputs[0]; + double* in2 = inputs[1]; + double* out1 = outputs[0]; + double* out2 = outputs[1]; + + double overallscale = 1.0; + overallscale /= 44100.0; + overallscale *= getSampleRate(); + int cycleEnd = floor(overallscale); + if (cycleEnd < 1) cycleEnd = 1; + if (cycleEnd > 4) cycleEnd = 4; + //this is going to be 2 for 88.1 or 96k, 3 for silly people, 4 for 176 or 192k + if (cycle > cycleEnd-1) cycle = cycleEnd-1; //sanity check + + double inputlevel = pow(A,2); + double samplerate = getSampleRate(); + double trimEQ = 1.1-B; + double toneEQ = trimEQ/1.2; + trimEQ /= 50.0; + trimEQ += 0.165; + double EQ = ((trimEQ-(toneEQ/6.1)) / samplerate)*22050.0; + double BEQ = ((trimEQ+(toneEQ/2.1)) / samplerate)*22050.0; + double outputlevel = C; + double wet = D; + double bassdrive = 1.57079633*(2.5-toneEQ); + + double cutoff = (18000.0+(B*1000.0)) / getSampleRate(); + if (cutoff > 0.49) cutoff = 0.49; //don't crash if run at 44.1k + if (cutoff < 0.001) cutoff = 0.001; //or if cutoff's too low + + fixF[fix_freq] = fixE[fix_freq] = fixD[fix_freq] = fixC[fix_freq] = fixB[fix_freq] = fixA[fix_freq] = cutoff; + + fixA[fix_reso] = 4.46570214; + fixB[fix_reso] = 1.51387132; + fixC[fix_reso] = 0.93979296; + fixD[fix_reso] = 0.70710678; + fixE[fix_reso] = 0.52972649; + fixF[fix_reso] = 0.50316379; + + double K = tan(M_PI * fixA[fix_freq]); //lowpass + double norm = 1.0 / (1.0 + K / fixA[fix_reso] + K * K); + fixA[fix_a0] = K * K * norm; + fixA[fix_a1] = 2.0 * fixA[fix_a0]; + fixA[fix_a2] = fixA[fix_a0]; + fixA[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixA[fix_b2] = (1.0 - K / fixA[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixB[fix_freq]); + norm = 1.0 / (1.0 + K / fixB[fix_reso] + K * K); + fixB[fix_a0] = K * K * norm; + fixB[fix_a1] = 2.0 * fixB[fix_a0]; + fixB[fix_a2] = fixB[fix_a0]; + fixB[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixB[fix_b2] = (1.0 - K / fixB[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixC[fix_freq]); + norm = 1.0 / (1.0 + K / fixC[fix_reso] + K * K); + fixC[fix_a0] = K * K * norm; + fixC[fix_a1] = 2.0 * fixC[fix_a0]; + fixC[fix_a2] = fixC[fix_a0]; + fixC[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixC[fix_b2] = (1.0 - K / fixC[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixD[fix_freq]); + norm = 1.0 / (1.0 + K / fixD[fix_reso] + K * K); + fixD[fix_a0] = K * K * norm; + fixD[fix_a1] = 2.0 * fixD[fix_a0]; + fixD[fix_a2] = fixD[fix_a0]; + fixD[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixD[fix_b2] = (1.0 - K / fixD[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixE[fix_freq]); + norm = 1.0 / (1.0 + K / fixE[fix_reso] + K * K); + fixE[fix_a0] = K * K * norm; + fixE[fix_a1] = 2.0 * fixE[fix_a0]; + fixE[fix_a2] = fixE[fix_a0]; + fixE[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixE[fix_b2] = (1.0 - K / fixE[fix_reso] + K * K) * norm; + + K = tan(M_PI * fixF[fix_freq]); + norm = 1.0 / (1.0 + K / fixF[fix_reso] + K * K); + fixF[fix_a0] = K * K * norm; + fixF[fix_a1] = 2.0 * fixF[fix_a0]; + fixF[fix_a2] = fixF[fix_a0]; + fixF[fix_b1] = 2.0 * (K * K - 1.0) * norm; + fixF[fix_b2] = (1.0 - K / fixF[fix_reso] + K * K) * norm; + + while (--sampleFrames >= 0) + { + double inputSampleL = *in1; + double inputSampleR = *in2; + if (fabs(inputSampleL)<1.18e-23) inputSampleL = fpdL * 1.18e-17; + if (fabs(inputSampleR)<1.18e-23) inputSampleR = fpdR * 1.18e-17; + double drySampleL = inputSampleL; + double drySampleR = inputSampleR; + + double outSample = (inputSampleL * fixA[fix_a0]) + fixA[fix_sL1]; + fixA[fix_sL1] = (inputSampleL * fixA[fix_a1]) - (outSample * fixA[fix_b1]) + fixA[fix_sL2]; + fixA[fix_sL2] = (inputSampleL * fixA[fix_a2]) - (outSample * fixA[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixA[fix_a0]) + fixA[fix_sR1]; + fixA[fix_sR1] = (inputSampleR * fixA[fix_a1]) - (outSample * fixA[fix_b1]) + fixA[fix_sR2]; + fixA[fix_sR2] = (inputSampleR * fixA[fix_a2]) - (outSample * fixA[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + inputSampleL *= inputlevel; + iirSampleAL = (iirSampleAL * (1.0 - EQ)) + (inputSampleL * EQ); + inputSampleL = inputSampleL - (iirSampleAL*0.92); + //highpass + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; + double bridgerectifier = fabs(inputSampleL); + double inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothAL + (secondAL*inverse) + (thirdAL*bridgerectifier) + inputSampleL); + thirdAL = secondAL; + secondAL = smoothAL; + smoothAL = inputSampleL; + double basscatchL = inputSampleL = bridgerectifier; + //three-sample averaging lowpass + + inputSampleR *= inputlevel; + iirSampleAR = (iirSampleAR * (1.0 - EQ)) + (inputSampleR * EQ); + inputSampleR = inputSampleR - (iirSampleAR*0.92); + //highpass + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; + bridgerectifier = fabs(inputSampleR); + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothAR + (secondAR*inverse) + (thirdAR*bridgerectifier) + inputSampleR); + thirdAR = secondAR; + secondAR = smoothAR; + smoothAR = inputSampleR; + double basscatchR = inputSampleR = bridgerectifier; + //three-sample averaging lowpass + + outSample = (inputSampleL * fixB[fix_a0]) + fixB[fix_sL1]; + fixB[fix_sL1] = (inputSampleL * fixB[fix_a1]) - (outSample * fixB[fix_b1]) + fixB[fix_sL2]; + fixB[fix_sL2] = (inputSampleL * fixB[fix_a2]) - (outSample * fixB[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixB[fix_a0]) + fixB[fix_sR1]; + fixB[fix_sR1] = (inputSampleR * fixB[fix_a1]) - (outSample * fixB[fix_b1]) + fixB[fix_sR2]; + fixB[fix_sR2] = (inputSampleR * fixB[fix_a2]) - (outSample * fixB[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + inputSampleL *= inputlevel; + iirSampleBL = (iirSampleBL * (1.0 - EQ)) + (inputSampleL * EQ); + inputSampleL = inputSampleL - (iirSampleBL*0.79); + //highpass + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; + //overdrive + bridgerectifier = fabs(inputSampleL); + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothBL + (secondBL*inverse) + (thirdBL*bridgerectifier) + inputSampleL); + thirdBL = secondBL; + secondBL = smoothBL; + smoothBL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + + inputSampleR *= inputlevel; + iirSampleBR = (iirSampleBR * (1.0 - EQ)) + (inputSampleR * EQ); + inputSampleR = inputSampleR - (iirSampleBR*0.79); + //highpass + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; + //overdrive + bridgerectifier = fabs(inputSampleR); + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothBR + (secondBR*inverse) + (thirdBR*bridgerectifier) + inputSampleR); + thirdBR = secondBR; + secondBR = smoothBR; + smoothBR = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + + iirSampleCL = (iirSampleCL * (1.0 - BEQ)) + (basscatchL * BEQ); + basscatchL = iirSampleCL*bassdrive; + bridgerectifier = fabs(basscatchL); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchL > 0.0) basscatchL = bridgerectifier; + else basscatchL = -bridgerectifier; + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothCL + (secondCL*inverse) + (thirdCL*bridgerectifier) + inputSampleL); + thirdCL = secondCL; + secondCL = smoothCL; + smoothCL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + + iirSampleCR = (iirSampleCR * (1.0 - BEQ)) + (basscatchR * BEQ); + basscatchR = iirSampleCR*bassdrive; + bridgerectifier = fabs(basscatchR); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchR > 0.0) basscatchR = bridgerectifier; + else basscatchR = -bridgerectifier; + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothCR + (secondCR*inverse) + (thirdCR*bridgerectifier) + inputSampleR); + thirdCR = secondCR; + secondCR = smoothCR; + smoothCR = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + + outSample = (inputSampleL * fixC[fix_a0]) + fixC[fix_sL1]; + fixC[fix_sL1] = (inputSampleL * fixC[fix_a1]) - (outSample * fixC[fix_b1]) + fixC[fix_sL2]; + fixC[fix_sL2] = (inputSampleL * fixC[fix_a2]) - (outSample * fixC[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixC[fix_a0]) + fixC[fix_sR1]; + fixC[fix_sR1] = (inputSampleR * fixC[fix_a1]) - (outSample * fixC[fix_b1]) + fixC[fix_sR2]; + fixC[fix_sR2] = (inputSampleR * fixC[fix_a2]) - (outSample * fixC[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + iirSampleDL = (iirSampleDL * (1.0 - BEQ)) + (basscatchL * BEQ); + basscatchL = iirSampleDL*bassdrive; + bridgerectifier = fabs(basscatchL); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchL > 0.0) basscatchL = bridgerectifier; + else basscatchL = -bridgerectifier; + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothDL + (secondDL*inverse) + (thirdDL*bridgerectifier) + inputSampleL); + thirdDL = secondDL; + secondDL = smoothDL; + smoothDL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + + iirSampleDR = (iirSampleDR * (1.0 - BEQ)) + (basscatchR * BEQ); + basscatchR = iirSampleDR*bassdrive; + bridgerectifier = fabs(basscatchR); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchR > 0.0) basscatchR = bridgerectifier; + else basscatchR = -bridgerectifier; + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothDR + (secondDR*inverse) + (thirdDR*bridgerectifier) + inputSampleR); + thirdDR = secondDR; + secondDR = smoothDR; + smoothDR = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + + outSample = (inputSampleL * fixD[fix_a0]) + fixD[fix_sL1]; + fixD[fix_sL1] = (inputSampleL * fixD[fix_a1]) - (outSample * fixD[fix_b1]) + fixD[fix_sL2]; + fixD[fix_sL2] = (inputSampleL * fixD[fix_a2]) - (outSample * fixD[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixD[fix_a0]) + fixD[fix_sR1]; + fixD[fix_sR1] = (inputSampleR * fixD[fix_a1]) - (outSample * fixD[fix_b1]) + fixD[fix_sR2]; + fixD[fix_sR2] = (inputSampleR * fixD[fix_a2]) - (outSample * fixD[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + iirSampleEL = (iirSampleEL * (1.0 - BEQ)) + (basscatchL * BEQ); + basscatchL = iirSampleEL*bassdrive; + bridgerectifier = fabs(basscatchL); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchL > 0.0) basscatchL = bridgerectifier; + else basscatchL = -bridgerectifier; + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothEL + (secondEL*inverse) + (thirdEL*bridgerectifier) + inputSampleL); + thirdEL = secondEL; + secondEL = smoothEL; + smoothEL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + + iirSampleER = (iirSampleER * (1.0 - BEQ)) + (basscatchR * BEQ); + basscatchR = iirSampleER*bassdrive; + bridgerectifier = fabs(basscatchR); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchR > 0.0) basscatchR = bridgerectifier; + else basscatchR = -bridgerectifier; + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothER + (secondER*inverse) + (thirdER*bridgerectifier) + inputSampleR); + thirdER = secondER; + secondER = smoothER; + smoothER = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + + iirSampleFL = (iirSampleFL * (1.0 - BEQ)) + (basscatchL * BEQ); + basscatchL = iirSampleFL*bassdrive; + bridgerectifier = fabs(basscatchL); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchL > 0.0) basscatchL = bridgerectifier; + else basscatchL = -bridgerectifier; + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothFL + (secondFL*inverse) + (thirdFL*bridgerectifier) + inputSampleL); + thirdFL = secondFL; + secondFL = smoothFL; + smoothFL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + + iirSampleFR = (iirSampleFR * (1.0 - BEQ)) + (basscatchR * BEQ); + basscatchR = iirSampleFR*bassdrive; + bridgerectifier = fabs(basscatchR); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchR > 0.0) basscatchR = bridgerectifier; + else basscatchR = -bridgerectifier; + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothFR + (secondFR*inverse) + (thirdFR*bridgerectifier) + inputSampleR); + thirdFR = secondFR; + secondFR = smoothFR; + smoothFR = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + + outSample = (inputSampleL * fixE[fix_a0]) + fixE[fix_sL1]; + fixE[fix_sL1] = (inputSampleL * fixE[fix_a1]) - (outSample * fixE[fix_b1]) + fixE[fix_sL2]; + fixE[fix_sL2] = (inputSampleL * fixE[fix_a2]) - (outSample * fixE[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixE[fix_a0]) + fixE[fix_sR1]; + fixE[fix_sR1] = (inputSampleR * fixE[fix_a1]) - (outSample * fixE[fix_b1]) + fixE[fix_sR2]; + fixE[fix_sR2] = (inputSampleR * fixE[fix_a2]) - (outSample * fixE[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + iirSampleGL = (iirSampleGL * (1.0 - BEQ)) + (basscatchL * BEQ); + basscatchL = iirSampleGL*bassdrive; + bridgerectifier = fabs(basscatchL); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchL > 0.0) basscatchL = bridgerectifier; + else basscatchL = -bridgerectifier; + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothGL + (secondGL*inverse) + (thirdGL*bridgerectifier) + inputSampleL); + thirdGL = secondGL; + secondGL = smoothGL; + smoothGL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + + iirSampleGR = (iirSampleGR * (1.0 - BEQ)) + (basscatchR * BEQ); + basscatchR = iirSampleGR*bassdrive; + bridgerectifier = fabs(basscatchR); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchR > 0.0) basscatchR = bridgerectifier; + else basscatchR = -bridgerectifier; + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothGR + (secondGR*inverse) + (thirdGR*bridgerectifier) + inputSampleR); + thirdGR = secondGR; + secondGR = smoothGR; + smoothGR = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + + iirSampleHL = (iirSampleHL * (1.0 - BEQ)) + (basscatchL * BEQ); + basscatchL = iirSampleHL*bassdrive; + bridgerectifier = fabs(basscatchL); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchL > 0.0) basscatchL = bridgerectifier; + else basscatchL = -bridgerectifier; + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothHL + (secondHL*inverse) + (thirdHL*bridgerectifier) + inputSampleL); + thirdHL = secondHL; + secondHL = smoothHL; + smoothHL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + + iirSampleHR = (iirSampleHR * (1.0 - BEQ)) + (basscatchR * BEQ); + basscatchR = iirSampleHR*bassdrive; + bridgerectifier = fabs(basscatchR); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchR > 0.0) basscatchR = bridgerectifier; + else basscatchR = -bridgerectifier; + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothHR + (secondHR*inverse) + (thirdHR*bridgerectifier) + inputSampleR); + thirdHR = secondHR; + secondHR = smoothHR; + smoothHR = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + + outSample = (inputSampleL * fixF[fix_a0]) + fixF[fix_sL1]; + fixF[fix_sL1] = (inputSampleL * fixF[fix_a1]) - (outSample * fixF[fix_b1]) + fixF[fix_sL2]; + fixF[fix_sL2] = (inputSampleL * fixF[fix_a2]) - (outSample * fixF[fix_b2]); + inputSampleL = outSample; //fixed biquad filtering ultrasonics + outSample = (inputSampleR * fixF[fix_a0]) + fixF[fix_sR1]; + fixF[fix_sR1] = (inputSampleR * fixF[fix_a1]) - (outSample * fixF[fix_b1]) + fixF[fix_sR2]; + fixF[fix_sR2] = (inputSampleR * fixF[fix_a2]) - (outSample * fixF[fix_b2]); + inputSampleR = outSample; //fixed biquad filtering ultrasonics + + iirSampleIL = (iirSampleIL * (1.0 - BEQ)) + (basscatchL * BEQ); + basscatchL = iirSampleIL*bassdrive; + bridgerectifier = fabs(basscatchL); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchL > 0.0) basscatchL = bridgerectifier; + else basscatchL = -bridgerectifier; + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothIL + (secondIL*inverse) + (thirdIL*bridgerectifier) + inputSampleL); + thirdIL = secondIL; + secondIL = smoothIL; + smoothIL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + bridgerectifier = fabs(inputSampleL); + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothJL + (secondJL*inverse) + (thirdJL*bridgerectifier) + inputSampleL); + thirdJL = secondJL; + secondJL = smoothJL; + smoothJL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + bridgerectifier = fabs(inputSampleL); + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothKL + (secondKL*inverse) + (thirdKL*bridgerectifier) + inputSampleL); + thirdKL = secondKL; + secondKL = smoothKL; + smoothKL = inputSampleL; + inputSampleL = bridgerectifier; + //three-sample averaging lowpass + + iirSampleIR = (iirSampleIR * (1.0 - BEQ)) + (basscatchR * BEQ); + basscatchR = iirSampleIR*bassdrive; + bridgerectifier = fabs(basscatchR); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (basscatchR > 0.0) basscatchR = bridgerectifier; + else basscatchR = -bridgerectifier; + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; + //overdrive + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothIR + (secondIR*inverse) + (thirdIR*bridgerectifier) + inputSampleR); + thirdIR = secondIR; + secondIR = smoothIR; + smoothIR = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + bridgerectifier = fabs(inputSampleR); + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothJR + (secondJR*inverse) + (thirdJR*bridgerectifier) + inputSampleR); + thirdJR = secondJR; + secondJR = smoothJR; + smoothJR = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + bridgerectifier = fabs(inputSampleR); + inverse = (bridgerectifier+1.0)/2.0; + bridgerectifier = (smoothKR + (secondKR*inverse) + (thirdKR*bridgerectifier) + inputSampleR); + thirdKR = secondKR; + secondKR = smoothKR; + smoothKR = inputSampleR; + inputSampleR = bridgerectifier; + //three-sample averaging lowpass + + basscatchL /= 2.0; + inputSampleL = (inputSampleL*toneEQ)+basscatchL; + //extra lowpass for 4*12" speakers + basscatchR /= 2.0; + inputSampleR = (inputSampleR*toneEQ)+basscatchR; + //extra lowpass for 4*12" speakers + + bridgerectifier = fabs(inputSampleL*outputlevel); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (inputSampleL > 0.0) inputSampleL = bridgerectifier; + else inputSampleL = -bridgerectifier; + inputSampleL += basscatchL; + //split bass between overdrive and clean + inputSampleL /= (1.0+toneEQ); + + bridgerectifier = fabs(inputSampleR*outputlevel); + if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633; + bridgerectifier = sin(bridgerectifier); + if (inputSampleR > 0.0) inputSampleR = bridgerectifier; + else inputSampleR = -bridgerectifier; + inputSampleR += basscatchR; + //split bass between overdrive and clean + inputSampleR /= (1.0+toneEQ); + + double randy = ((double(fpdL)/UINT32_MAX)*0.061); + inputSampleL = ((inputSampleL*(1-randy))+(storeSampleL*randy))*outputlevel; + storeSampleL = inputSampleL; + + randy = ((double(fpdR)/UINT32_MAX)*0.061); + inputSampleR = ((inputSampleR*(1-randy))+(storeSampleR*randy))*outputlevel; + storeSampleR = inputSampleR; + + if (wet !=1.0) { + inputSampleL = (inputSampleL * wet) + (drySampleL * (1.0-wet)); + inputSampleR = (inputSampleR * wet) + (drySampleR * (1.0-wet)); + } + //Dry/Wet control, defaults to the last slider + //amp + + cycle++; + if (cycle == cycleEnd) { + + double temp = (inputSampleL + smoothCabAL)/3.0; + smoothCabAL = inputSampleL; + inputSampleL = temp; + + bL[83] = bL[82]; bL[82] = bL[81]; bL[81] = bL[80]; bL[80] = bL[79]; + bL[79] = bL[78]; bL[78] = bL[77]; bL[77] = bL[76]; bL[76] = bL[75]; bL[75] = bL[74]; bL[74] = bL[73]; bL[73] = bL[72]; bL[72] = bL[71]; + bL[71] = bL[70]; bL[70] = bL[69]; bL[69] = bL[68]; bL[68] = bL[67]; bL[67] = bL[66]; bL[66] = bL[65]; bL[65] = bL[64]; bL[64] = bL[63]; + bL[63] = bL[62]; bL[62] = bL[61]; bL[61] = bL[60]; bL[60] = bL[59]; bL[59] = bL[58]; bL[58] = bL[57]; bL[57] = bL[56]; bL[56] = bL[55]; + bL[55] = bL[54]; bL[54] = bL[53]; bL[53] = bL[52]; bL[52] = bL[51]; bL[51] = bL[50]; bL[50] = bL[49]; bL[49] = bL[48]; bL[48] = bL[47]; + bL[47] = bL[46]; bL[46] = bL[45]; bL[45] = bL[44]; bL[44] = bL[43]; bL[43] = bL[42]; bL[42] = bL[41]; bL[41] = bL[40]; bL[40] = bL[39]; + bL[39] = bL[38]; bL[38] = bL[37]; bL[37] = bL[36]; bL[36] = bL[35]; bL[35] = bL[34]; bL[34] = bL[33]; bL[33] = bL[32]; bL[32] = bL[31]; + bL[31] = bL[30]; bL[30] = bL[29]; bL[29] = bL[28]; bL[28] = bL[27]; bL[27] = bL[26]; bL[26] = bL[25]; bL[25] = bL[24]; bL[24] = bL[23]; + bL[23] = bL[22]; bL[22] = bL[21]; bL[21] = bL[20]; bL[20] = bL[19]; bL[19] = bL[18]; bL[18] = bL[17]; bL[17] = bL[16]; bL[16] = bL[15]; + bL[15] = bL[14]; bL[14] = bL[13]; bL[13] = bL[12]; bL[12] = bL[11]; bL[11] = bL[10]; bL[10] = bL[9]; bL[9] = bL[8]; bL[8] = bL[7]; + bL[7] = bL[6]; bL[6] = bL[5]; bL[5] = bL[4]; bL[4] = bL[3]; bL[3] = bL[2]; bL[2] = bL[1]; bL[1] = bL[0]; bL[0] = inputSampleL; + inputSampleL += (bL[1] * (1.29550481610475132 + (0.19713872057074355*fabs(bL[1])))); + inputSampleL += (bL[2] * (1.42302569895462616 + (0.30599505521284787*fabs(bL[2])))); + inputSampleL += (bL[3] * (1.28728195804197565 + (0.23168333460446133*fabs(bL[3])))); + inputSampleL += (bL[4] * (0.88553784290822690 + (0.14263256172918892*fabs(bL[4])))); + inputSampleL += (bL[5] * (0.37129054918432319 + (0.00150040944205920*fabs(bL[5])))); + inputSampleL -= (bL[6] * (0.12150959412556320 + (0.32776273620569107*fabs(bL[6])))); + inputSampleL -= (bL[7] * (0.44900065463203775 + (0.74101214925298819*fabs(bL[7])))); + inputSampleL -= (bL[8] * (0.54058781908186482 + (1.07821707459008387*fabs(bL[8])))); + inputSampleL -= (bL[9] * (0.49361966401791391 + (1.23540109014850508*fabs(bL[9])))); + inputSampleL -= (bL[10] * (0.39819495093078133 + (1.11247213730917749*fabs(bL[10])))); + inputSampleL -= (bL[11] * (0.31379279985435521 + (0.80330360359638298*fabs(bL[11])))); + inputSampleL -= (bL[12] * (0.30744359242808555 + (0.42132528876858205*fabs(bL[12])))); + inputSampleL -= (bL[13] * (0.33943170284673974 + (0.09183418349389982*fabs(bL[13])))); + inputSampleL -= (bL[14] * (0.33838775119286391 - (0.06453051658561271*fabs(bL[14])))); + inputSampleL -= (bL[15] * (0.30682305697961665 - (0.09549380253249232*fabs(bL[15])))); + inputSampleL -= (bL[16] * (0.23408741339295336 - (0.08083404732361277*fabs(bL[16])))); + inputSampleL -= (bL[17] * (0.10411746814025019 + (0.00253651281245780*fabs(bL[17])))); + inputSampleL += (bL[18] * (0.00133623776084696 - (0.04447267870865820*fabs(bL[18])))); + inputSampleL += (bL[19] * (0.02461903992114161 + (0.07530671732655550*fabs(bL[19])))); + inputSampleL += (bL[20] * (0.02086715842475373 + (0.22795860236804899*fabs(bL[20])))); + inputSampleL += (bL[21] * (0.02761433637100917 + (0.26108320417844094*fabs(bL[21])))); + inputSampleL += (bL[22] * (0.04475285369162533 + (0.19160705011061663*fabs(bL[22])))); + inputSampleL += (bL[23] * (0.09447338372862381 + (0.03681550508743799*fabs(bL[23])))); + inputSampleL += (bL[24] * (0.13445890343722280 - (0.13713036462146147*fabs(bL[24])))); + inputSampleL += (bL[25] * (0.13872868945088121 - (0.22401242373298191*fabs(bL[25])))); + inputSampleL += (bL[26] * (0.14915650097434549 - (0.26718804981526367*fabs(bL[26])))); + inputSampleL += (bL[27] * (0.12766643217091783 - (0.27745664795660430*fabs(bL[27])))); + inputSampleL += (bL[28] * (0.03675849788393101 - (0.18338278173550679*fabs(bL[28])))); + inputSampleL -= (bL[29] * (0.06307306864232835 + (0.06089480869040766*fabs(bL[29])))); + inputSampleL -= (bL[30] * (0.14947389348962944 + (0.04642103054798480*fabs(bL[30])))); + inputSampleL -= (bL[31] * (0.25235266566401526 + (0.08423062596460507*fabs(bL[31])))); + inputSampleL -= (bL[32] * (0.33496344048679683 + (0.09808328256677995*fabs(bL[32])))); + inputSampleL -= (bL[33] * (0.36590030482175445 + (0.10622650888958179*fabs(bL[33])))); + inputSampleL -= (bL[34] * (0.35015197011464372 + (0.08982043516016047*fabs(bL[34])))); + inputSampleL -= (bL[35] * (0.26808437585665090 + (0.00735561860229533*fabs(bL[35])))); + inputSampleL -= (bL[36] * (0.11624318543291220 - (0.07142484314510467*fabs(bL[36])))); + inputSampleL += (bL[37] * (0.05617084165377551 + (0.11785854050350089*fabs(bL[37])))); + inputSampleL += (bL[38] * (0.20540028692589385 + (0.20479174663329586*fabs(bL[38])))); + inputSampleL += (bL[39] * (0.30455415003043818 + (0.29074864580096849*fabs(bL[39])))); + inputSampleL += (bL[40] * (0.33810750937829476 + (0.29182307921316802*fabs(bL[40])))); + inputSampleL += (bL[41] * (0.31936133365277430 + (0.26535537727394987*fabs(bL[41])))); + inputSampleL += (bL[42] * (0.27388548321981876 + (0.19735049990538350*fabs(bL[42])))); + inputSampleL += (bL[43] * (0.21454597517994098 + (0.06415909270247236*fabs(bL[43])))); + inputSampleL += (bL[44] * (0.15001045817707717 - (0.03831118543404573*fabs(bL[44])))); + inputSampleL += (bL[45] * (0.07283437284653138 - (0.09281952429543777*fabs(bL[45])))); + inputSampleL -= (bL[46] * (0.03917872184241358 + (0.14306291461398810*fabs(bL[46])))); + inputSampleL -= (bL[47] * (0.16695932032148642 + (0.19138995946950504*fabs(bL[47])))); + inputSampleL -= (bL[48] * (0.27055854466909462 + (0.22531296466343192*fabs(bL[48])))); + inputSampleL -= (bL[49] * (0.33256357307578271 + (0.23305840475692102*fabs(bL[49])))); + inputSampleL -= (bL[50] * (0.33459770116834442 + (0.24091822618917569*fabs(bL[50])))); + inputSampleL -= (bL[51] * (0.27156687236338090 + (0.24062938573512443*fabs(bL[51])))); + inputSampleL -= (bL[52] * (0.17197093288412094 + (0.19083085091993421*fabs(bL[52])))); + inputSampleL -= (bL[53] * (0.06738628195910543 + (0.10268609751019808*fabs(bL[53])))); + inputSampleL += (bL[54] * (0.00222429218204290 + (0.01439664435720548*fabs(bL[54])))); + inputSampleL += (bL[55] * (0.01346992803494091 + (0.15947137113534526*fabs(bL[55])))); + inputSampleL -= (bL[56] * (0.02038911881377448 - (0.26763170752416160*fabs(bL[56])))); + inputSampleL -= (bL[57] * (0.08233579178189687 - (0.29415931086406055*fabs(bL[57])))); + inputSampleL -= (bL[58] * (0.15447855089824883 - (0.26489186990840807*fabs(bL[58])))); + inputSampleL -= (bL[59] * (0.20518281113362655 - (0.16135382257522859*fabs(bL[59])))); + inputSampleL -= (bL[60] * (0.22244686050232007 + (0.00847180390247432*fabs(bL[60])))); + inputSampleL -= (bL[61] * (0.21849243134998034 + (0.14460595245753741*fabs(bL[61])))); + inputSampleL -= (bL[62] * (0.20256105734574054 + (0.18932793221831667*fabs(bL[62])))); + inputSampleL -= (bL[63] * (0.18604070054295399 + (0.17250665610927965*fabs(bL[63])))); + inputSampleL -= (bL[64] * (0.17222844322058231 + (0.12992472027850357*fabs(bL[64])))); + inputSampleL -= (bL[65] * (0.14447856616566443 + (0.09089219002147308*fabs(bL[65])))); + inputSampleL -= (bL[66] * (0.10385520794251019 + (0.08600465834570559*fabs(bL[66])))); + inputSampleL -= (bL[67] * (0.07124435678265063 + (0.09071532210549428*fabs(bL[67])))); + inputSampleL -= (bL[68] * (0.05216857461197572 + (0.06794061706070262*fabs(bL[68])))); + inputSampleL -= (bL[69] * (0.05235381920184123 + (0.02818101717909346*fabs(bL[69])))); + inputSampleL -= (bL[70] * (0.07569701245553526 - (0.00634228544764946*fabs(bL[70])))); + inputSampleL -= (bL[71] * (0.10320125382718826 - (0.02751486906644141*fabs(bL[71])))); + inputSampleL -= (bL[72] * (0.12122120969079088 - (0.05434007312178933*fabs(bL[72])))); + inputSampleL -= (bL[73] * (0.13438969117200902 - (0.09135218559713874*fabs(bL[73])))); + inputSampleL -= (bL[74] * (0.13534390437529981 - (0.10437672041458675*fabs(bL[74])))); + inputSampleL -= (bL[75] * (0.11424128854188388 - (0.08693450726462598*fabs(bL[75])))); + inputSampleL -= (bL[76] * (0.08166894518596159 - (0.06949989431475120*fabs(bL[76])))); + inputSampleL -= (bL[77] * (0.04293976378555305 - (0.05718625137421843*fabs(bL[77])))); + inputSampleL += (bL[78] * (0.00933076320644409 + (0.01728285211520138*fabs(bL[78])))); + inputSampleL += (bL[79] * (0.06450430362918153 - (0.02492994833691022*fabs(bL[79])))); + inputSampleL += (bL[80] * (0.10187400687649277 - (0.03578455940532403*fabs(bL[80])))); + inputSampleL += (bL[81] * (0.11039763294094571 - (0.03995523517573508*fabs(bL[81])))); + inputSampleL += (bL[82] * (0.08557960776024547 - (0.03482514309492527*fabs(bL[82])))); + inputSampleL += (bL[83] * (0.02730881850805332 - (0.00514750108411127*fabs(bL[83])))); + + temp = (inputSampleL + smoothCabBL)/3.0; + smoothCabBL = inputSampleL; + inputSampleL = temp/4.0; + + randy = ((double(fpdL)/UINT32_MAX)*0.044); + drySampleL = ((((inputSampleL*(1-randy))+(lastCabSampleL*randy))*wet)+(drySampleL*(1.0-wet)))*outputlevel; + lastCabSampleL = inputSampleL; + inputSampleL = drySampleL; //cab L + + temp = (inputSampleR + smoothCabAR)/3.0; + smoothCabAR = inputSampleR; + inputSampleR = temp; + + bR[83] = bR[82]; bR[82] = bR[81]; bR[81] = bR[80]; bR[80] = bR[79]; + bR[79] = bR[78]; bR[78] = bR[77]; bR[77] = bR[76]; bR[76] = bR[75]; bR[75] = bR[74]; bR[74] = bR[73]; bR[73] = bR[72]; bR[72] = bR[71]; + bR[71] = bR[70]; bR[70] = bR[69]; bR[69] = bR[68]; bR[68] = bR[67]; bR[67] = bR[66]; bR[66] = bR[65]; bR[65] = bR[64]; bR[64] = bR[63]; + bR[63] = bR[62]; bR[62] = bR[61]; bR[61] = bR[60]; bR[60] = bR[59]; bR[59] = bR[58]; bR[58] = bR[57]; bR[57] = bR[56]; bR[56] = bR[55]; + bR[55] = bR[54]; bR[54] = bR[53]; bR[53] = bR[52]; bR[52] = bR[51]; bR[51] = bR[50]; bR[50] = bR[49]; bR[49] = bR[48]; bR[48] = bR[47]; + bR[47] = bR[46]; bR[46] = bR[45]; bR[45] = bR[44]; bR[44] = bR[43]; bR[43] = bR[42]; bR[42] = bR[41]; bR[41] = bR[40]; bR[40] = bR[39]; + bR[39] = bR[38]; bR[38] = bR[37]; bR[37] = bR[36]; bR[36] = bR[35]; bR[35] = bR[34]; bR[34] = bR[33]; bR[33] = bR[32]; bR[32] = bR[31]; + bR[31] = bR[30]; bR[30] = bR[29]; bR[29] = bR[28]; bR[28] = bR[27]; bR[27] = bR[26]; bR[26] = bR[25]; bR[25] = bR[24]; bR[24] = bR[23]; + bR[23] = bR[22]; bR[22] = bR[21]; bR[21] = bR[20]; bR[20] = bR[19]; bR[19] = bR[18]; bR[18] = bR[17]; bR[17] = bR[16]; bR[16] = bR[15]; + bR[15] = bR[14]; bR[14] = bR[13]; bR[13] = bR[12]; bR[12] = bR[11]; bR[11] = bR[10]; bR[10] = bR[9]; bR[9] = bR[8]; bR[8] = bR[7]; + bR[7] = bR[6]; bR[6] = bR[5]; bR[5] = bR[4]; bR[4] = bR[3]; bR[3] = bR[2]; bR[2] = bR[1]; bR[1] = bR[0]; bR[0] = inputSampleR; + inputSampleR += (bR[1] * (1.29550481610475132 + (0.19713872057074355*fabs(bR[1])))); + inputSampleR += (bR[2] * (1.42302569895462616 + (0.30599505521284787*fabs(bR[2])))); + inputSampleR += (bR[3] * (1.28728195804197565 + (0.23168333460446133*fabs(bR[3])))); + inputSampleR += (bR[4] * (0.88553784290822690 + (0.14263256172918892*fabs(bR[4])))); + inputSampleR += (bR[5] * (0.37129054918432319 + (0.00150040944205920*fabs(bR[5])))); + inputSampleR -= (bR[6] * (0.12150959412556320 + (0.32776273620569107*fabs(bR[6])))); + inputSampleR -= (bR[7] * (0.44900065463203775 + (0.74101214925298819*fabs(bR[7])))); + inputSampleR -= (bR[8] * (0.54058781908186482 + (1.07821707459008387*fabs(bR[8])))); + inputSampleR -= (bR[9] * (0.49361966401791391 + (1.23540109014850508*fabs(bR[9])))); + inputSampleR -= (bR[10] * (0.39819495093078133 + (1.11247213730917749*fabs(bR[10])))); + inputSampleR -= (bR[11] * (0.31379279985435521 + (0.80330360359638298*fabs(bR[11])))); + inputSampleR -= (bR[12] * (0.30744359242808555 + (0.42132528876858205*fabs(bR[12])))); + inputSampleR -= (bR[13] * (0.33943170284673974 + (0.09183418349389982*fabs(bR[13])))); + inputSampleR -= (bR[14] * (0.33838775119286391 - (0.06453051658561271*fabs(bR[14])))); + inputSampleR -= (bR[15] * (0.30682305697961665 - (0.09549380253249232*fabs(bR[15])))); + inputSampleR -= (bR[16] * (0.23408741339295336 - (0.08083404732361277*fabs(bR[16])))); + inputSampleR -= (bR[17] * (0.10411746814025019 + (0.00253651281245780*fabs(bR[17])))); + inputSampleR += (bR[18] * (0.00133623776084696 - (0.04447267870865820*fabs(bR[18])))); + inputSampleR += (bR[19] * (0.02461903992114161 + (0.07530671732655550*fabs(bR[19])))); + inputSampleR += (bR[20] * (0.02086715842475373 + (0.22795860236804899*fabs(bR[20])))); + inputSampleR += (bR[21] * (0.02761433637100917 + (0.26108320417844094*fabs(bR[21])))); + inputSampleR += (bR[22] * (0.04475285369162533 + (0.19160705011061663*fabs(bR[22])))); + inputSampleR += (bR[23] * (0.09447338372862381 + (0.03681550508743799*fabs(bR[23])))); + inputSampleR += (bR[24] * (0.13445890343722280 - (0.13713036462146147*fabs(bR[24])))); + inputSampleR += (bR[25] * (0.13872868945088121 - (0.22401242373298191*fabs(bR[25])))); + inputSampleR += (bR[26] * (0.14915650097434549 - (0.26718804981526367*fabs(bR[26])))); + inputSampleR += (bR[27] * (0.12766643217091783 - (0.27745664795660430*fabs(bR[27])))); + inputSampleR += (bR[28] * (0.03675849788393101 - (0.18338278173550679*fabs(bR[28])))); + inputSampleR -= (bR[29] * (0.06307306864232835 + (0.06089480869040766*fabs(bR[29])))); + inputSampleR -= (bR[30] * (0.14947389348962944 + (0.04642103054798480*fabs(bR[30])))); + inputSampleR -= (bR[31] * (0.25235266566401526 + (0.08423062596460507*fabs(bR[31])))); + inputSampleR -= (bR[32] * (0.33496344048679683 + (0.09808328256677995*fabs(bR[32])))); + inputSampleR -= (bR[33] * (0.36590030482175445 + (0.10622650888958179*fabs(bR[33])))); + inputSampleR -= (bR[34] * (0.35015197011464372 + (0.08982043516016047*fabs(bR[34])))); + inputSampleR -= (bR[35] * (0.26808437585665090 + (0.00735561860229533*fabs(bR[35])))); + inputSampleR -= (bR[36] * (0.11624318543291220 - (0.07142484314510467*fabs(bR[36])))); + inputSampleR += (bR[37] * (0.05617084165377551 + (0.11785854050350089*fabs(bR[37])))); + inputSampleR += (bR[38] * (0.20540028692589385 + (0.20479174663329586*fabs(bR[38])))); + inputSampleR += (bR[39] * (0.30455415003043818 + (0.29074864580096849*fabs(bR[39])))); + inputSampleR += (bR[40] * (0.33810750937829476 + (0.29182307921316802*fabs(bR[40])))); + inputSampleR += (bR[41] * (0.31936133365277430 + (0.26535537727394987*fabs(bR[41])))); + inputSampleR += (bR[42] * (0.27388548321981876 + (0.19735049990538350*fabs(bR[42])))); + inputSampleR += (bR[43] * (0.21454597517994098 + (0.06415909270247236*fabs(bR[43])))); + inputSampleR += (bR[44] * (0.15001045817707717 - (0.03831118543404573*fabs(bR[44])))); + inputSampleR += (bR[45] * (0.07283437284653138 - (0.09281952429543777*fabs(bR[45])))); + inputSampleR -= (bR[46] * (0.03917872184241358 + (0.14306291461398810*fabs(bR[46])))); + inputSampleR -= (bR[47] * (0.16695932032148642 + (0.19138995946950504*fabs(bR[47])))); + inputSampleR -= (bR[48] * (0.27055854466909462 + (0.22531296466343192*fabs(bR[48])))); + inputSampleR -= (bR[49] * (0.33256357307578271 + (0.23305840475692102*fabs(bR[49])))); + inputSampleR -= (bR[50] * (0.33459770116834442 + (0.24091822618917569*fabs(bR[50])))); + inputSampleR -= (bR[51] * (0.27156687236338090 + (0.24062938573512443*fabs(bR[51])))); + inputSampleR -= (bR[52] * (0.17197093288412094 + (0.19083085091993421*fabs(bR[52])))); + inputSampleR -= (bR[53] * (0.06738628195910543 + (0.10268609751019808*fabs(bR[53])))); + inputSampleR += (bR[54] * (0.00222429218204290 + (0.01439664435720548*fabs(bR[54])))); + inputSampleR += (bR[55] * (0.01346992803494091 + (0.15947137113534526*fabs(bR[55])))); + inputSampleR -= (bR[56] * (0.02038911881377448 - (0.26763170752416160*fabs(bR[56])))); + inputSampleR -= (bR[57] * (0.08233579178189687 - (0.29415931086406055*fabs(bR[57])))); + inputSampleR -= (bR[58] * (0.15447855089824883 - (0.26489186990840807*fabs(bR[58])))); + inputSampleR -= (bR[59] * (0.20518281113362655 - (0.16135382257522859*fabs(bR[59])))); + inputSampleR -= (bR[60] * (0.22244686050232007 + (0.00847180390247432*fabs(bR[60])))); + inputSampleR -= (bR[61] * (0.21849243134998034 + (0.14460595245753741*fabs(bR[61])))); + inputSampleR -= (bR[62] * (0.20256105734574054 + (0.18932793221831667*fabs(bR[62])))); + inputSampleR -= (bR[63] * (0.18604070054295399 + (0.17250665610927965*fabs(bR[63])))); + inputSampleR -= (bR[64] * (0.17222844322058231 + (0.12992472027850357*fabs(bR[64])))); + inputSampleR -= (bR[65] * (0.14447856616566443 + (0.09089219002147308*fabs(bR[65])))); + inputSampleR -= (bR[66] * (0.10385520794251019 + (0.08600465834570559*fabs(bR[66])))); + inputSampleR -= (bR[67] * (0.07124435678265063 + (0.09071532210549428*fabs(bR[67])))); + inputSampleR -= (bR[68] * (0.05216857461197572 + (0.06794061706070262*fabs(bR[68])))); + inputSampleR -= (bR[69] * (0.05235381920184123 + (0.02818101717909346*fabs(bR[69])))); + inputSampleR -= (bR[70] * (0.07569701245553526 - (0.00634228544764946*fabs(bR[70])))); + inputSampleR -= (bR[71] * (0.10320125382718826 - (0.02751486906644141*fabs(bR[71])))); + inputSampleR -= (bR[72] * (0.12122120969079088 - (0.05434007312178933*fabs(bR[72])))); + inputSampleR -= (bR[73] * (0.13438969117200902 - (0.09135218559713874*fabs(bR[73])))); + inputSampleR -= (bR[74] * (0.13534390437529981 - (0.10437672041458675*fabs(bR[74])))); + inputSampleR -= (bR[75] * (0.11424128854188388 - (0.08693450726462598*fabs(bR[75])))); + inputSampleR -= (bR[76] * (0.08166894518596159 - (0.06949989431475120*fabs(bR[76])))); + inputSampleR -= (bR[77] * (0.04293976378555305 - (0.05718625137421843*fabs(bR[77])))); + inputSampleR += (bR[78] * (0.00933076320644409 + (0.01728285211520138*fabs(bR[78])))); + inputSampleR += (bR[79] * (0.06450430362918153 - (0.02492994833691022*fabs(bR[79])))); + inputSampleR += (bR[80] * (0.10187400687649277 - (0.03578455940532403*fabs(bR[80])))); + inputSampleR += (bR[81] * (0.11039763294094571 - (0.03995523517573508*fabs(bR[81])))); + inputSampleR += (bR[82] * (0.08557960776024547 - (0.03482514309492527*fabs(bR[82])))); + inputSampleR += (bR[83] * (0.02730881850805332 - (0.00514750108411127*fabs(bR[83])))); + + temp = (inputSampleR + smoothCabBR)/3.0; + smoothCabBR = inputSampleR; + inputSampleR = temp/4.0; + + randy = ((double(fpdR)/UINT32_MAX)*0.04); + drySampleR = ((((inputSampleR*(1-randy))+(lastCabSampleR*randy))*wet)+(drySampleR*(1.0-wet)))*outputlevel; + lastCabSampleR = inputSampleR; + inputSampleR = drySampleR; //cab + + if (cycleEnd == 4) { + lastRefL[0] = lastRefL[4]; //start from previous last + lastRefL[2] = (lastRefL[0] + inputSampleL)/2; //half + lastRefL[1] = (lastRefL[0] + lastRefL[2])/2; //one quarter + lastRefL[3] = (lastRefL[2] + inputSampleL)/2; //three quarters + lastRefL[4] = inputSampleL; //full + lastRefR[0] = lastRefR[4]; //start from previous last + lastRefR[2] = (lastRefR[0] + inputSampleR)/2; //half + lastRefR[1] = (lastRefR[0] + lastRefR[2])/2; //one quarter + lastRefR[3] = (lastRefR[2] + inputSampleR)/2; //three quarters + lastRefR[4] = inputSampleR; //full + } + if (cycleEnd == 3) { + lastRefL[0] = lastRefL[3]; //start from previous last + lastRefL[2] = (lastRefL[0]+lastRefL[0]+inputSampleL)/3; //third + lastRefL[1] = (lastRefL[0]+inputSampleL+inputSampleL)/3; //two thirds + lastRefL[3] = inputSampleL; //full + lastRefR[0] = lastRefR[3]; //start from previous last + lastRefR[2] = (lastRefR[0]+lastRefR[0]+inputSampleR)/3; //third + lastRefR[1] = (lastRefR[0]+inputSampleR+inputSampleR)/3; //two thirds + lastRefR[3] = inputSampleR; //full + } + if (cycleEnd == 2) { + lastRefL[0] = lastRefL[2]; //start from previous last + lastRefL[1] = (lastRefL[0] + inputSampleL)/2; //half + lastRefL[2] = inputSampleL; //full + lastRefR[0] = lastRefR[2]; //start from previous last + lastRefR[1] = (lastRefR[0] + inputSampleR)/2; //half + lastRefR[2] = inputSampleR; //full + } + if (cycleEnd == 1) { + lastRefL[0] = inputSampleL; + lastRefR[0] = inputSampleR; + } + cycle = 0; //reset + inputSampleL = lastRefL[cycle]; + inputSampleR = lastRefR[cycle]; + } else { + inputSampleL = lastRefL[cycle]; + inputSampleR = lastRefR[cycle]; + //we are going through our references now + } + switch (cycleEnd) //multi-pole average using lastRef[] variables + { + case 4: + lastRefL[8] = inputSampleL; inputSampleL = (inputSampleL+lastRefL[7])*0.5; + lastRefL[7] = lastRefL[8]; //continue, do not break + lastRefR[8] = inputSampleR; inputSampleR = (inputSampleR+lastRefR[7])*0.5; + lastRefR[7] = lastRefR[8]; //continue, do not break + case 3: + lastRefL[8] = inputSampleL; inputSampleL = (inputSampleL+lastRefL[6])*0.5; + lastRefL[6] = lastRefL[8]; //continue, do not break + lastRefR[8] = inputSampleR; inputSampleR = (inputSampleR+lastRefR[6])*0.5; + lastRefR[6] = lastRefR[8]; //continue, do not break + case 2: + lastRefL[8] = inputSampleL; inputSampleL = (inputSampleL+lastRefL[5])*0.5; + lastRefL[5] = lastRefL[8]; //continue, do not break + lastRefR[8] = inputSampleR; inputSampleR = (inputSampleR+lastRefR[5])*0.5; + lastRefR[5] = lastRefR[8]; //continue, do not break + case 1: + break; //no further averaging + } + + //begin 64 bit stereo floating point dither + //int expon; frexp((double)inputSampleL, &expon); + fpdL ^= fpdL << 13; fpdL ^= fpdL >> 17; fpdL ^= fpdL << 5; + //inputSampleL += ((double(fpdL)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62)); + //frexp((double)inputSampleR, &expon); + fpdR ^= fpdR << 13; fpdR ^= fpdR >> 17; fpdR ^= fpdR << 5; + //inputSampleR += ((double(fpdR)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62)); + //end 64 bit stereo floating point dither + + *out1 = inputSampleL; + *out2 = inputSampleR; + + in1++; + in2++; + out1++; + out2++; + } +} diff --git a/plugin/Source/Panels.h b/plugin/Source/Panels.h index 9268748..28a33bc 100644 --- a/plugin/Source/Panels.h +++ b/plugin/Source/Panels.h @@ -638,15 +638,16 @@ public: getProperties().set ("fxId", fxGate); addEnable (proc.gateParams.enable); + getHeader().setMouseCursor (juce::MouseCursor::LeftRightResizeCursor); - addControl (new gin::Select (proc.gateParams.beat), 0, 0); - addControl (new gin::Knob (proc.gateParams.length), 1, 0); - addControl (new gin::Knob (proc.gateParams.attack), 2, 0); - addControl (new gin::Knob (proc.gateParams.release), 3, 0); + addControl (new gin::Select (proc.gateParams.beat)); + addControl (new gin::Knob (proc.gateParams.length)); + addControl (new gin::Knob (proc.gateParams.attack)); + addControl (new gin::Knob (proc.gateParams.release)); auto g = new gin::GateEffectComponent (Cfg::numGateSteps); g->setParams (proc.gateParams.length, proc.gateParams.l, proc.gateParams.r, proc.gateParams.enable); - addControl (g, 0, 1, 4, 1); + addControl (g); } WavetableAudioProcessor& proc; @@ -663,6 +664,7 @@ public: getProperties().set ("fxId", fxChorus); addEnable (proc.chorusParams.enable); + getHeader().setMouseCursor (juce::MouseCursor::LeftRightResizeCursor); addControl (new gin::Knob (proc.chorusParams.delay), 0, 0); addControl (new gin::Knob (proc.chorusParams.rate), 1, 0); @@ -686,11 +688,110 @@ public: getProperties().set ("fxId", fxDistort); addEnable (proc.distortionParams.enable); + getHeader().setMouseCursor (juce::MouseCursor::LeftRightResizeCursor); - addControl (new gin::Knob (proc.distortionParams.amount), 0, 0); + { + page1 = new juce::Component ("page1"); + page1->setInterceptsMouseClicks (false, true); + + addControl (page1); + + addControl (page1, new gin::Knob (proc.distortionParams.amount)); + } + + { + page2 = new juce::Component ("page2"); + page2->setInterceptsMouseClicks (false, true); + + addControl (page2); + + addControl (page2, new gin::Knob (proc.bitcrusherParams.rate)); + addControl (page2, new gin::Knob (proc.bitcrusherParams.rez)); + addControl (page2, new gin::Knob (proc.bitcrusherParams.hard)); + addControl (page2, new gin::Knob (proc.bitcrusherParams.mix)); + } + + { + page3 = new juce::Component ("page3"); + page3->setInterceptsMouseClicks (false, true); + + addControl (page3); + + addControl (page3, new gin::Knob (proc.fireAmpParams.gain)); + addControl (page3, new gin::Knob (proc.fireAmpParams.tone)); + addControl (page3, new gin::Knob (proc.fireAmpParams.output)); + addControl (page3, new gin::Knob (proc.fireAmpParams.mix)); + } + + { + page4 = new juce::Component ("page4"); + page4->setInterceptsMouseClicks (false, true); + + addControl (page4); + + addControl (page4, new gin::Knob (proc.grindAmpParams.gain)); + addControl (page4, new gin::Knob (proc.grindAmpParams.tone)); + addControl (page4, new gin::Knob (proc.grindAmpParams.output)); + addControl (page4, new gin::Knob (proc.grindAmpParams.mix)); + } + + auto& h = getHeader(); + h.addAndMakeVisible (modeButton); + modeButton.onClick = [this] + { + juce::PopupMenu m; + m.setLookAndFeel (&getLookAndFeel()); + + m.addItem ("Simple", true, proc.fxParams.distMode->getUserValueInt() == 0, [this] + { + proc.fxParams.distMode->setUserValue (0.0f); + }); + m.addItem ("Bitcrusher", true, proc.fxParams.distMode->getUserValueInt() == 1, [this] + { + proc.fxParams.distMode->setUserValue (1.0f); + }); + m.addItem ("Fire Amp", true, proc.fxParams.distMode->getUserValueInt() == 2, [this] + { + proc.fxParams.distMode->setUserValue (2.0f); + }); + m.addItem ("Grind Amp", true, proc.fxParams.distMode->getUserValueInt() == 3, [this] + { + proc.fxParams.distMode->setUserValue (3.0f); + }); + + m.showMenuAsync ({}); + }; + + watchParam (proc.fxParams.distMode); + paramChanged(); } + void paramChanged() override + { + gin::ParamBox::paramChanged(); + + auto mode = proc.fxParams.distMode->getUserValueInt(); + + page1->setVisible (mode == 0); + page2->setVisible (mode == 1); + page3->setVisible (mode == 2); + page4->setVisible (mode == 3); + + auto& h = getHeader(); + if (mode == 0) h.setTitle ("Dist"); + if (mode == 1) h.setTitle ("Crush"); + if (mode == 2) h.setTitle ("Fire"); + if (mode == 3) h.setTitle ("Grind"); + } + + juce::Component* page1; + juce::Component* page2; + juce::Component* page3; + juce::Component* page4; + WavetableAudioProcessor& proc; + + gin::SVGButton modeButton { "mode", gin::Assets::caretDown, 6 }; }; //============================================================================== @@ -704,6 +805,7 @@ public: getProperties().set ("fxId", fxDelay); addEnable (proc.delayParams.enable); + getHeader().setMouseCursor (juce::MouseCursor::LeftRightResizeCursor); addControl (t = new gin::Knob (proc.delayParams.time), 0, 0); addControl (b = new gin::Select (proc.delayParams.beat), 0, 0); @@ -742,6 +844,7 @@ public: getProperties().set ("fxId", fxReverb); addEnable (proc.reverbParams.enable); + getHeader().setMouseCursor (juce::MouseCursor::LeftRightResizeCursor); addControl (new gin::Knob (proc.reverbParams.size), 0, 0); addControl (new gin::Knob (proc.reverbParams.decay), 1, 0); diff --git a/plugin/Source/PluginProcessor.cpp b/plugin/Source/PluginProcessor.cpp index 9c735dd..6957818 100644 --- a/plugin/Source/PluginProcessor.cpp +++ b/plugin/Source/PluginProcessor.cpp @@ -365,11 +365,48 @@ void WavetableAudioProcessor::ReverbParams::setup (WavetableAudioProcessor& p) //============================================================================== void WavetableAudioProcessor::FXParams::setup (WavetableAudioProcessor& p) { - fx1 = p.addIntParam ("fxOrder1", "FX1", "", "", { 0.0, 4.0, 1.0, 1.0 }, fxGate, 0.0f); - fx2 = p.addIntParam ("fxOrder2", "FX2", "", "", { 0.0, 4.0, 1.0, 1.0 }, fxChorus, 0.0f); - fx3 = p.addIntParam ("fxOrder3", "FX3", "", "", { 0.0, 4.0, 1.0, 1.0 }, fxDistort, 0.0f); - fx4 = p.addIntParam ("fxOrder4", "FX4", "", "", { 0.0, 4.0, 1.0, 1.0 }, fxDelay, 0.0f); - fx5 = p.addIntParam ("fxOrder5", "FX5", "", "", { 0.0, 4.0, 1.0, 1.0 }, fxReverb, 0.0f); + fx1 = p.addIntParam ("fxOrder1", "FX1", "", "", { 0.0, 4.0, 1.0, 1.0 }, fxGate, 0.0f); + fx2 = p.addIntParam ("fxOrder2", "FX2", "", "", { 0.0, 4.0, 1.0, 1.0 }, fxChorus, 0.0f); + fx3 = p.addIntParam ("fxOrder3", "FX3", "", "", { 0.0, 4.0, 1.0, 1.0 }, fxDistort, 0.0f); + fx4 = p.addIntParam ("fxOrder4", "FX4", "", "", { 0.0, 4.0, 1.0, 1.0 }, fxDelay, 0.0f); + fx5 = p.addIntParam ("fxOrder5", "FX5", "", "", { 0.0, 4.0, 1.0, 1.0 }, fxReverb, 0.0f); + distMode = p.addIntParam ("distMode", "Dist Mode", "", "", { 0.0, 3.0, 1.0, 1.0 }, 0, 0.0f); +} + +//============================================================================== +void WavetableAudioProcessor::BitCrusherParams::setup (WavetableAudioProcessor& p) +{ + juce::String id = "crush"; + juce::String nm = "Crush "; + + rate = p.addExtParam (id + "rate", nm + "Rate", "Rate", "", { 0.0, 1.0, 0.0, 1.0f }, 0.5f, 0.0f); + rez = p.addExtParam (id + "rez", nm + "Rez", "Rez", "", { 0.0, 1.0, 0.0, 1.0f }, 0.5f, 0.0f); + hard = p.addExtParam (id + "hard", nm + "Hard", "Hard", "", { 0.0, 1.0, 0.0, 1.0f }, 0.8f, 0.0f); + mix = p.addExtParam (id + "mix", nm + "Mix", "Mix", "", { 0.0, 1.0, 0.0, 1.0f }, 1.0f, 0.0f); +} + +//============================================================================== +void WavetableAudioProcessor::FireAmpParams::setup (WavetableAudioProcessor& p) +{ + juce::String id = "fire"; + juce::String nm = "Fire "; + + gain = p.addExtParam (id + "gain", nm + "Gain", "Gain", "", { 0.0, 1.0, 0.0, 1.0f }, 0.5f, 0.0f); + tone = p.addExtParam (id + "tone", nm + "Tone", "Tone", "", { 0.0, 1.0, 0.0, 1.0f }, 0.5f, 0.0f); + output = p.addExtParam (id + "output", nm + "Output", "Output", "", { 0.0, 1.0, 0.0, 1.0f }, 0.8f, 0.0f); + mix = p.addExtParam (id + "mix", nm + "Mix", "Mix", "", { 0.0, 1.0, 0.0, 1.0f }, 1.0f, 0.0f); +} + +//============================================================================== +void WavetableAudioProcessor::GrindAmpParams::setup (WavetableAudioProcessor& p) +{ + juce::String id = "grind"; + juce::String nm = "Grind "; + + gain = p.addExtParam (id + "gain", nm + "Gain", "Gain", "", { 0.0, 1.0, 0.0, 1.0f }, 0.5f, 0.0f); + tone = p.addExtParam (id + "tone", nm + "Tone", "Tone", "", { 0.0, 1.0, 0.0, 1.0f }, 0.5f, 0.0f); + output = p.addExtParam (id + "output", nm + "Output", "Output", "", { 0.0, 1.0, 0.0, 1.0f }, 0.8f, 0.0f); + mix = p.addExtParam (id + "mix", nm + "Mix", "Mix", "", { 0.0, 1.0, 0.0, 1.0f }, 1.0f, 0.0f); } #if 0 @@ -467,7 +504,10 @@ void extractWavetables() //============================================================================== WavetableAudioProcessor::WavetableAudioProcessor() - : gin::Processor (juce::AudioProcessor::BusesProperties().withOutput ("Output", juce::AudioChannelSet::stereo(), true), false) + : gin::Processor (juce::AudioProcessor::BusesProperties().withOutput ("Output", juce::AudioChannelSet::stereo(), true), false), + bitcrusher (FXBaseCallback ([this] { return gin::Processor::getSampleRate(); })), + fireAmp (FXBaseCallback ([this] { return gin::Processor::getSampleRate(); })), + grindAmp (FXBaseCallback ([this] { return gin::Processor::getSampleRate(); })) { { auto sz = 0; @@ -510,6 +550,11 @@ WavetableAudioProcessor::WavetableAudioProcessor() reverbParams.setup (*this); fxParams.setup (*this); + versionHint++; + bitcrusherParams.setup (*this); + fireAmpParams.setup (*this); + grindAmpParams.setup (*this); + for (int i = 0; i < 50; i++) { auto voice = new WavetableVoice (*this); @@ -885,8 +930,24 @@ void WavetableAudioProcessor::applyEffect (juce::AudioSampleBuffer& buffer, int // Apply Distortion if (fxId == fxDistort && distortionParams.enable->isOn()) { - auto clip = 1.0f / (2.0f * distortionVal); - gin::Distortion::processBlock (buffer, distortionVal, -clip, clip); + auto mode = fxParams.distMode->getUserValueInt(); + if (mode == 0) + { + auto clip = 1.0f / (2.0f * distortionVal); + gin::Distortion::processBlock (buffer, distortionVal, -clip, clip); + } + else if (mode == 1) + { + bitcrusher.processReplacing ((float**)buffer.getArrayOfWritePointers(), (float**)buffer.getArrayOfWritePointers(), buffer.getNumSamples()); + } + else if (mode == 2) + { + fireAmp.processReplacing ((float**)buffer.getArrayOfWritePointers(), (float**)buffer.getArrayOfWritePointers(), buffer.getNumSamples()); + } + else if (mode == 3) + { + grindAmp.processReplacing ((float**)buffer.getArrayOfWritePointers(), (float**)buffer.getArrayOfWritePointers(), buffer.getNumSamples()); + } } // Apply Delay @@ -999,7 +1060,34 @@ void WavetableAudioProcessor::updateParams (int newBlockSize) // Update Distortion if (distortionParams.enable->isOn()) - distortionVal = modMatrix.getValue (distortionParams.amount); + { + auto mode = fxParams.distMode->getUserValueInt(); + if (mode == 0) + { + distortionVal = modMatrix.getValue (distortionParams.amount); + } + else if (mode == 1) + { + bitcrusher.setParameter (0, modMatrix.getValue (bitcrusherParams.rez)); + bitcrusher.setParameter (1, modMatrix.getValue (bitcrusherParams.rate)); + bitcrusher.setParameter (2, modMatrix.getValue (bitcrusherParams.hard)); + bitcrusher.setParameter (3, modMatrix.getValue (bitcrusherParams.mix)); + } + else if (mode == 2) + { + fireAmp.setParameter (0, modMatrix.getValue (fireAmpParams.gain)); + fireAmp.setParameter (1, modMatrix.getValue (fireAmpParams.tone)); + fireAmp.setParameter (2, modMatrix.getValue (fireAmpParams.output)); + fireAmp.setParameter (3, modMatrix.getValue (fireAmpParams.mix)); + } + else if (mode == 3) + { + grindAmp.setParameter (0, modMatrix.getValue (grindAmpParams.gain)); + grindAmp.setParameter (1, modMatrix.getValue (grindAmpParams.tone)); + grindAmp.setParameter (2, modMatrix.getValue (grindAmpParams.output)); + grindAmp.setParameter (3, modMatrix.getValue (grindAmpParams.mix)); + } + } // Update Delay if (delayParams.enable->isOn()) @@ -1032,7 +1120,6 @@ void WavetableAudioProcessor::updateParams (int newBlockSize) reverb.setDamping (modMatrix.getValue (reverbParams.damping)); reverb.setPredelay (modMatrix.getValue (reverbParams.predelay)); reverb.setMix (modMatrix.getValue (reverbParams.mix)); - } // Output gain diff --git a/plugin/Source/PluginProcessor.h b/plugin/Source/PluginProcessor.h index 4eb4526..fb33a1e 100644 --- a/plugin/Source/PluginProcessor.h +++ b/plugin/Source/PluginProcessor.h @@ -3,6 +3,9 @@ #include #include "WavetableVoice.h" +#include "FX/DeRez2.h" +#include "FX/FireAmp.h" +#include "FX/GrindAmp.h" constexpr auto fxGate = 0; constexpr auto fxChorus = 1; @@ -232,13 +235,46 @@ public: { FXParams() = default; - gin::Parameter::Ptr fx1, fx2, fx3, fx4, fx5; + gin::Parameter::Ptr fx1, fx2, fx3, fx4, fx5, distMode; void setup (WavetableAudioProcessor& p); JUCE_DECLARE_NON_COPYABLE (FXParams) }; + struct BitCrusherParams + { + BitCrusherParams() = default; + + gin::Parameter::Ptr rate, rez, hard, mix; + + void setup (WavetableAudioProcessor& p); + + JUCE_DECLARE_NON_COPYABLE (BitCrusherParams) + }; + + struct FireAmpParams + { + FireAmpParams() = default; + + gin::Parameter::Ptr gain, tone, output, mix; + + void setup (WavetableAudioProcessor& p); + + JUCE_DECLARE_NON_COPYABLE (FireAmpParams) + }; + + struct GrindAmpParams + { + GrindAmpParams() = default; + + gin::Parameter::Ptr gain, tone, output, mix; + + void setup (WavetableAudioProcessor& p); + + JUCE_DECLARE_NON_COPYABLE (GrindAmpParams) + }; + //============================================================================== gin::ModSrcId modSrcPressure, modSrcTimbre, modSrcPitchbend, modScrPitchBend, modSrcFilter, modSrcNote, modSrcVelocity, modSrcStep, modSrcMonoStep; @@ -264,6 +300,9 @@ public: DistortionParams distortionParams; DelayParams delayParams; ReverbParams reverbParams; + BitCrusherParams bitcrusherParams; + FireAmpParams fireAmpParams; + GrindAmpParams grindAmpParams; UIParams uiParams; //============================================================================== @@ -274,6 +313,9 @@ public: gin::GainProcessor outputGain; gin::AudioFifo scopeFifo { 2, 44100 }; float distortionVal = 0.0f; + DeRez2 bitcrusher; + FireAmp fireAmp; + GrindAmp grindAmp; juce::OwnedArray osc1Tables; juce::OwnedArray osc2Tables;