From 269773482d643f7cf409641895bf2cbec5526296 Mon Sep 17 00:00:00 2001 From: Chris Johnson Date: Sun, 8 Sep 2019 20:05:27 -0400 Subject: Monitoring --- plugins/LinuxVST/src/Monitoring/Monitoring.cpp | 179 ++++ plugins/LinuxVST/src/Monitoring/Monitoring.h | 85 ++ plugins/LinuxVST/src/Monitoring/MonitoringProc.cpp | 948 +++++++++++++++++++++ 3 files changed, 1212 insertions(+) create mode 100755 plugins/LinuxVST/src/Monitoring/Monitoring.cpp create mode 100755 plugins/LinuxVST/src/Monitoring/Monitoring.h create mode 100755 plugins/LinuxVST/src/Monitoring/MonitoringProc.cpp (limited to 'plugins/LinuxVST/src') diff --git a/plugins/LinuxVST/src/Monitoring/Monitoring.cpp b/plugins/LinuxVST/src/Monitoring/Monitoring.cpp new file mode 100755 index 0000000..124af48 --- /dev/null +++ b/plugins/LinuxVST/src/Monitoring/Monitoring.cpp @@ -0,0 +1,179 @@ +/* ======================================== + * Monitoring - Monitoring.h + * Copyright (c) 2016 airwindows, All rights reserved + * ======================================== */ + +#ifndef __Monitoring_H +#include "Monitoring.h" +#endif + +AudioEffect* createEffectInstance(audioMasterCallback audioMaster) {return new Monitoring(audioMaster);} + +Monitoring::Monitoring(audioMasterCallback audioMaster) : + AudioEffectX(audioMaster, kNumPrograms, kNumParameters) +{ + bynL[0] = 1000.0; + bynL[1] = 301.0; + bynL[2] = 176.0; + bynL[3] = 125.0; + bynL[4] = 97.0; + bynL[5] = 79.0; + bynL[6] = 67.0; + bynL[7] = 58.0; + bynL[8] = 51.0; + bynL[9] = 46.0; + bynL[10] = 1000.0; + noiseShapingL = 0.0; + bynR[0] = 1000.0; + bynR[1] = 301.0; + bynR[2] = 176.0; + bynR[3] = 125.0; + bynR[4] = 97.0; + bynR[5] = 79.0; + bynR[6] = 67.0; + bynR[7] = 58.0; + bynR[8] = 51.0; + bynR[9] = 46.0; + bynR[10] = 1000.0; + noiseShapingR = 0.0; + //end NJAD + for(int count = 0; count < 1502; count++) { + aL[count] = 0.0; bL[count] = 0.0; cL[count] = 0.0; dL[count] = 0.0; + aR[count] = 0.0; bR[count] = 0.0; cR[count] = 0.0; dR[count] = 0.0; + } + ax = 1; bx = 1; cx = 1; dx = 1; + //PeaksOnly + lastSampleL = 0.0; lastSampleR = 0.0; + //SlewOnly + 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; iirSampleML = 0.0; iirSampleNL = 0.0; iirSampleOL = 0.0; iirSamplePL = 0.0; + iirSampleQL = 0.0; iirSampleRL = 0.0; iirSampleSL = 0.0; + iirSampleTL = 0.0; iirSampleUL = 0.0; iirSampleVL = 0.0; + iirSampleWL = 0.0; iirSampleXL = 0.0; iirSampleYL = 0.0; iirSampleZL = 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; iirSampleMR = 0.0; iirSampleNR = 0.0; iirSampleOR = 0.0; iirSamplePR = 0.0; + iirSampleQR = 0.0; iirSampleRR = 0.0; iirSampleSR = 0.0; + iirSampleTR = 0.0; iirSampleUR = 0.0; iirSampleVR = 0.0; + iirSampleWR = 0.0; iirSampleXR = 0.0; iirSampleYR = 0.0; iirSampleZR = 0.0; // o/` + //SubsOnly + for (int x = 0; x < 11; x++) {biquad[x] = 0.0;} + //Bandpasses + A = 0.0; + fpd = 17; + //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 +} + +Monitoring::~Monitoring() {} +VstInt32 Monitoring::getVendorVersion () {return 1000;} +void Monitoring::setProgramName(char *name) {vst_strncpy (_programName, name, kVstMaxProgNameLen);} +void Monitoring::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 Monitoring::getChunk (void** data, bool isPreset) +{ + float *chunkData = (float *)calloc(kNumParameters, sizeof(float)); + chunkData[0] = A; + /* 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 Monitoring::setChunk (void* data, VstInt32 byteSize, bool isPreset) +{ + float *chunkData = (float *)data; + A = pinParameter(chunkData[0]); + /* 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 Monitoring::setParameter(VstInt32 index, float value) { + switch (index) { + case kParamA: A = value; break; + default: throw; // unknown parameter, shouldn't happen! + } +} + +float Monitoring::getParameter(VstInt32 index) { + switch (index) { + case kParamA: return A; 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 Monitoring::getParameterName(VstInt32 index, char *text) { + switch (index) { + case kParamA: vst_strncpy (text, "Monitor", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } //this is our labels for displaying in the VST host +} + +void Monitoring::getParameterDisplay(VstInt32 index, char *text) { + switch (index) { + case kParamA: switch((VstInt32)( A * 11.999 )) //0 to almost edge of # of params + { case 0: vst_strncpy (text, "Out24", kVstMaxParamStrLen); break; + case 1: vst_strncpy (text, "Out16", kVstMaxParamStrLen); break; + case 2: vst_strncpy (text, "Peaks", kVstMaxParamStrLen); break; + case 3: vst_strncpy (text, "Slew", kVstMaxParamStrLen); break; + case 4: vst_strncpy (text, "Subs", kVstMaxParamStrLen); break; + case 5: vst_strncpy (text, "Mono", kVstMaxParamStrLen); break; + case 6: vst_strncpy (text, "Side", kVstMaxParamStrLen); break; + case 7: vst_strncpy (text, "Vinyl", kVstMaxParamStrLen); break; + case 8: vst_strncpy (text, "Aurat", kVstMaxParamStrLen); break; + case 9: vst_strncpy (text, "Phone", kVstMaxParamStrLen); break; + case 10: vst_strncpy (text, "Cans A", kVstMaxParamStrLen); break; + case 11: vst_strncpy (text, "Cans B", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } break; + default: break; // unknown parameter, shouldn't happen! + } //this displays the values and handles 'popups' where it's discrete choices +} + +void Monitoring::getParameterLabel(VstInt32 index, char *text) { + switch (index) { + case kParamA: vst_strncpy (text, "", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } +} + +VstInt32 Monitoring::canDo(char *text) +{ return (_canDo.find(text) == _canDo.end()) ? -1: 1; } // 1 = yes, -1 = no, 0 = don't know + +bool Monitoring::getEffectName(char* name) { + vst_strncpy(name, "Monitoring", kVstMaxProductStrLen); return true; +} + +VstPlugCategory Monitoring::getPlugCategory() {return kPlugCategEffect;} + +bool Monitoring::getProductString(char* text) { + vst_strncpy (text, "airwindows Monitoring", kVstMaxProductStrLen); return true; +} + +bool Monitoring::getVendorString(char* text) { + vst_strncpy (text, "airwindows", kVstMaxVendorStrLen); return true; +} diff --git a/plugins/LinuxVST/src/Monitoring/Monitoring.h b/plugins/LinuxVST/src/Monitoring/Monitoring.h new file mode 100755 index 0000000..cb64834 --- /dev/null +++ b/plugins/LinuxVST/src/Monitoring/Monitoring.h @@ -0,0 +1,85 @@ +/* ======================================== + * Monitoring - Monitoring.h + * Created 8/12/11 by SPIAdmin + * Copyright (c) 2011 __MyCompanyName__, All rights reserved + * ======================================== */ + +#ifndef __Monitoring_H +#define __Monitoring_H + +#ifndef __audioeffect__ +#include "audioeffectx.h" +#endif + +#include +#include +#include + +enum { + kParamA = 0, + kNumParameters = 1 +}; // + +const int kNumPrograms = 0; +const int kNumInputs = 2; +const int kNumOutputs = 2; +const unsigned long kUniqueId = 'moni'; //Change this to what the AU identity is! + +class Monitoring : + public AudioEffectX +{ +public: + Monitoring(audioMasterCallback audioMaster); + ~Monitoring(); + virtual bool getEffectName(char* name); // The plug-in name + virtual VstPlugCategory getPlugCategory(); // The general category for the plug-in + virtual bool getProductString(char* text); // This is a unique plug-in string provided by Steinberg + virtual bool getVendorString(char* text); // Vendor info + virtual VstInt32 getVendorVersion(); // Version number + virtual void processReplacing (float** inputs, float** outputs, VstInt32 sampleFrames); + virtual void processDoubleReplacing (double** inputs, double** outputs, VstInt32 sampleFrames); + virtual void getProgramName(char *name); // read the name from the host + virtual void setProgramName(char *name); // changes the name of the preset displayed in the host + virtual VstInt32 getChunk (void** data, bool isPreset); + virtual VstInt32 setChunk (void* data, VstInt32 byteSize, bool isPreset); + virtual float getParameter(VstInt32 index); // get the parameter value at the specified index + virtual void setParameter(VstInt32 index, float value); // set the parameter at index to value + virtual void getParameterLabel(VstInt32 index, char *text); // label for the parameter (eg dB) + virtual void getParameterName(VstInt32 index, char *text); // name of the parameter + virtual void getParameterDisplay(VstInt32 index, char *text); // text description of the current value + virtual VstInt32 canDo(char *text); +private: + char _programName[kVstMaxProgNameLen + 1]; + std::set< std::string > _canDo; + + long double bynL[13], bynR[13]; + long double noiseShapingL, noiseShapingR; + //NJAD + double aL[1503], bL[1503], cL[1503], dL[1503]; + double aR[1503], bR[1503], cR[1503], dR[1503]; + int ax, bx, cx, dx; + //PeaksOnly + double lastSampleL, lastSampleR; + //SlewOnly + double iirSampleAL, iirSampleBL, iirSampleCL, iirSampleDL, iirSampleEL, iirSampleFL, iirSampleGL; + double iirSampleHL, iirSampleIL, iirSampleJL, iirSampleKL, iirSampleLL, iirSampleML, iirSampleNL, iirSampleOL, iirSamplePL; + double iirSampleQL, iirSampleRL, iirSampleSL; + double iirSampleTL, iirSampleUL, iirSampleVL; + double iirSampleWL, iirSampleXL, iirSampleYL, iirSampleZL; + + double iirSampleAR, iirSampleBR, iirSampleCR, iirSampleDR, iirSampleER, iirSampleFR, iirSampleGR; + double iirSampleHR, iirSampleIR, iirSampleJR, iirSampleKR, iirSampleLR, iirSampleMR, iirSampleNR, iirSampleOR, iirSamplePR; + double iirSampleQR, iirSampleRR, iirSampleSR; + double iirSampleTR, iirSampleUR, iirSampleVR; + double iirSampleWR, iirSampleXR, iirSampleYR, iirSampleZR; // o/` + //SubsOnly + long double biquad[11]; + //Bandpasses + + uint32_t fpd; + //default stuff + + float A; +}; + +#endif diff --git a/plugins/LinuxVST/src/Monitoring/MonitoringProc.cpp b/plugins/LinuxVST/src/Monitoring/MonitoringProc.cpp new file mode 100755 index 0000000..297655c --- /dev/null +++ b/plugins/LinuxVST/src/Monitoring/MonitoringProc.cpp @@ -0,0 +1,948 @@ +/* ======================================== + * Monitoring - Monitoring.h + * Copyright (c) 2016 airwindows, All rights reserved + * ======================================== */ + +#ifndef __Monitoring_H +#include "Monitoring.h" +#endif + +void Monitoring::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 processing = (VstInt32)( A * 11.999 ); + int am = (int)149.0 * overallscale; + int bm = (int)179.0 * overallscale; + int cm = (int)191.0 * overallscale; + int dm = (int)223.0 * overallscale; //these are 'good' primes, spacing out the allpasses + int allpasstemp; + //for PeaksOnly + biquad[0] = 0.0385/overallscale; biquad[1] = 0.0825; //define as VINYL unless overridden + if (processing == 8) {biquad[0] = 0.0375/overallscale; biquad[1] = 0.1575;} + if (processing == 9) {biquad[0] = 0.1245/overallscale; biquad[1] = 0.46;} + double K = tan(M_PI * biquad[0]); + double norm = 1.0 / (1.0 + K / biquad[1] + K * K); + biquad[2] = K / biquad[1] * norm; + biquad[4] = -biquad[2]; //for bandpass, ignore [3] = 0.0 + biquad[5] = 2.0 * (K * K - 1.0) * norm; + biquad[6] = (1.0 - K / biquad[1] + K * K) * norm; + //for Bandpasses + + while (--sampleFrames >= 0) + { + long double inputSampleL = *in1; + long double inputSampleR = *in2; + if (fabs(inputSampleL)<1.18e-37) inputSampleL = fpd * 1.18e-37; + if (fabs(inputSampleR)<1.18e-37) inputSampleR = fpd * 1.18e-37; + + switch (processing) + { + case 0: + case 1: + break; + case 2: + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; inputSampleL = asin(inputSampleL); + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; inputSampleR = asin(inputSampleR); + //amplitude aspect + allpasstemp = ax - 1; if (allpasstemp < 0 || allpasstemp > am) allpasstemp = am; + inputSampleL -= aL[allpasstemp]*0.5; aL[ax] = inputSampleL; inputSampleL *= 0.5; + inputSampleR -= aR[allpasstemp]*0.5; aR[ax] = inputSampleR; inputSampleR *= 0.5; + ax--; if (ax < 0 || ax > am) {ax = am;} + inputSampleL += (aL[ax]); + inputSampleR += (aR[ax]); + //a single Midiverb-style allpass + + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; inputSampleL = asin(inputSampleL); + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; inputSampleR = asin(inputSampleR); + //amplitude aspect + + allpasstemp = bx - 1; if (allpasstemp < 0 || allpasstemp > bm) allpasstemp = bm; + inputSampleL -= bL[allpasstemp]*0.5; bL[bx] = inputSampleL; inputSampleL *= 0.5; + inputSampleR -= bR[allpasstemp]*0.5; bR[bx] = inputSampleR; inputSampleR *= 0.5; + bx--; if (bx < 0 || bx > bm) {bx = bm;} + inputSampleL += (bL[bx]); + inputSampleR += (bR[bx]); + //a single Midiverb-style allpass + + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; inputSampleL = asin(inputSampleL); + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; inputSampleR = asin(inputSampleR); + //amplitude aspect + + allpasstemp = cx - 1; if (allpasstemp < 0 || allpasstemp > cm) allpasstemp = cm; + inputSampleL -= cL[allpasstemp]*0.5; cL[cx] = inputSampleL; inputSampleL *= 0.5; + inputSampleR -= cR[allpasstemp]*0.5; cR[cx] = inputSampleR; inputSampleR *= 0.5; + cx--; if (cx < 0 || cx > cm) {cx = cm;} + inputSampleL += (cL[cx]); + inputSampleR += (cR[cx]); + //a single Midiverb-style allpass + + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; inputSampleL = asin(inputSampleL); + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; inputSampleR = asin(inputSampleR); + //amplitude aspect + + allpasstemp = dx - 1; if (allpasstemp < 0 || allpasstemp > dm) allpasstemp = dm; + inputSampleL -= dL[allpasstemp]*0.5; dL[dx] = inputSampleL; inputSampleL *= 0.5; + inputSampleR -= dR[allpasstemp]*0.5; dR[dx] = inputSampleR; inputSampleR *= 0.5; + dx--; if (dx < 0 || dx > dm) {dx = dm;} + inputSampleL += (dL[dx]); + inputSampleR += (dR[dx]); + //a single Midiverb-style allpass + + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; inputSampleL = asin(inputSampleL); + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; inputSampleR = asin(inputSampleR); + //amplitude aspect + + inputSampleL *= 0.63679; inputSampleR *= 0.63679; //scale it to 0dB output at full blast + //PeaksOnly + break; + case 3: + double trim; + trim = 2.302585092994045684017991; //natural logarithm of 10 + long double slewSample; slewSample = (inputSampleL - lastSampleL)*trim; + lastSampleL = inputSampleL; + if (slewSample > 1.0) slewSample = 1.0; if (slewSample < -1.0) slewSample = -1.0; + inputSampleL = slewSample; + slewSample = (inputSampleR - lastSampleR)*trim; + lastSampleR = inputSampleR; + if (slewSample > 1.0) slewSample = 1.0; if (slewSample < -1.0) slewSample = -1.0; + inputSampleR = slewSample; + //SlewOnly + break; + case 4: + double iirAmount; iirAmount = (2250/44100.0) / overallscale; + double gain; gain = 1.42; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + + iirSampleAL = (iirSampleAL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleAL; + iirSampleAR = (iirSampleAR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleAR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleBL = (iirSampleBL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleBL; + iirSampleBR = (iirSampleBR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleBR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleCL = (iirSampleCL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleCL; + iirSampleCR = (iirSampleCR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleCR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleDL = (iirSampleDL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleDL; + iirSampleDR = (iirSampleDR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleDR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleEL = (iirSampleEL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleEL; + iirSampleER = (iirSampleER * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleER; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleFL = (iirSampleFL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleFL; + iirSampleFR = (iirSampleFR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleFR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleGL = (iirSampleGL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleGL; + iirSampleGR = (iirSampleGR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleGR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleHL = (iirSampleHL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleHL; + iirSampleHR = (iirSampleHR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleHR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleIL = (iirSampleIL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleIL; + iirSampleIR = (iirSampleIR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleIR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleJL = (iirSampleJL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleJL; + iirSampleJR = (iirSampleJR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleJR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleKL = (iirSampleKL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleKL; + iirSampleKR = (iirSampleKR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleKR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleLL = (iirSampleLL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleLL; + iirSampleLR = (iirSampleLR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleLR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleML = (iirSampleML * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleML; + iirSampleMR = (iirSampleMR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleMR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleNL = (iirSampleNL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleNL; + iirSampleNR = (iirSampleNR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleNR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleOL = (iirSampleOL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleOL; + iirSampleOR = (iirSampleOR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleOR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSamplePL = (iirSamplePL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSamplePL; + iirSamplePR = (iirSamplePR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSamplePR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleQL = (iirSampleQL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleQL; + iirSampleQR = (iirSampleQR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleQR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleRL = (iirSampleRL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleRL; + iirSampleRR = (iirSampleRR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleRR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleSL = (iirSampleSL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleSL; + iirSampleSR = (iirSampleSR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleSR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleTL = (iirSampleTL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleTL; + iirSampleTR = (iirSampleTR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleTR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleUL = (iirSampleUL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleUL; + iirSampleUR = (iirSampleUR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleUR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleVL = (iirSampleVL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleVL; + iirSampleVR = (iirSampleVR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleVR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleWL = (iirSampleWL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleWL; + iirSampleWR = (iirSampleWR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleWR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleXL = (iirSampleXL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleXL; + iirSampleXR = (iirSampleXR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleXR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleYL = (iirSampleYL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleYL; + iirSampleYR = (iirSampleYR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleYR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleZL = (iirSampleZL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleZL; + iirSampleZR = (iirSampleZR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleZR; + 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; + //SubsOnly + break; + case 5: + case 6: + long double mid; mid = inputSampleL + inputSampleR; + long double side; side = inputSampleL - inputSampleR; + if (processing < 6) side = 0.0; + else mid = 0.0; //mono monitoring, or side-only monitoring + inputSampleL = (mid+side)/2.0; + inputSampleR = (mid-side)/2.0; + break; + case 7: + case 8: + case 9: + //Bandpass: changes in EQ are up in the variable defining, not here + inputSampleL = sin(inputSampleL); inputSampleR = sin(inputSampleR); + //encode Console5: good cleanness + + long double tempSampleL; tempSampleL = (inputSampleL * biquad[2]) + biquad[7]; + biquad[7] = (-tempSampleL * biquad[5]) + biquad[8]; + biquad[8] = (inputSampleL * biquad[4]) - (tempSampleL * biquad[6]); + inputSampleL = tempSampleL; //like mono AU, 7 and 8 store L channel + + long double tempSampleR; tempSampleR = (inputSampleR * biquad[2]) + biquad[9]; + biquad[9] = (-tempSampleR * biquad[5]) + biquad[10]; + biquad[10] = (inputSampleR * biquad[4]) - (tempSampleR * biquad[6]); + inputSampleR = tempSampleR; //note: 9 and 10 store the R channel + + 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; + //without this, you can get a NaN condition where it spits out DC offset at full blast! + inputSampleL = asin(inputSampleL); inputSampleR = asin(inputSampleR); + //amplitude aspect + break; + case 10: + case 11: + inputSampleL = sin(inputSampleL); + inputSampleR = sin(inputSampleR); + long double drySampleL; drySampleL = inputSampleL; + long double drySampleR; drySampleR = inputSampleR; //everything runs 'inside' Console + + allpasstemp = ax - 1; if (allpasstemp < 0 || allpasstemp > am) allpasstemp = am; + inputSampleL -= aL[allpasstemp]*0.5; aL[ax] = inputSampleL; inputSampleL *= 0.5; + inputSampleR -= aR[allpasstemp]*0.5; aR[ax] = inputSampleR; inputSampleR *= 0.5; + ax--; if (ax < 0 || ax > am) {ax = am;} + inputSampleL += (aL[ax]); + inputSampleR += (aR[ax]); + //a single Midiverb-style allpass + + if (processing == 10) {inputSampleL *= 0.125; inputSampleR *= 0.125;} + else {inputSampleL *= 0.25; inputSampleR *= 0.25;} + //Cans A suppresses the crossfeed more, Cans B makes it louder + + drySampleL += inputSampleR; + drySampleR += inputSampleL; //the crossfeed + + allpasstemp = dx - 1; if (allpasstemp < 0 || allpasstemp > dm) allpasstemp = dm; + inputSampleL -= dL[allpasstemp]*0.5; dL[dx] = inputSampleL; inputSampleL *= 0.5; + inputSampleR -= dR[allpasstemp]*0.5; dR[dx] = inputSampleR; inputSampleR *= 0.5; + dx--; if (dx < 0 || dx > dm) {dx = dm;} + inputSampleL += (dL[dx]); + inputSampleR += (dR[dx]); + //a single Midiverb-style allpass, which is stretching the previous one even more + + if (processing == 10) {inputSampleL *= 0.5; inputSampleR *= 0.5;} + else {inputSampleL *= 0.25; inputSampleR *= 0.25;} + //Cans A already had crossfeeds down, bloom is louder. Cans B sits on bloom more + + drySampleL += inputSampleL; + drySampleR += inputSampleR; //add the crossfeed and very faint extra verbyness + + inputSampleL = drySampleL; + inputSampleR = drySampleR; //and output our can-opened headphone feed + + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; inputSampleL = asin(inputSampleL); + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; inputSampleR = asin(inputSampleR); + //ConsoleBuss processing + break; + } + + + //begin Not Just Another Dither + if (processing == 1) { + inputSampleL = inputSampleL * 32768.0; //or 16 bit option + inputSampleR = inputSampleR * 32768.0; //or 16 bit option + } else { + inputSampleL = inputSampleL * 8388608.0; //for literally everything else + inputSampleR = inputSampleR * 8388608.0; //we will apply the 24 bit NJAD + } //on the not unreasonable assumption that we are very likely playing back on 24 bit DAC + //if we're not, then all we did was apply a Benford Realness function at 24 bits down. + + bool cutbinsL; cutbinsL = false; + bool cutbinsR; cutbinsR = false; + long double drySampleL; drySampleL = inputSampleL; + long double drySampleR; drySampleR = inputSampleR; + inputSampleL -= noiseShapingL; + inputSampleR -= noiseShapingR; + //NJAD L + long double benfordize; benfordize = floor(inputSampleL); + while (benfordize >= 1.0) benfordize /= 10; + while (benfordize < 1.0 && benfordize > 0.0000001) benfordize *= 10; + int hotbinA; hotbinA = floor(benfordize); + //hotbin becomes the Benford bin value for this number floored + long double totalA; totalA = 0; + if ((hotbinA > 0) && (hotbinA < 10)) + { + bynL[hotbinA] += 1; if (bynL[hotbinA] > 982) cutbinsL = true; + totalA += (301-bynL[1]); totalA += (176-bynL[2]); totalA += (125-bynL[3]); + totalA += (97-bynL[4]); totalA += (79-bynL[5]); totalA += (67-bynL[6]); + totalA += (58-bynL[7]); totalA += (51-bynL[8]); totalA += (46-bynL[9]); bynL[hotbinA] -= 1; + } else hotbinA = 10; + //produce total number- smaller is closer to Benford real + benfordize = ceil(inputSampleL); + while (benfordize >= 1.0) benfordize /= 10; + while (benfordize < 1.0 && benfordize > 0.0000001) benfordize *= 10; + int hotbinB; hotbinB = floor(benfordize); + //hotbin becomes the Benford bin value for this number ceiled + long double totalB; totalB = 0; + if ((hotbinB > 0) && (hotbinB < 10)) + { + bynL[hotbinB] += 1; if (bynL[hotbinB] > 982) cutbinsL = true; + totalB += (301-bynL[1]); totalB += (176-bynL[2]); totalB += (125-bynL[3]); + totalB += (97-bynL[4]); totalB += (79-bynL[5]); totalB += (67-bynL[6]); + totalB += (58-bynL[7]); totalB += (51-bynL[8]); totalB += (46-bynL[9]); bynL[hotbinB] -= 1; + } else hotbinB = 10; + //produce total number- smaller is closer to Benford real + long double outputSample; + if (totalA < totalB) {bynL[hotbinA] += 1; outputSample = floor(inputSampleL);} + else {bynL[hotbinB] += 1; outputSample = floor(inputSampleL+1);} + //assign the relevant one to the delay line + //and floor/ceil signal accordingly + if (cutbinsL) { + bynL[1] *= 0.99; bynL[2] *= 0.99; bynL[3] *= 0.99; bynL[4] *= 0.99; bynL[5] *= 0.99; + bynL[6] *= 0.99; bynL[7] *= 0.99; bynL[8] *= 0.99; bynL[9] *= 0.99; bynL[10] *= 0.99; + } + noiseShapingL += outputSample - drySampleL; + if (noiseShapingL > fabs(inputSampleL)) noiseShapingL = fabs(inputSampleL); + if (noiseShapingL < -fabs(inputSampleL)) noiseShapingL = -fabs(inputSampleL); + if (processing == 1) inputSampleL = outputSample / 32768.0; + else inputSampleL = outputSample / 8388608.0; + if (inputSampleL > 1.0) inputSampleL = 1.0; + if (inputSampleL < -1.0) inputSampleL = -1.0; + //finished NJAD L + + //NJAD R + benfordize = floor(inputSampleR); + while (benfordize >= 1.0) benfordize /= 10; + while (benfordize < 1.0 && benfordize > 0.0000001) benfordize *= 10; + hotbinA = floor(benfordize); + //hotbin becomes the Benford bin value for this number floored + totalA = 0; + if ((hotbinA > 0) && (hotbinA < 10)) + { + bynR[hotbinA] += 1; if (bynR[hotbinA] > 982) cutbinsR = true; + totalA += (301-bynR[1]); totalA += (176-bynR[2]); totalA += (125-bynR[3]); + totalA += (97-bynR[4]); totalA += (79-bynR[5]); totalA += (67-bynR[6]); + totalA += (58-bynR[7]); totalA += (51-bynR[8]); totalA += (46-bynR[9]); bynR[hotbinA] -= 1; + } else hotbinA = 10; + //produce total number- smaller is closer to Benford real + benfordize = ceil(inputSampleR); + while (benfordize >= 1.0) benfordize /= 10; + while (benfordize < 1.0 && benfordize > 0.0000001) benfordize *= 10; + hotbinB = floor(benfordize); + //hotbin becomes the Benford bin value for this number ceiled + totalB = 0; + if ((hotbinB > 0) && (hotbinB < 10)) + { + bynR[hotbinB] += 1; if (bynR[hotbinB] > 982) cutbinsR = true; + totalB += (301-bynR[1]); totalB += (176-bynR[2]); totalB += (125-bynR[3]); + totalB += (97-bynR[4]); totalB += (79-bynR[5]); totalB += (67-bynR[6]); + totalB += (58-bynR[7]); totalB += (51-bynR[8]); totalB += (46-bynR[9]); bynR[hotbinB] -= 1; + } else hotbinB = 10; + //produce total number- smaller is closer to Benford real + if (totalA < totalB) {bynR[hotbinA] += 1; outputSample = floor(inputSampleR);} + else {bynR[hotbinB] += 1; outputSample = floor(inputSampleR+1);} + //assign the relevant one to the delay line + //and floor/ceil signal accordingly + if (cutbinsR) { + bynR[1] *= 0.99; bynR[2] *= 0.99; bynR[3] *= 0.99; bynR[4] *= 0.99; bynR[5] *= 0.99; + bynR[6] *= 0.99; bynR[7] *= 0.99; bynR[8] *= 0.99; bynR[9] *= 0.99; bynR[10] *= 0.99; + } + noiseShapingR += outputSample - drySampleR; + if (noiseShapingR > fabs(inputSampleR)) noiseShapingR = fabs(inputSampleR); + if (noiseShapingR < -fabs(inputSampleR)) noiseShapingR = -fabs(inputSampleR); + if (processing == 1) inputSampleR = outputSample / 32768.0; + else inputSampleR = outputSample / 8388608.0; + if (inputSampleR > 1.0) inputSampleR = 1.0; + if (inputSampleR < -1.0) inputSampleR = -1.0; + //finished NJAD R + + //does not use 32 bit stereo floating point dither + + *out1 = inputSampleL; + *out2 = inputSampleR; + + *in1++; + *in2++; + *out1++; + *out2++; + } +} + +void Monitoring::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 processing = (VstInt32)( A * 11.999 ); + int am = (int)149.0 * overallscale; + int bm = (int)179.0 * overallscale; + int cm = (int)191.0 * overallscale; + int dm = (int)223.0 * overallscale; //these are 'good' primes, spacing out the allpasses + int allpasstemp; + //for PeaksOnly + biquad[0] = 0.0385/overallscale; biquad[1] = 0.0825; //define as VINYL unless overridden + if (processing == 8) {biquad[0] = 0.0375/overallscale; biquad[1] = 0.1575;} + if (processing == 9) {biquad[0] = 0.1245/overallscale; biquad[1] = 0.46;} + double K = tan(M_PI * biquad[0]); + double norm = 1.0 / (1.0 + K / biquad[1] + K * K); + biquad[2] = K / biquad[1] * norm; + biquad[4] = -biquad[2]; //for bandpass, ignore [3] = 0.0 + biquad[5] = 2.0 * (K * K - 1.0) * norm; + biquad[6] = (1.0 - K / biquad[1] + K * K) * norm; + //for Bandpasses + + while (--sampleFrames >= 0) + { + long double inputSampleL = *in1; + long double inputSampleR = *in2; + if (fabs(inputSampleL)<1.18e-43) inputSampleL = fpd * 1.18e-43; + if (fabs(inputSampleR)<1.18e-43) inputSampleR = fpd * 1.18e-43; + + switch (processing) + { + case 0: + case 1: + break; + case 2: + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; inputSampleL = asin(inputSampleL); + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; inputSampleR = asin(inputSampleR); + //amplitude aspect + allpasstemp = ax - 1; if (allpasstemp < 0 || allpasstemp > am) allpasstemp = am; + inputSampleL -= aL[allpasstemp]*0.5; aL[ax] = inputSampleL; inputSampleL *= 0.5; + inputSampleR -= aR[allpasstemp]*0.5; aR[ax] = inputSampleR; inputSampleR *= 0.5; + ax--; if (ax < 0 || ax > am) {ax = am;} + inputSampleL += (aL[ax]); + inputSampleR += (aR[ax]); + //a single Midiverb-style allpass + + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; inputSampleL = asin(inputSampleL); + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; inputSampleR = asin(inputSampleR); + //amplitude aspect + + allpasstemp = bx - 1; if (allpasstemp < 0 || allpasstemp > bm) allpasstemp = bm; + inputSampleL -= bL[allpasstemp]*0.5; bL[bx] = inputSampleL; inputSampleL *= 0.5; + inputSampleR -= bR[allpasstemp]*0.5; bR[bx] = inputSampleR; inputSampleR *= 0.5; + bx--; if (bx < 0 || bx > bm) {bx = bm;} + inputSampleL += (bL[bx]); + inputSampleR += (bR[bx]); + //a single Midiverb-style allpass + + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; inputSampleL = asin(inputSampleL); + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; inputSampleR = asin(inputSampleR); + //amplitude aspect + + allpasstemp = cx - 1; if (allpasstemp < 0 || allpasstemp > cm) allpasstemp = cm; + inputSampleL -= cL[allpasstemp]*0.5; cL[cx] = inputSampleL; inputSampleL *= 0.5; + inputSampleR -= cR[allpasstemp]*0.5; cR[cx] = inputSampleR; inputSampleR *= 0.5; + cx--; if (cx < 0 || cx > cm) {cx = cm;} + inputSampleL += (cL[cx]); + inputSampleR += (cR[cx]); + //a single Midiverb-style allpass + + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; inputSampleL = asin(inputSampleL); + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; inputSampleR = asin(inputSampleR); + //amplitude aspect + + allpasstemp = dx - 1; if (allpasstemp < 0 || allpasstemp > dm) allpasstemp = dm; + inputSampleL -= dL[allpasstemp]*0.5; dL[dx] = inputSampleL; inputSampleL *= 0.5; + inputSampleR -= dR[allpasstemp]*0.5; dR[dx] = inputSampleR; inputSampleR *= 0.5; + dx--; if (dx < 0 || dx > dm) {dx = dm;} + inputSampleL += (dL[dx]); + inputSampleR += (dR[dx]); + //a single Midiverb-style allpass + + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; inputSampleL = asin(inputSampleL); + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; inputSampleR = asin(inputSampleR); + //amplitude aspect + + inputSampleL *= 0.63679; inputSampleR *= 0.63679; //scale it to 0dB output at full blast + //PeaksOnly + break; + case 3: + double trim; + trim = 2.302585092994045684017991; //natural logarithm of 10 + long double slewSample; slewSample = (inputSampleL - lastSampleL)*trim; + lastSampleL = inputSampleL; + if (slewSample > 1.0) slewSample = 1.0; if (slewSample < -1.0) slewSample = -1.0; + inputSampleL = slewSample; + slewSample = (inputSampleR - lastSampleR)*trim; + lastSampleR = inputSampleR; + if (slewSample > 1.0) slewSample = 1.0; if (slewSample < -1.0) slewSample = -1.0; + inputSampleR = slewSample; + //SlewOnly + break; + case 4: + double iirAmount; iirAmount = (2250/44100.0) / overallscale; + double gain; gain = 1.42; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + + iirSampleAL = (iirSampleAL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleAL; + iirSampleAR = (iirSampleAR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleAR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleBL = (iirSampleBL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleBL; + iirSampleBR = (iirSampleBR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleBR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleCL = (iirSampleCL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleCL; + iirSampleCR = (iirSampleCR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleCR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleDL = (iirSampleDL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleDL; + iirSampleDR = (iirSampleDR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleDR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleEL = (iirSampleEL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleEL; + iirSampleER = (iirSampleER * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleER; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleFL = (iirSampleFL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleFL; + iirSampleFR = (iirSampleFR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleFR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleGL = (iirSampleGL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleGL; + iirSampleGR = (iirSampleGR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleGR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleHL = (iirSampleHL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleHL; + iirSampleHR = (iirSampleHR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleHR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleIL = (iirSampleIL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleIL; + iirSampleIR = (iirSampleIR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleIR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleJL = (iirSampleJL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleJL; + iirSampleJR = (iirSampleJR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleJR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleKL = (iirSampleKL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleKL; + iirSampleKR = (iirSampleKR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleKR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleLL = (iirSampleLL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleLL; + iirSampleLR = (iirSampleLR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleLR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleML = (iirSampleML * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleML; + iirSampleMR = (iirSampleMR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleMR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleNL = (iirSampleNL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleNL; + iirSampleNR = (iirSampleNR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleNR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleOL = (iirSampleOL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleOL; + iirSampleOR = (iirSampleOR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleOR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSamplePL = (iirSamplePL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSamplePL; + iirSamplePR = (iirSamplePR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSamplePR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleQL = (iirSampleQL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleQL; + iirSampleQR = (iirSampleQR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleQR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleRL = (iirSampleRL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleRL; + iirSampleRR = (iirSampleRR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleRR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleSL = (iirSampleSL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleSL; + iirSampleSR = (iirSampleSR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleSR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleTL = (iirSampleTL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleTL; + iirSampleTR = (iirSampleTR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleTR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleUL = (iirSampleUL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleUL; + iirSampleUR = (iirSampleUR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleUR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleVL = (iirSampleVL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleVL; + iirSampleVR = (iirSampleVR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleVR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleWL = (iirSampleWL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleWL; + iirSampleWR = (iirSampleWR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleWR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleXL = (iirSampleXL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleXL; + iirSampleXR = (iirSampleXR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleXR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleYL = (iirSampleYL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleYL; + iirSampleYR = (iirSampleYR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleYR; + inputSampleL *= gain; inputSampleR *= gain; gain = ((gain-1)*0.75)+1; + 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; + + iirSampleZL = (iirSampleZL * (1.0-iirAmount)) + (inputSampleL * iirAmount); inputSampleL = iirSampleZL; + iirSampleZR = (iirSampleZR * (1.0-iirAmount)) + (inputSampleR * iirAmount); inputSampleR = iirSampleZR; + 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; + //SubsOnly + break; + case 5: + case 6: + long double mid; mid = inputSampleL + inputSampleR; + long double side; side = inputSampleL - inputSampleR; + if (processing < 6) side = 0.0; + else mid = 0.0; //mono monitoring, or side-only monitoring + inputSampleL = (mid+side)/2.0; + inputSampleR = (mid-side)/2.0; + break; + case 7: + case 8: + case 9: + //Bandpass: changes in EQ are up in the variable defining, not here + inputSampleL = sin(inputSampleL); inputSampleR = sin(inputSampleR); + //encode Console5: good cleanness + + long double tempSampleL; tempSampleL = (inputSampleL * biquad[2]) + biquad[7]; + biquad[7] = (-tempSampleL * biquad[5]) + biquad[8]; + biquad[8] = (inputSampleL * biquad[4]) - (tempSampleL * biquad[6]); + inputSampleL = tempSampleL; //like mono AU, 7 and 8 store L channel + + long double tempSampleR; tempSampleR = (inputSampleR * biquad[2]) + biquad[9]; + biquad[9] = (-tempSampleR * biquad[5]) + biquad[10]; + biquad[10] = (inputSampleR * biquad[4]) - (tempSampleR * biquad[6]); + inputSampleR = tempSampleR; //note: 9 and 10 store the R channel + + 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; + //without this, you can get a NaN condition where it spits out DC offset at full blast! + inputSampleL = asin(inputSampleL); inputSampleR = asin(inputSampleR); + //amplitude aspect + break; + case 10: + case 11: + inputSampleL = sin(inputSampleL); + inputSampleR = sin(inputSampleR); + long double drySampleL; drySampleL = inputSampleL; + long double drySampleR; drySampleR = inputSampleR; //everything runs 'inside' Console + + allpasstemp = ax - 1; if (allpasstemp < 0 || allpasstemp > am) allpasstemp = am; + inputSampleL -= aL[allpasstemp]*0.5; aL[ax] = inputSampleL; inputSampleL *= 0.5; + inputSampleR -= aR[allpasstemp]*0.5; aR[ax] = inputSampleR; inputSampleR *= 0.5; + ax--; if (ax < 0 || ax > am) {ax = am;} + inputSampleL += (aL[ax]); + inputSampleR += (aR[ax]); + //a single Midiverb-style allpass + + if (processing == 10) {inputSampleL *= 0.125; inputSampleR *= 0.125;} + else {inputSampleL *= 0.25; inputSampleR *= 0.25;} + //Cans A suppresses the crossfeed more, Cans B makes it louder + + drySampleL += inputSampleR; + drySampleR += inputSampleL; //the crossfeed + + allpasstemp = dx - 1; if (allpasstemp < 0 || allpasstemp > dm) allpasstemp = dm; + inputSampleL -= dL[allpasstemp]*0.5; dL[dx] = inputSampleL; inputSampleL *= 0.5; + inputSampleR -= dR[allpasstemp]*0.5; dR[dx] = inputSampleR; inputSampleR *= 0.5; + dx--; if (dx < 0 || dx > dm) {dx = dm;} + inputSampleL += (dL[dx]); + inputSampleR += (dR[dx]); + //a single Midiverb-style allpass, which is stretching the previous one even more + + if (processing == 10) {inputSampleL *= 0.5; inputSampleR *= 0.5;} + else {inputSampleL *= 0.25; inputSampleR *= 0.25;} + //Cans A already had crossfeeds down, bloom is louder. Cans B sits on bloom more + + drySampleL += inputSampleL; + drySampleR += inputSampleR; //add the crossfeed and very faint extra verbyness + + inputSampleL = drySampleL; + inputSampleR = drySampleR; //and output our can-opened headphone feed + + if (inputSampleL > 1.0) inputSampleL = 1.0; if (inputSampleL < -1.0) inputSampleL = -1.0; inputSampleL = asin(inputSampleL); + if (inputSampleR > 1.0) inputSampleR = 1.0; if (inputSampleR < -1.0) inputSampleR = -1.0; inputSampleR = asin(inputSampleR); + //ConsoleBuss processing + break; + } + + + //begin Not Just Another Dither + if (processing == 1) { + inputSampleL = inputSampleL * 32768.0; //or 16 bit option + inputSampleR = inputSampleR * 32768.0; //or 16 bit option + } else { + inputSampleL = inputSampleL * 8388608.0; //for literally everything else + inputSampleR = inputSampleR * 8388608.0; //we will apply the 24 bit NJAD + } //on the not unreasonable assumption that we are very likely playing back on 24 bit DAC + //if we're not, then all we did was apply a Benford Realness function at 24 bits down. + + bool cutbinsL; cutbinsL = false; + bool cutbinsR; cutbinsR = false; + long double drySampleL; drySampleL = inputSampleL; + long double drySampleR; drySampleR = inputSampleR; + inputSampleL -= noiseShapingL; + inputSampleR -= noiseShapingR; + //NJAD L + long double benfordize; benfordize = floor(inputSampleL); + while (benfordize >= 1.0) benfordize /= 10; + while (benfordize < 1.0 && benfordize > 0.0000001) benfordize *= 10; + int hotbinA; hotbinA = floor(benfordize); + //hotbin becomes the Benford bin value for this number floored + long double totalA; totalA = 0; + if ((hotbinA > 0) && (hotbinA < 10)) + { + bynL[hotbinA] += 1; if (bynL[hotbinA] > 982) cutbinsL = true; + totalA += (301-bynL[1]); totalA += (176-bynL[2]); totalA += (125-bynL[3]); + totalA += (97-bynL[4]); totalA += (79-bynL[5]); totalA += (67-bynL[6]); + totalA += (58-bynL[7]); totalA += (51-bynL[8]); totalA += (46-bynL[9]); bynL[hotbinA] -= 1; + } else hotbinA = 10; + //produce total number- smaller is closer to Benford real + benfordize = ceil(inputSampleL); + while (benfordize >= 1.0) benfordize /= 10; + while (benfordize < 1.0 && benfordize > 0.0000001) benfordize *= 10; + int hotbinB; hotbinB = floor(benfordize); + //hotbin becomes the Benford bin value for this number ceiled + long double totalB; totalB = 0; + if ((hotbinB > 0) && (hotbinB < 10)) + { + bynL[hotbinB] += 1; if (bynL[hotbinB] > 982) cutbinsL = true; + totalB += (301-bynL[1]); totalB += (176-bynL[2]); totalB += (125-bynL[3]); + totalB += (97-bynL[4]); totalB += (79-bynL[5]); totalB += (67-bynL[6]); + totalB += (58-bynL[7]); totalB += (51-bynL[8]); totalB += (46-bynL[9]); bynL[hotbinB] -= 1; + } else hotbinB = 10; + //produce total number- smaller is closer to Benford real + long double outputSample; + if (totalA < totalB) {bynL[hotbinA] += 1; outputSample = floor(inputSampleL);} + else {bynL[hotbinB] += 1; outputSample = floor(inputSampleL+1);} + //assign the relevant one to the delay line + //and floor/ceil signal accordingly + if (cutbinsL) { + bynL[1] *= 0.99; bynL[2] *= 0.99; bynL[3] *= 0.99; bynL[4] *= 0.99; bynL[5] *= 0.99; + bynL[6] *= 0.99; bynL[7] *= 0.99; bynL[8] *= 0.99; bynL[9] *= 0.99; bynL[10] *= 0.99; + } + noiseShapingL += outputSample - drySampleL; + if (noiseShapingL > fabs(inputSampleL)) noiseShapingL = fabs(inputSampleL); + if (noiseShapingL < -fabs(inputSampleL)) noiseShapingL = -fabs(inputSampleL); + if (processing == 1) inputSampleL = outputSample / 32768.0; + else inputSampleL = outputSample / 8388608.0; + if (inputSampleL > 1.0) inputSampleL = 1.0; + if (inputSampleL < -1.0) inputSampleL = -1.0; + //finished NJAD L + + //NJAD R + benfordize = floor(inputSampleR); + while (benfordize >= 1.0) benfordize /= 10; + while (benfordize < 1.0 && benfordize > 0.0000001) benfordize *= 10; + hotbinA = floor(benfordize); + //hotbin becomes the Benford bin value for this number floored + totalA = 0; + if ((hotbinA > 0) && (hotbinA < 10)) + { + bynR[hotbinA] += 1; if (bynR[hotbinA] > 982) cutbinsR = true; + totalA += (301-bynR[1]); totalA += (176-bynR[2]); totalA += (125-bynR[3]); + totalA += (97-bynR[4]); totalA += (79-bynR[5]); totalA += (67-bynR[6]); + totalA += (58-bynR[7]); totalA += (51-bynR[8]); totalA += (46-bynR[9]); bynR[hotbinA] -= 1; + } else hotbinA = 10; + //produce total number- smaller is closer to Benford real + benfordize = ceil(inputSampleR); + while (benfordize >= 1.0) benfordize /= 10; + while (benfordize < 1.0 && benfordize > 0.0000001) benfordize *= 10; + hotbinB = floor(benfordize); + //hotbin becomes the Benford bin value for this number ceiled + totalB = 0; + if ((hotbinB > 0) && (hotbinB < 10)) + { + bynR[hotbinB] += 1; if (bynR[hotbinB] > 982) cutbinsR = true; + totalB += (301-bynR[1]); totalB += (176-bynR[2]); totalB += (125-bynR[3]); + totalB += (97-bynR[4]); totalB += (79-bynR[5]); totalB += (67-bynR[6]); + totalB += (58-bynR[7]); totalB += (51-bynR[8]); totalB += (46-bynR[9]); bynR[hotbinB] -= 1; + } else hotbinB = 10; + //produce total number- smaller is closer to Benford real + if (totalA < totalB) {bynR[hotbinA] += 1; outputSample = floor(inputSampleR);} + else {bynR[hotbinB] += 1; outputSample = floor(inputSampleR+1);} + //assign the relevant one to the delay line + //and floor/ceil signal accordingly + if (cutbinsR) { + bynR[1] *= 0.99; bynR[2] *= 0.99; bynR[3] *= 0.99; bynR[4] *= 0.99; bynR[5] *= 0.99; + bynR[6] *= 0.99; bynR[7] *= 0.99; bynR[8] *= 0.99; bynR[9] *= 0.99; bynR[10] *= 0.99; + } + noiseShapingR += outputSample - drySampleR; + if (noiseShapingR > fabs(inputSampleR)) noiseShapingR = fabs(inputSampleR); + if (noiseShapingR < -fabs(inputSampleR)) noiseShapingR = -fabs(inputSampleR); + if (processing == 1) inputSampleR = outputSample / 32768.0; + else inputSampleR = outputSample / 8388608.0; + if (inputSampleR > 1.0) inputSampleR = 1.0; + if (inputSampleR < -1.0) inputSampleR = -1.0; + //finished NJAD R + + //does not use 64 bit stereo floating point dither + + *out1 = inputSampleL; + *out2 = inputSampleR; + + *in1++; + *in2++; + *out1++; + *out2++; + } +} -- cgit v1.2.3