Ditherbox… and individual dithers

3 files changed, 2182 insertions, 0 deletions

diff --git a/plugins/MacVST/Ditherbox/source/Ditherbox.cpp b/plugins/MacVST/Ditherbox/source/Ditherbox.cpp
new file mode 100755
index 0000000..7e57c49
--- /dev/null
+++ b/plugins/MacVST/Ditherbox/source/Ditherbox.cpp
@@ -0,0 +1,285 @@
+/* ========================================
+ *  Ditherbox - Ditherbox.h
+ *  Copyright (c) 2016 airwindows, All rights reserved
+ * ======================================== */
+
+#ifndef __Ditherbox_H
+#include "Ditherbox.h"
+#endif
+
+AudioEffect* createEffectInstance(audioMasterCallback audioMaster) {return new Ditherbox(audioMaster);}
+
+Ditherbox::Ditherbox(audioMasterCallback audioMaster) :
+    AudioEffectX(audioMaster, kNumPrograms, kNumParameters)
+{
+	A = 0.825;
+
+	Position = 99999999;
+	contingentErrL = 0.0;
+	contingentErrR = 0.0;
+	bynL[0] = 1000;
+	bynL[1] = 301;
+	bynL[2] = 176;
+	bynL[3] = 125;
+	bynL[4] = 97;
+	bynL[5] = 79;
+	bynL[6] = 67;
+	bynL[7] = 58;
+	bynL[8] = 51;
+	bynL[9] = 46;
+	bynL[10] = 1000;
+	noiseShapingL = 0.0;
+	bynR[0] = 1000;
+	bynR[1] = 301;
+	bynR[2] = 176;
+	bynR[3] = 125;
+	bynR[4] = 97;
+	bynR[5] = 79;
+	bynR[6] = 67;
+	bynR[7] = 58;
+	bynR[8] = 51;
+	bynR[9] = 46;
+	bynR[10] = 1000;
+	noiseShapingR = 0.0;
+	
+	NSOddL = 0.0;
+	prevL = 0.0;
+	nsL[0] = 0;
+	nsL[1] = 0;
+	nsL[2] = 0;
+	nsL[3] = 0;
+	nsL[4] = 0;
+	nsL[5] = 0;
+	nsL[6] = 0;
+	nsL[7] = 0;
+	nsL[8] = 0;
+	nsL[9] = 0;
+	nsL[10] = 0;
+	nsL[11] = 0;
+	nsL[12] = 0;
+	nsL[13] = 0;
+	nsL[14] = 0;
+	nsL[15] = 0;
+	NSOddR = 0.0;
+	prevR = 0.0;
+	nsR[0] = 0;
+	nsR[1] = 0;
+	nsR[2] = 0;
+	nsR[3] = 0;
+	nsR[4] = 0;
+	nsR[5] = 0;
+	nsR[6] = 0;
+	nsR[7] = 0;
+	nsR[8] = 0;
+	nsR[9] = 0;
+	nsR[10] = 0;
+	nsR[11] = 0;
+	nsR[12] = 0;
+	nsR[13] = 0;
+	nsR[14] = 0;
+	nsR[15] = 0;
+
+	lastSampleL = 0.0;
+	outSampleL = 0.0;
+	lastSampleR = 0.0;
+	outSampleR = 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;
+	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;
+	//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
+}
+
+Ditherbox::~Ditherbox() {}
+VstInt32 Ditherbox::getVendorVersion () {return 1000;}
+void Ditherbox::setProgramName(char *name) {vst_strncpy (_programName, name, kVstMaxProgNameLen);}
+void Ditherbox::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 Ditherbox::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 Ditherbox::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 Ditherbox::setParameter(VstInt32 index, float value) {
+    switch (index) {
+        case kParamA: A = value; break;
+        default: throw; // unknown parameter, shouldn't happen!
+    }
+}
+
+float Ditherbox::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 Ditherbox::getParameterName(VstInt32 index, char *text) {
+    switch (index) {
+        case kParamA: vst_strncpy (text, "Type", kVstMaxParamStrLen); break;
+        default: break; // unknown parameter, shouldn't happen!
+    } //this is our labels for displaying in the VST host
+}
+
+void Ditherbox::getParameterDisplay(VstInt32 index, char *text) {
+    switch (index) {
+        case kParamA: switch((VstInt32)( A * 19.999 )) //0 to almost edge of # of params
+		{
+			case 0: vst_strncpy (text, "Trunc", kVstMaxParamStrLen); break;
+			case 1: vst_strncpy (text, "Flat", kVstMaxParamStrLen); break;
+			case 2: vst_strncpy (text, "TPDF", kVstMaxParamStrLen); break;
+			case 4: vst_strncpy (text, "HiGloss", kVstMaxParamStrLen); break;
+			case 5: vst_strncpy (text, "Vinyl", kVstMaxParamStrLen); break;
+			case 6: vst_strncpy (text, "Spatial", kVstMaxParamStrLen); break;
+			case 7: vst_strncpy (text, "Natural", kVstMaxParamStrLen); break;
+			case 8: vst_strncpy (text, "NJAD", kVstMaxParamStrLen); break;
+			case 9: vst_strncpy (text, "Trunc", kVstMaxParamStrLen); break;
+			case 10: vst_strncpy (text, "Flat", kVstMaxParamStrLen); break;
+			case 11: vst_strncpy (text, "TPDF", kVstMaxParamStrLen); break;
+			case 12: vst_strncpy (text, "HiGloss", kVstMaxParamStrLen); break;
+			case 13: vst_strncpy (text, "Vinyl", kVstMaxParamStrLen); break;
+			case 14: vst_strncpy (text, "Spatial", kVstMaxParamStrLen); break;
+			case 15: vst_strncpy (text, "Natural", kVstMaxParamStrLen); break;
+			case 16: vst_strncpy (text, "NJAD", kVstMaxParamStrLen); break;
+			case 17: vst_strncpy (text, "SlewOnl", kVstMaxParamStrLen); break;
+			case 18: vst_strncpy (text, "SubsOnl", kVstMaxParamStrLen); break;
+			case 19: vst_strncpy (text, "Silhoue", 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 Ditherbox::getParameterLabel(VstInt32 index, char *text) {
+    switch (index) {
+        case kParamA: switch((VstInt32)( A * 19.999 )) //0 to almost edge of # of params
+		{
+			case 0: vst_strncpy (text, "16", kVstMaxParamStrLen); break;
+			case 1: vst_strncpy (text, "16", kVstMaxParamStrLen); break;
+			case 2: vst_strncpy (text, "16", kVstMaxParamStrLen); break;
+			case 4: vst_strncpy (text, "16", kVstMaxParamStrLen); break;
+			case 5: vst_strncpy (text, "16", kVstMaxParamStrLen); break;
+			case 6: vst_strncpy (text, "16", kVstMaxParamStrLen); break;
+			case 7: vst_strncpy (text, "16", kVstMaxParamStrLen); break;
+			case 8: vst_strncpy (text, "16", kVstMaxParamStrLen); break;
+			case 9: vst_strncpy (text, "24", kVstMaxParamStrLen); break;
+			case 10: vst_strncpy (text, "24", kVstMaxParamStrLen); break;
+			case 11: vst_strncpy (text, "24", kVstMaxParamStrLen); break;
+			case 12: vst_strncpy (text, "24", kVstMaxParamStrLen); break;
+			case 13: vst_strncpy (text, "24", kVstMaxParamStrLen); break;
+			case 14: vst_strncpy (text, "24", kVstMaxParamStrLen); break;
+			case 15: vst_strncpy (text, "24", kVstMaxParamStrLen); break;
+			case 16: vst_strncpy (text, "24", kVstMaxParamStrLen); break;
+			case 17: vst_strncpy (text, "y", kVstMaxParamStrLen); break;
+			case 18: vst_strncpy (text, "y", kVstMaxParamStrLen); break;
+			case 19: vst_strncpy (text, "tte", 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
+}
+
+VstInt32 Ditherbox::canDo(char *text) 
+{ return (_canDo.find(text) == _canDo.end()) ? -1: 1; } // 1 = yes, -1 = no, 0 = don't know
+
+bool Ditherbox::getEffectName(char* name) {
+    vst_strncpy(name, "Ditherbox", kVstMaxProductStrLen); return true;
+}
+
+VstPlugCategory Ditherbox::getPlugCategory() {return kPlugCategEffect;}
+
+bool Ditherbox::getProductString(char* text) {
+  	vst_strncpy (text, "airwindows Ditherbox", kVstMaxProductStrLen); return true;
+}
+
+bool Ditherbox::getVendorString(char* text) {
+  	vst_strncpy (text, "airwindows", kVstMaxVendorStrLen); return true;
+}
diff --git a/plugins/MacVST/Ditherbox/source/Ditherbox.h b/plugins/MacVST/Ditherbox/source/Ditherbox.h
new file mode 100755
index 0000000..baf5bb1
--- /dev/null
+++ b/plugins/MacVST/Ditherbox/source/Ditherbox.h
@@ -0,0 +1,131 @@
+/* ========================================
+ *  Ditherbox - Ditherbox.h
+ *  Created 8/12/11 by SPIAdmin 
+ *  Copyright (c) 2011 __MyCompanyName__, All rights reserved
+ * ======================================== */
+
+#ifndef __Ditherbox_H
+#define __Ditherbox_H
+
+#ifndef __audioeffect__
+#include "audioeffectx.h"
+#endif
+
+#include <set>
+#include <string>
+#include <math.h>
+
+enum {
+	kParamA = 0,
+  kNumParameters = 1
+}; //
+
+const int kNumPrograms = 0;
+const int kNumInputs = 2;
+const int kNumOutputs = 2;
+const unsigned long kUniqueId = 'dith';    //Change this to what the AU identity is!
+
+class Ditherbox : 
+    public AudioEffectX 
+{
+public:
+    Ditherbox(audioMasterCallback audioMaster);
+    ~Ditherbox();
+    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 bynL[13];
+	double bynR[13];
+	long double noiseShapingL;
+	long double noiseShapingR;
+	double contingentErrL;
+	double contingentErrR;
+	int Position;
+	bool flip;
+	double NSOddL;
+	double prevL;
+	double nsL[16];
+	double NSOddR;
+	double prevR;
+	double nsR[16];
+	long double lastSampleL;
+	long double outSampleL;
+	long double lastSampleR;
+	long double outSampleR;
+	
+	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 iirSampleML;
+	double iirSampleNL;
+	double iirSampleOL;
+	double iirSamplePL;
+	double iirSampleQL;
+	double iirSampleRL;
+	double iirSampleSL;
+	double iirSampleTL;
+	double iirSampleUL;
+	double iirSampleVL;
+	double iirSampleWL;
+	double iirSampleXL;
+	double iirSampleYL;
+	double iirSampleZL;
+	
+	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 iirSampleMR;
+	double iirSampleNR;
+	double iirSampleOR;
+	double iirSamplePR;
+	double iirSampleQR;
+	double iirSampleRR;
+	double iirSampleSR;
+	double iirSampleTR;
+	double iirSampleUR;
+	double iirSampleVR;
+	double iirSampleWR;
+	double iirSampleXR;
+	double iirSampleYR;
+	double iirSampleZR;
+	
+    float A;
+};
+
+#endif
diff --git a/plugins/MacVST/Ditherbox/source/DitherboxProc.cpp b/plugins/MacVST/Ditherbox/source/DitherboxProc.cpp
new file mode 100755
index 0000000..feb5874
--- /dev/null
+++ b/plugins/MacVST/Ditherbox/source/DitherboxProc.cpp
@@ -0,0 +1,1766 @@
+/* ========================================
+ *  Ditherbox - Ditherbox.h
+ *  Copyright (c) 2016 airwindows, All rights reserved
+ * ======================================== */
+
+#ifndef __Ditherbox_H
+#include "Ditherbox.h"
+#endif
+
+void Ditherbox::processReplacing(float **inputs, float **outputs, VstInt32 sampleFrames) 
+{
+    float* in1  =  inputs[0];
+    float* in2  =  inputs[1];
+    float* out1 = outputs[0];
+    float* out2 = outputs[1];
+	
+	int dtype = (int)(A * 19.999); // +1 for Reaper bug workaround
+	long double overallscale = 1.0;
+	overallscale /= 44100.0;
+	overallscale *= getSampleRate();
+	long double iirAmount = 2250/44100.0;
+	long double gaintarget = 1.42;
+	long double gain;
+	iirAmount /= overallscale;
+	long double altAmount = 1.0 - iirAmount;
+	long double outputSampleL;
+	long double outputSampleR;
+	long double silhouette;
+	long double smoother;
+	long double bridgerectifier;
+	long double benfordize;
+	int hotbinA;
+	int hotbinB;
+	long double totalA;
+	long double totalB;
+	long double contingentRnd;
+	long double absSample;
+	long double contingent;
+	long double randyConstant = 1.61803398874989484820458683436563811772030917980576;
+	long double omegaConstant = 0.56714329040978387299996866221035554975381578718651;
+	long double expConstant = 0.06598803584531253707679018759684642493857704825279;
+	long double trim = 2.302585092994045684017991; //natural logarithm of 10
+	bool highRes = false;
+	bool dithering = true;
+	if (dtype > 8){highRes = true; dtype -= 8;}
+	if (dtype > 8){dithering = false; highRes = false;}
+	//follow up by switching high res back off for the monitoring	
+	
+    while (--sampleFrames >= 0)
+    {
+		long double inputSampleL = *in1;
+		long double inputSampleR = *in2;
+		float drySampleL = inputSampleL;
+		float drySampleR = inputSampleR;
+				
+		if (dtype == 8) {inputSampleL -= noiseShapingL; inputSampleR -= noiseShapingR;}
+
+		if (dithering) {inputSampleL *= 32768.0; inputSampleR *= 32768.0;}
+		//denormalizing as way of controlling insane detail boosting
+		if (highRes) {inputSampleL *= 256.0; inputSampleR *= 256.0;} //256 for 16/24 version
+		
+		switch (dtype)
+		{
+			case 1: 
+				inputSampleL = floor(inputSampleL);
+				inputSampleR = floor(inputSampleR);
+				//truncate
+				break;
+				
+			case 2: 
+				inputSampleL += (rand()/(double)RAND_MAX);
+				inputSampleL -= 0.5;
+				inputSampleL = floor(inputSampleL);
+				inputSampleR += (rand()/(double)RAND_MAX);
+				inputSampleR -= 0.5;
+				inputSampleR = floor(inputSampleR);
+				//flat dither
+				break;
+				
+			case 3:
+				inputSampleL += (rand()/(double)RAND_MAX);
+				inputSampleL += (rand()/(double)RAND_MAX);
+				inputSampleL -= 1.0;
+				inputSampleL = floor(inputSampleL);
+				inputSampleR += (rand()/(double)RAND_MAX);
+				inputSampleR += (rand()/(double)RAND_MAX);
+				inputSampleR -= 1.0;
+				inputSampleR = floor(inputSampleR);
+				//TPDF dither
+				break;
+				
+			case 4: 
+				Position += 1;
+				//Note- uses integer overflow as a 'mod' operator
+				hotbinA = Position * Position;
+				hotbinA = hotbinA % 170003; //% is C++ mod operator
+				hotbinA *= hotbinA;
+				hotbinA = hotbinA % 17011; //% is C++ mod operator
+				hotbinA *= hotbinA;
+				hotbinA = hotbinA % 1709; //% is C++ mod operator
+				hotbinA *= hotbinA;
+				hotbinA = hotbinA % 173; //% is C++ mod operator
+				hotbinA *= hotbinA;
+				hotbinA = hotbinA % 17;
+				hotbinA *= 0.0635;
+				if (flip) hotbinA = -hotbinA;
+				inputSampleL += hotbinA;
+				inputSampleR += hotbinA;
+				inputSampleL = floor(inputSampleL);
+				inputSampleR = floor(inputSampleR);
+				//Quadratic dither
+				break;
+				
+			case 5:
+				absSample = ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[0] += absSample; nsL[0] /= 2; absSample -= nsL[0];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[1] += absSample; nsL[1] /= 2; absSample -= nsL[1];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[2] += absSample; nsL[2] /= 2; absSample -= nsL[2];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[3] += absSample; nsL[3] /= 2; absSample -= nsL[3];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[4] += absSample; nsL[4] /= 2; absSample -= nsL[4];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[5] += absSample; nsL[5] /= 2; absSample -= nsL[5];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[6] += absSample; nsL[6] /= 2; absSample -= nsL[6];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[7] += absSample; nsL[7] /= 2; absSample -= nsL[7];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[8] += absSample; nsL[8] /= 2; absSample -= nsL[8];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[9] += absSample; nsL[9] /= 2; absSample -= nsL[9];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[10] += absSample; nsL[10] /= 2; absSample -= nsL[10];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[11] += absSample; nsL[11] /= 2; absSample -= nsL[11];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[12] += absSample; nsL[12] /= 2; absSample -= nsL[12];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[13] += absSample; nsL[13] /= 2; absSample -= nsL[13];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[14] += absSample; nsL[14] /= 2; absSample -= nsL[14];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[15] += absSample; nsL[15] /= 2; absSample -= nsL[15];
+				//install noise and then shape it
+				absSample += inputSampleL;
+				
+				if (NSOddL > 0) NSOddL -= 0.97;
+				if (NSOddL < 0) NSOddL += 0.97;
+				
+				NSOddL -= (NSOddL * NSOddL * NSOddL * 0.475);
+				
+				NSOddL += prevL;
+				absSample += (NSOddL*0.475);
+				prevL = floor(absSample) - inputSampleL;
+				inputSampleL = floor(absSample);
+				//TenNines dither L
+				
+				
+				absSample = ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[0] += absSample; nsR[0] /= 2; absSample -= nsR[0];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[1] += absSample; nsR[1] /= 2; absSample -= nsR[1];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[2] += absSample; nsR[2] /= 2; absSample -= nsR[2];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[3] += absSample; nsR[3] /= 2; absSample -= nsR[3];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[4] += absSample; nsR[4] /= 2; absSample -= nsR[4];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[5] += absSample; nsR[5] /= 2; absSample -= nsR[5];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[6] += absSample; nsR[6] /= 2; absSample -= nsR[6];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[7] += absSample; nsR[7] /= 2; absSample -= nsR[7];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[8] += absSample; nsR[8] /= 2; absSample -= nsR[8];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[9] += absSample; nsR[9] /= 2; absSample -= nsR[9];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[10] += absSample; nsR[10] /= 2; absSample -= nsR[10];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[11] += absSample; nsR[11] /= 2; absSample -= nsR[11];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[12] += absSample; nsR[12] /= 2; absSample -= nsR[12];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[13] += absSample; nsR[13] /= 2; absSample -= nsR[13];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[14] += absSample; nsR[14] /= 2; absSample -= nsR[14];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[15] += absSample; nsR[15] /= 2; absSample -= nsR[15];
+				//install noise and then shape it
+				absSample += inputSampleR;
+				
+				if (NSOddR > 0) NSOddR -= 0.97;
+				if (NSOddR < 0) NSOddR += 0.97;
+				
+				NSOddR -= (NSOddR * NSOddR * NSOddR * 0.475);
+				
+				NSOddR += prevR;
+				absSample += (NSOddR*0.475);
+				prevR = floor(absSample) - inputSampleR;
+				inputSampleR = floor(absSample);
+				//TenNines dither R
+				break;
+				
+			case 6: 
+				if (inputSampleL > 0) inputSampleL += 0.383;
+				if (inputSampleL < 0) inputSampleL -= 0.383;
+				if (inputSampleR > 0) inputSampleR += 0.383;
+				if (inputSampleR < 0) inputSampleR -= 0.383;
+				//adjusting to permit more information drug outta the noisefloor
+				
+				contingentRnd = (((rand()/(double)RAND_MAX)+(rand()/(double)RAND_MAX))-1.0) * randyConstant; //produce TPDF dist, scale
+				contingentRnd -= contingentErrL*omegaConstant; //include err
+				absSample = fabs(inputSampleL);
+				contingentErrL = absSample - floor(absSample); //get next err
+				contingent = contingentErrL * 2.0; //scale of quantization levels
+				if (contingent > 1.0) contingent = ((-contingent+2.0)*omegaConstant) + expConstant;
+				else contingent = (contingent * omegaConstant) + expConstant;
+				//zero is next to a quantization level, one is exactly between them
+				if (flip) contingentRnd = (contingentRnd * (1.0-contingent)) + contingent + 0.5;
+				else contingentRnd = (contingentRnd * (1.0-contingent)) - contingent + 0.5;
+				inputSampleL += (contingentRnd * contingent);
+				//Contingent Dither
+				inputSampleL = floor(inputSampleL);
+				
+				contingentRnd = (((rand()/(double)RAND_MAX)+(rand()/(double)RAND_MAX))-1.0) * randyConstant; //produce TPDF dist, scale
+				contingentRnd -= contingentErrR*omegaConstant; //include err
+				absSample = fabs(inputSampleR);
+				contingentErrR = absSample - floor(absSample); //get next err
+				contingent = contingentErrR * 2.0; //scale of quantization levels
+				if (contingent > 1.0) contingent = ((-contingent+2.0)*omegaConstant) + expConstant;
+				else contingent = (contingent * omegaConstant) + expConstant;
+				//zero is next to a quantization level, one is exactly between them
+				if (flip) contingentRnd = (contingentRnd * (1.0-contingent)) + contingent + 0.5;
+				else contingentRnd = (contingentRnd * (1.0-contingent)) - contingent + 0.5;
+				inputSampleR += (contingentRnd * contingent);
+				//Contingent Dither
+				inputSampleR = floor(inputSampleR);
+				
+				//note: this does not dither for values exactly the same as 16 bit values-
+				//which forces the dither to gate at 0.0. It goes to digital black,
+				//and does a teeny parallel-compression thing when almost at digital black.
+				break;
+				
+			case 7: //this one is the original Naturalize
+				if (inputSampleL > 0) inputSampleL += (0.3333333333);
+				if (inputSampleL < 0) inputSampleL -= (0.3333333333);
+				inputSampleL += (rand()/(double)RAND_MAX)*0.6666666666;
+				
+				if (inputSampleR > 0) inputSampleR += (0.3333333333);
+				if (inputSampleR < 0) inputSampleR -= (0.3333333333);
+				inputSampleR += (rand()/(double)RAND_MAX)*0.6666666666;
+				
+				//begin L
+				benfordize = floor(inputSampleL);
+				while (benfordize >= 1.0) {benfordize /= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				hotbinA = floor(benfordize);
+				//hotbin becomes the Benford bin value for this number floored
+				totalA = 0;
+				if ((hotbinA > 0) && (hotbinA < 10))
+				{
+					bynL[hotbinA] += 1;
+					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;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				hotbinB = floor(benfordize);
+				//hotbin becomes the Benford bin value for this number ceiled
+				totalB = 0;
+				if ((hotbinB > 0) && (hotbinB < 10))
+				{
+					bynL[hotbinB] += 1;
+					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
+				
+				if (totalA < totalB)
+				{
+					bynL[hotbinA] += 1;
+					inputSampleL = floor(inputSampleL);
+				}
+				else
+				{
+					bynL[hotbinB] += 1;
+					inputSampleL = ceil(inputSampleL);
+				}
+				//assign the relevant one to the delay line
+				//and floor/ceil signal accordingly
+				
+				totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
+				totalA /= 1000;
+				if (totalA = 0) totalA = 1;
+				bynL[1] /= totalA;
+				bynL[2] /= totalA;
+				bynL[3] /= totalA;
+				bynL[4] /= totalA;
+				bynL[5] /= totalA;
+				bynL[6] /= totalA;
+				bynL[7] /= totalA;
+				bynL[8] /= totalA;
+				bynL[9] /= totalA;
+				bynL[10] /= 2; //catchall for garbage data
+				//end L
+				
+				//begin R
+				benfordize = floor(inputSampleR);
+				while (benfordize >= 1.0) {benfordize /= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {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;
+					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;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {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;
+					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;
+					inputSampleR = floor(inputSampleR);
+				}
+				else
+				{
+					bynR[hotbinB] += 1;
+					inputSampleR = ceil(inputSampleR);
+				}
+				//assign the relevant one to the delay line
+				//and floor/ceil signal accordingly
+				
+				totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
+				totalA /= 1000;
+				if (totalA = 0) totalA = 1;
+				bynR[1] /= totalA;
+				bynR[2] /= totalA;
+				bynR[3] /= totalA;
+				bynR[4] /= totalA;
+				bynR[5] /= totalA;
+				bynR[6] /= totalA;
+				bynR[7] /= totalA;
+				bynR[8] /= totalA;
+				bynR[9] /= totalA;
+				bynR[10] /= 2; //catchall for garbage data
+				//end R
+				break;
+				
+			case 8: //this one is the Not Just Another Dither
+				
+				//begin L
+				benfordize = floor(inputSampleL);
+				while (benfordize >= 1.0) {benfordize /= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				hotbinA = floor(benfordize);
+				//hotbin becomes the Benford bin value for this number floored
+				totalA = 0;
+				if ((hotbinA > 0) && (hotbinA < 10))
+				{
+					bynL[hotbinA] += 1;
+					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;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				hotbinB = floor(benfordize);
+				//hotbin becomes the Benford bin value for this number ceiled
+				totalB = 0;
+				if ((hotbinB > 0) && (hotbinB < 10))
+				{
+					bynL[hotbinB] += 1;
+					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
+				
+				if (totalA < totalB)
+				{
+					bynL[hotbinA] += 1;
+					inputSampleL = floor(inputSampleL);
+				}
+				else
+				{
+					bynL[hotbinB] += 1;
+					inputSampleL = ceil(inputSampleL);
+				}
+				//assign the relevant one to the delay line
+				//and floor/ceil signal accordingly
+				
+				totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
+				totalA /= 1000;
+				if (totalA = 0) totalA = 1;
+				bynL[1] /= totalA;
+				bynL[2] /= totalA;
+				bynL[3] /= totalA;
+				bynL[4] /= totalA;
+				bynL[5] /= totalA;
+				bynL[6] /= totalA;
+				bynL[7] /= totalA;
+				bynL[8] /= totalA;
+				bynL[9] /= totalA;
+				bynL[10] /= 2; //catchall for garbage data
+				//end L
+				
+				//begin R
+				benfordize = floor(inputSampleR);
+				while (benfordize >= 1.0) {benfordize /= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {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;
+					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;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {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;
+					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;
+					inputSampleR = floor(inputSampleR);
+				}
+				else
+				{
+					bynR[hotbinB] += 1;
+					inputSampleR = ceil(inputSampleR);
+				}
+				//assign the relevant one to the delay line
+				//and floor/ceil signal accordingly
+				
+				totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
+				totalA /= 1000;
+				if (totalA = 0) totalA = 1;
+				bynR[1] /= totalA;
+				bynR[2] /= totalA;
+				bynR[3] /= totalA;
+				bynR[4] /= totalA;
+				bynR[5] /= totalA;
+				bynR[6] /= totalA;
+				bynR[7] /= totalA;
+				bynR[8] /= totalA;
+				bynR[9] /= totalA;
+				bynR[10] /= 2; //catchall for garbage data
+				//end R
+				break;
+				
+			case 9: 
+				//slew only
+				outputSampleL = (inputSampleL - lastSampleL)*trim;
+				outputSampleR = (inputSampleR - lastSampleR)*trim;
+				lastSampleL = inputSampleL;
+				lastSampleR = inputSampleR;
+				if (outputSampleL > 1.0) outputSampleL = 1.0;
+				if (outputSampleR > 1.0) outputSampleR = 1.0;
+				if (outputSampleL < -1.0) outputSampleL = -1.0;		
+				if (outputSampleR < -1.0) outputSampleR = -1.0;		
+				inputSampleL = outputSampleL;
+				inputSampleR = outputSampleR;
+				break;
+				
+			case 10: 
+				//subs only
+				gain = gaintarget;
+				
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				iirSampleAL = (iirSampleAL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleAL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleBL = (iirSampleBL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleBL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleCL = (iirSampleCL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleCL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleDL = (iirSampleDL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleDL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleEL = (iirSampleEL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleEL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleFL = (iirSampleFL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleFL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleGL = (iirSampleGL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleGL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleHL = (iirSampleHL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleHL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleIL = (iirSampleIL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleIL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleJL = (iirSampleJL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleJL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleKL = (iirSampleKL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleKL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleLL = (iirSampleLL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleLL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleML = (iirSampleML * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleML;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleNL = (iirSampleNL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleNL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleOL = (iirSampleOL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleOL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSamplePL = (iirSamplePL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSamplePL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleQL = (iirSampleQL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleQL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleRL = (iirSampleRL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleRL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleSL = (iirSampleSL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleSL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleTL = (iirSampleTL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleTL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleUL = (iirSampleUL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleUL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleVL = (iirSampleVL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleVL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleWL = (iirSampleWL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleWL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleXL = (iirSampleXL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleXL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleYL = (iirSampleYL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleYL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleZL = (iirSampleZL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleZL;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				gain = gaintarget;
+				
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				iirSampleAR = (iirSampleAR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleAR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleBR = (iirSampleBR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleBR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleCR = (iirSampleCR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleCR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleDR = (iirSampleDR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleDR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleER = (iirSampleER * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleER;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleFR = (iirSampleFR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleFR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleGR = (iirSampleGR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleGR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleHR = (iirSampleHR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleHR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleIR = (iirSampleIR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleIR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleJR = (iirSampleJR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleJR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleKR = (iirSampleKR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleKR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleLR = (iirSampleLR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleLR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleMR = (iirSampleMR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleMR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleNR = (iirSampleNR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleNR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleOR = (iirSampleOR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleOR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSamplePR = (iirSamplePR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSamplePR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleQR = (iirSampleQR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleQR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleRR = (iirSampleRR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleRR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleSR = (iirSampleSR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleSR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleTR = (iirSampleTR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleTR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleUR = (iirSampleUR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleUR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleVR = (iirSampleVR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleVR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleWR = (iirSampleWR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleWR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleXR = (iirSampleXR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleXR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleYR = (iirSampleYR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleYR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleZR = (iirSampleZR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleZR;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;		
+				break;
+				
+			case 11: 
+				//silhouette
+				//begin L
+				bridgerectifier = fabs(inputSampleL)*1.57079633;
+				if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633;
+				bridgerectifier = 1.0-cos(bridgerectifier);
+				if (inputSampleL > 0.0) inputSampleL = bridgerectifier;
+				else inputSampleL = -bridgerectifier;
+				
+				silhouette = rand()/(double)RAND_MAX;
+				silhouette -= 0.5;
+				silhouette *= 2.0;
+				silhouette *= fabs(inputSampleL);
+				
+				smoother = rand()/(double)RAND_MAX;
+				smoother -= 0.5;
+				smoother *= 2.0;
+				smoother *= fabs(lastSampleL);
+				lastSampleL = inputSampleL;
+				
+				silhouette += smoother;
+				
+				bridgerectifier = fabs(silhouette)*1.57079633;
+				if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633;
+				bridgerectifier = sin(bridgerectifier);
+				if (silhouette > 0.0) silhouette = bridgerectifier;
+				else silhouette = -bridgerectifier;
+				
+				inputSampleL = (silhouette + outSampleL) / 2.0;
+				outSampleL = silhouette;
+				//end L
+				
+				//begin R				
+				bridgerectifier = fabs(inputSampleR)*1.57079633;
+				if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633;
+				bridgerectifier = 1.0-cos(bridgerectifier);
+				if (inputSampleR > 0.0) inputSampleR = bridgerectifier;
+				else inputSampleR = -bridgerectifier;
+				
+				silhouette = rand()/(double)RAND_MAX;
+				silhouette -= 0.5;
+				silhouette *= 2.0;
+				silhouette *= fabs(inputSampleR);
+				
+				smoother = rand()/(double)RAND_MAX;
+				smoother -= 0.5;
+				smoother *= 2.0;
+				smoother *= fabs(lastSampleR);
+				lastSampleR = inputSampleR;
+				
+				silhouette += smoother;
+				
+				bridgerectifier = fabs(silhouette)*1.57079633;
+				if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633;
+				bridgerectifier = sin(bridgerectifier);
+				if (silhouette > 0.0) silhouette = bridgerectifier;
+				else silhouette = -bridgerectifier;
+				
+				inputSampleR = (silhouette + outSampleR) / 2.0;
+				outSampleR = silhouette;
+				//end R
+				break;
+		}
+		
+		flip = !flip;
+		//several dithers use this
+		
+		if (highRes) {inputSampleL /= 256.0; inputSampleR /= 256.0;} //256 for 16/24 version
+		if (dithering) {inputSampleL /= 32768.0; inputSampleR /= 32768.0;}
+		
+		if (dtype == 8) {
+			noiseShapingL += inputSampleL - drySampleL;
+			noiseShapingR += inputSampleR - drySampleR;
+		}
+				
+		*out1 = inputSampleL;
+		*out2 = inputSampleR;
+
+		*in1++;
+		*in2++;
+		*out1++;
+		*out2++;
+    }
+}
+
+void Ditherbox::processDoubleReplacing(double **inputs, double **outputs, VstInt32 sampleFrames) 
+{
+    double* in1  =  inputs[0];
+    double* in2  =  inputs[1];
+    double* out1 = outputs[0];
+    double* out2 = outputs[1];
+	
+	int dtype = (int)(A * 19.999); // +1 for Reaper bug workaround
+	long double overallscale = 1.0;
+	overallscale /= 44100.0;
+	overallscale *= getSampleRate();
+	long double iirAmount = 2250/44100.0;
+	long double gaintarget = 1.42;
+	long double gain;
+	iirAmount /= overallscale;
+	long double altAmount = 1.0 - iirAmount;
+	long double outputSampleL;
+	long double outputSampleR;
+	long double silhouette;
+	long double smoother;
+	long double bridgerectifier;
+	long double benfordize;
+	int hotbinA;
+	int hotbinB;
+	long double totalA;
+	long double totalB;
+	long double contingentRnd;
+	long double absSample;
+	long double contingent;
+	long double randyConstant = 1.61803398874989484820458683436563811772030917980576;
+	long double omegaConstant = 0.56714329040978387299996866221035554975381578718651;
+	long double expConstant = 0.06598803584531253707679018759684642493857704825279;
+	long double trim = 2.302585092994045684017991; //natural logarithm of 10
+	bool highRes = false;
+	bool dithering = true;
+	if (dtype > 8){highRes = true; dtype -= 8;}
+	if (dtype > 8){dithering = false; highRes = false;}
+	//follow up by switching high res back off for the monitoring	
+	
+    while (--sampleFrames >= 0)
+    {
+		long double inputSampleL = *in1;
+		long double inputSampleR = *in2;
+		double drySampleL = inputSampleL;
+		double drySampleR = inputSampleR;
+		
+		if (dtype == 8) {inputSampleL -= noiseShapingL; inputSampleR -= noiseShapingR;}
+		
+		if (dithering) {inputSampleL *= 32768.0; inputSampleR *= 32768.0;}
+		//denormalizing as way of controlling insane detail boosting
+		if (highRes) {inputSampleL *= 256.0; inputSampleR *= 256.0;} //256 for 16/24 version
+		
+		switch (dtype)
+		{
+			case 1: 
+				inputSampleL = floor(inputSampleL);
+				inputSampleR = floor(inputSampleR);
+				//truncate
+				break;
+				
+			case 2: 
+				inputSampleL += (rand()/(double)RAND_MAX);
+				inputSampleL -= 0.5;
+				inputSampleL = floor(inputSampleL);
+				inputSampleR += (rand()/(double)RAND_MAX);
+				inputSampleR -= 0.5;
+				inputSampleR = floor(inputSampleR);
+				//flat dither
+				break;
+				
+			case 3:
+				inputSampleL += (rand()/(double)RAND_MAX);
+				inputSampleL += (rand()/(double)RAND_MAX);
+				inputSampleL -= 1.0;
+				inputSampleL = floor(inputSampleL);
+				inputSampleR += (rand()/(double)RAND_MAX);
+				inputSampleR += (rand()/(double)RAND_MAX);
+				inputSampleR -= 1.0;
+				inputSampleR = floor(inputSampleR);
+				//TPDF dither
+				break;
+				
+			case 4: 
+				Position += 1;
+				//Note- uses integer overflow as a 'mod' operator
+				hotbinA = Position * Position;
+				hotbinA = hotbinA % 170003; //% is C++ mod operator
+				hotbinA *= hotbinA;
+				hotbinA = hotbinA % 17011; //% is C++ mod operator
+				hotbinA *= hotbinA;
+				hotbinA = hotbinA % 1709; //% is C++ mod operator
+				hotbinA *= hotbinA;
+				hotbinA = hotbinA % 173; //% is C++ mod operator
+				hotbinA *= hotbinA;
+				hotbinA = hotbinA % 17;
+				hotbinA *= 0.0635;
+				if (flip) hotbinA = -hotbinA;
+				inputSampleL += hotbinA;
+				inputSampleR += hotbinA;
+				inputSampleL = floor(inputSampleL);
+				inputSampleR = floor(inputSampleR);
+				//Quadratic dither
+				break;
+				
+			case 5:
+				absSample = ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[0] += absSample; nsL[0] /= 2; absSample -= nsL[0];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[1] += absSample; nsL[1] /= 2; absSample -= nsL[1];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[2] += absSample; nsL[2] /= 2; absSample -= nsL[2];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[3] += absSample; nsL[3] /= 2; absSample -= nsL[3];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[4] += absSample; nsL[4] /= 2; absSample -= nsL[4];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[5] += absSample; nsL[5] /= 2; absSample -= nsL[5];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[6] += absSample; nsL[6] /= 2; absSample -= nsL[6];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[7] += absSample; nsL[7] /= 2; absSample -= nsL[7];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[8] += absSample; nsL[8] /= 2; absSample -= nsL[8];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[9] += absSample; nsL[9] /= 2; absSample -= nsL[9];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[10] += absSample; nsL[10] /= 2; absSample -= nsL[10];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[11] += absSample; nsL[11] /= 2; absSample -= nsL[11];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[12] += absSample; nsL[12] /= 2; absSample -= nsL[12];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[13] += absSample; nsL[13] /= 2; absSample -= nsL[13];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[14] += absSample; nsL[14] /= 2; absSample -= nsL[14];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsL[15] += absSample; nsL[15] /= 2; absSample -= nsL[15];
+				//install noise and then shape it
+				absSample += inputSampleL;
+				
+				if (NSOddL > 0) NSOddL -= 0.97;
+				if (NSOddL < 0) NSOddL += 0.97;
+				
+				NSOddL -= (NSOddL * NSOddL * NSOddL * 0.475);
+				
+				NSOddL += prevL;
+				absSample += (NSOddL*0.475);
+				prevL = floor(absSample) - inputSampleL;
+				inputSampleL = floor(absSample);
+				//TenNines dither L
+				
+				
+				absSample = ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[0] += absSample; nsR[0] /= 2; absSample -= nsR[0];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[1] += absSample; nsR[1] /= 2; absSample -= nsR[1];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[2] += absSample; nsR[2] /= 2; absSample -= nsR[2];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[3] += absSample; nsR[3] /= 2; absSample -= nsR[3];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[4] += absSample; nsR[4] /= 2; absSample -= nsR[4];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[5] += absSample; nsR[5] /= 2; absSample -= nsR[5];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[6] += absSample; nsR[6] /= 2; absSample -= nsR[6];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[7] += absSample; nsR[7] /= 2; absSample -= nsR[7];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[8] += absSample; nsR[8] /= 2; absSample -= nsR[8];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[9] += absSample; nsR[9] /= 2; absSample -= nsR[9];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[10] += absSample; nsR[10] /= 2; absSample -= nsR[10];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[11] += absSample; nsR[11] /= 2; absSample -= nsR[11];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[12] += absSample; nsR[12] /= 2; absSample -= nsR[12];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[13] += absSample; nsR[13] /= 2; absSample -= nsR[13];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[14] += absSample; nsR[14] /= 2; absSample -= nsR[14];
+				absSample += ((rand()/(double)RAND_MAX) - 0.5);
+				nsR[15] += absSample; nsR[15] /= 2; absSample -= nsR[15];
+				//install noise and then shape it
+				absSample += inputSampleR;
+				
+				if (NSOddR > 0) NSOddR -= 0.97;
+				if (NSOddR < 0) NSOddR += 0.97;
+				
+				NSOddR -= (NSOddR * NSOddR * NSOddR * 0.475);
+				
+				NSOddR += prevR;
+				absSample += (NSOddR*0.475);
+				prevR = floor(absSample) - inputSampleR;
+				inputSampleR = floor(absSample);
+				//TenNines dither R
+				break;
+				
+			case 6: 
+				if (inputSampleL > 0) inputSampleL += 0.383;
+				if (inputSampleL < 0) inputSampleL -= 0.383;
+				if (inputSampleR > 0) inputSampleR += 0.383;
+				if (inputSampleR < 0) inputSampleR -= 0.383;
+				//adjusting to permit more information drug outta the noisefloor
+				
+				contingentRnd = (((rand()/(double)RAND_MAX)+(rand()/(double)RAND_MAX))-1.0) * randyConstant; //produce TPDF dist, scale
+				contingentRnd -= contingentErrL*omegaConstant; //include err
+				absSample = fabs(inputSampleL);
+				contingentErrL = absSample - floor(absSample); //get next err
+				contingent = contingentErrL * 2.0; //scale of quantization levels
+				if (contingent > 1.0) contingent = ((-contingent+2.0)*omegaConstant) + expConstant;
+				else contingent = (contingent * omegaConstant) + expConstant;
+				//zero is next to a quantization level, one is exactly between them
+				if (flip) contingentRnd = (contingentRnd * (1.0-contingent)) + contingent + 0.5;
+				else contingentRnd = (contingentRnd * (1.0-contingent)) - contingent + 0.5;
+				inputSampleL += (contingentRnd * contingent);
+				//Contingent Dither
+				inputSampleL = floor(inputSampleL);
+				
+				contingentRnd = (((rand()/(double)RAND_MAX)+(rand()/(double)RAND_MAX))-1.0) * randyConstant; //produce TPDF dist, scale
+				contingentRnd -= contingentErrR*omegaConstant; //include err
+				absSample = fabs(inputSampleR);
+				contingentErrR = absSample - floor(absSample); //get next err
+				contingent = contingentErrR * 2.0; //scale of quantization levels
+				if (contingent > 1.0) contingent = ((-contingent+2.0)*omegaConstant) + expConstant;
+				else contingent = (contingent * omegaConstant) + expConstant;
+				//zero is next to a quantization level, one is exactly between them
+				if (flip) contingentRnd = (contingentRnd * (1.0-contingent)) + contingent + 0.5;
+				else contingentRnd = (contingentRnd * (1.0-contingent)) - contingent + 0.5;
+				inputSampleR += (contingentRnd * contingent);
+				//Contingent Dither
+				inputSampleR = floor(inputSampleR);
+				
+				//note: this does not dither for values exactly the same as 16 bit values-
+				//which forces the dither to gate at 0.0. It goes to digital black,
+				//and does a teeny parallel-compression thing when almost at digital black.
+				break;
+				
+			case 7: //this one is the original Naturalize
+				if (inputSampleL > 0) inputSampleL += (0.3333333333);
+				if (inputSampleL < 0) inputSampleL -= (0.3333333333);
+				inputSampleL += (rand()/(double)RAND_MAX)*0.6666666666;
+				
+				if (inputSampleR > 0) inputSampleR += (0.3333333333);
+				if (inputSampleR < 0) inputSampleR -= (0.3333333333);
+				inputSampleR += (rand()/(double)RAND_MAX)*0.6666666666;
+				
+				//begin L
+				benfordize = floor(inputSampleL);
+				while (benfordize >= 1.0) {benfordize /= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				hotbinA = floor(benfordize);
+				//hotbin becomes the Benford bin value for this number floored
+				totalA = 0;
+				if ((hotbinA > 0) && (hotbinA < 10))
+				{
+					bynL[hotbinA] += 1;
+					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;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				hotbinB = floor(benfordize);
+				//hotbin becomes the Benford bin value for this number ceiled
+				totalB = 0;
+				if ((hotbinB > 0) && (hotbinB < 10))
+				{
+					bynL[hotbinB] += 1;
+					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
+				
+				if (totalA < totalB)
+				{
+					bynL[hotbinA] += 1;
+					inputSampleL = floor(inputSampleL);
+				}
+				else
+				{
+					bynL[hotbinB] += 1;
+					inputSampleL = ceil(inputSampleL);
+				}
+				//assign the relevant one to the delay line
+				//and floor/ceil signal accordingly
+				
+				totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
+				totalA /= 1000;
+				if (totalA = 0) totalA = 1;
+				bynL[1] /= totalA;
+				bynL[2] /= totalA;
+				bynL[3] /= totalA;
+				bynL[4] /= totalA;
+				bynL[5] /= totalA;
+				bynL[6] /= totalA;
+				bynL[7] /= totalA;
+				bynL[8] /= totalA;
+				bynL[9] /= totalA;
+				bynL[10] /= 2; //catchall for garbage data
+				//end L
+				
+				//begin R
+				benfordize = floor(inputSampleR);
+				while (benfordize >= 1.0) {benfordize /= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {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;
+					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;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {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;
+					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;
+					inputSampleR = floor(inputSampleR);
+				}
+				else
+				{
+					bynR[hotbinB] += 1;
+					inputSampleR = ceil(inputSampleR);
+				}
+				//assign the relevant one to the delay line
+				//and floor/ceil signal accordingly
+				
+				totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
+				totalA /= 1000;
+				if (totalA = 0) totalA = 1;
+				bynR[1] /= totalA;
+				bynR[2] /= totalA;
+				bynR[3] /= totalA;
+				bynR[4] /= totalA;
+				bynR[5] /= totalA;
+				bynR[6] /= totalA;
+				bynR[7] /= totalA;
+				bynR[8] /= totalA;
+				bynR[9] /= totalA;
+				bynR[10] /= 2; //catchall for garbage data
+				//end R
+				break;
+				
+			case 8: //this one is the Not Just Another Dither
+				
+				//begin L
+				benfordize = floor(inputSampleL);
+				while (benfordize >= 1.0) {benfordize /= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				hotbinA = floor(benfordize);
+				//hotbin becomes the Benford bin value for this number floored
+				totalA = 0;
+				if ((hotbinA > 0) && (hotbinA < 10))
+				{
+					bynL[hotbinA] += 1;
+					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;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				hotbinB = floor(benfordize);
+				//hotbin becomes the Benford bin value for this number ceiled
+				totalB = 0;
+				if ((hotbinB > 0) && (hotbinB < 10))
+				{
+					bynL[hotbinB] += 1;
+					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
+				
+				if (totalA < totalB)
+				{
+					bynL[hotbinA] += 1;
+					inputSampleL = floor(inputSampleL);
+				}
+				else
+				{
+					bynL[hotbinB] += 1;
+					inputSampleL = ceil(inputSampleL);
+				}
+				//assign the relevant one to the delay line
+				//and floor/ceil signal accordingly
+				
+				totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
+				totalA /= 1000;
+				if (totalA = 0) totalA = 1;
+				bynL[1] /= totalA;
+				bynL[2] /= totalA;
+				bynL[3] /= totalA;
+				bynL[4] /= totalA;
+				bynL[5] /= totalA;
+				bynL[6] /= totalA;
+				bynL[7] /= totalA;
+				bynL[8] /= totalA;
+				bynL[9] /= totalA;
+				bynL[10] /= 2; //catchall for garbage data
+				//end L
+				
+				//begin R
+				benfordize = floor(inputSampleR);
+				while (benfordize >= 1.0) {benfordize /= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {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;
+					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;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {benfordize *= 10;}
+				if (benfordize < 1.0) {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;
+					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;
+					inputSampleR = floor(inputSampleR);
+				}
+				else
+				{
+					bynR[hotbinB] += 1;
+					inputSampleR = ceil(inputSampleR);
+				}
+				//assign the relevant one to the delay line
+				//and floor/ceil signal accordingly
+				
+				totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
+				totalA /= 1000;
+				if (totalA = 0) totalA = 1;
+				bynR[1] /= totalA;
+				bynR[2] /= totalA;
+				bynR[3] /= totalA;
+				bynR[4] /= totalA;
+				bynR[5] /= totalA;
+				bynR[6] /= totalA;
+				bynR[7] /= totalA;
+				bynR[8] /= totalA;
+				bynR[9] /= totalA;
+				bynR[10] /= 2; //catchall for garbage data
+				//end R
+				break;
+				
+			case 9: 
+				//slew only
+				outputSampleL = (inputSampleL - lastSampleL)*trim;
+				outputSampleR = (inputSampleR - lastSampleR)*trim;
+				lastSampleL = inputSampleL;
+				lastSampleR = inputSampleR;
+				if (outputSampleL > 1.0) outputSampleL = 1.0;
+				if (outputSampleR > 1.0) outputSampleR = 1.0;
+				if (outputSampleL < -1.0) outputSampleL = -1.0;		
+				if (outputSampleR < -1.0) outputSampleR = -1.0;		
+				inputSampleL = outputSampleL;
+				inputSampleR = outputSampleR;
+				break;
+				
+			case 10: 
+				//subs only
+				gain = gaintarget;
+				
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				iirSampleAL = (iirSampleAL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleAL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleBL = (iirSampleBL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleBL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleCL = (iirSampleCL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleCL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleDL = (iirSampleDL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleDL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleEL = (iirSampleEL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleEL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleFL = (iirSampleFL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleFL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleGL = (iirSampleGL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleGL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleHL = (iirSampleHL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleHL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleIL = (iirSampleIL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleIL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleJL = (iirSampleJL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleJL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleKL = (iirSampleKL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleKL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleLL = (iirSampleLL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleLL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleML = (iirSampleML * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleML;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleNL = (iirSampleNL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleNL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleOL = (iirSampleOL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleOL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSamplePL = (iirSamplePL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSamplePL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleQL = (iirSampleQL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleQL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleRL = (iirSampleRL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleRL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleSL = (iirSampleSL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleSL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleTL = (iirSampleTL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleTL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleUL = (iirSampleUL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleUL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleVL = (iirSampleVL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleVL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleWL = (iirSampleWL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleWL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleXL = (iirSampleXL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleXL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleYL = (iirSampleYL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleYL;
+				inputSampleL *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				iirSampleZL = (iirSampleZL * altAmount) + (inputSampleL * iirAmount); inputSampleL = iirSampleZL;
+				if (inputSampleL > 1.0) inputSampleL = 1.0;
+				if (inputSampleL < -1.0) inputSampleL = -1.0;
+				gain = gaintarget;
+				
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				iirSampleAR = (iirSampleAR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleAR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleBR = (iirSampleBR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleBR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleCR = (iirSampleCR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleCR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleDR = (iirSampleDR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleDR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleER = (iirSampleER * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleER;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleFR = (iirSampleFR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleFR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleGR = (iirSampleGR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleGR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleHR = (iirSampleHR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleHR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleIR = (iirSampleIR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleIR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleJR = (iirSampleJR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleJR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleKR = (iirSampleKR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleKR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleLR = (iirSampleLR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleLR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleMR = (iirSampleMR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleMR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleNR = (iirSampleNR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleNR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleOR = (iirSampleOR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleOR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSamplePR = (iirSamplePR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSamplePR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleQR = (iirSampleQR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleQR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleRR = (iirSampleRR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleRR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleSR = (iirSampleSR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleSR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleTR = (iirSampleTR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleTR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleUR = (iirSampleUR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleUR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleVR = (iirSampleVR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleVR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleWR = (iirSampleWR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleWR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleXR = (iirSampleXR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleXR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleYR = (iirSampleYR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleYR;
+				inputSampleR *= gain; gain = ((gain-1)*0.75)+1;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;
+				iirSampleZR = (iirSampleZR * altAmount) + (inputSampleR * iirAmount); inputSampleR = iirSampleZR;
+				if (inputSampleR > 1.0) inputSampleR = 1.0;
+				if (inputSampleR < -1.0) inputSampleR = -1.0;		
+				break;
+				
+			case 11: 
+				//silhouette
+				//begin L
+				bridgerectifier = fabs(inputSampleL)*1.57079633;
+				if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633;
+				bridgerectifier = 1.0-cos(bridgerectifier);
+				if (inputSampleL > 0.0) inputSampleL = bridgerectifier;
+				else inputSampleL = -bridgerectifier;
+				
+				silhouette = rand()/(double)RAND_MAX;
+				silhouette -= 0.5;
+				silhouette *= 2.0;
+				silhouette *= fabs(inputSampleL);
+				
+				smoother = rand()/(double)RAND_MAX;
+				smoother -= 0.5;
+				smoother *= 2.0;
+				smoother *= fabs(lastSampleL);
+				lastSampleL = inputSampleL;
+				
+				silhouette += smoother;
+				
+				bridgerectifier = fabs(silhouette)*1.57079633;
+				if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633;
+				bridgerectifier = sin(bridgerectifier);
+				if (silhouette > 0.0) silhouette = bridgerectifier;
+				else silhouette = -bridgerectifier;
+				
+				inputSampleL = (silhouette + outSampleL) / 2.0;
+				outSampleL = silhouette;
+				//end L
+				
+				//begin R				
+				bridgerectifier = fabs(inputSampleR)*1.57079633;
+				if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633;
+				bridgerectifier = 1.0-cos(bridgerectifier);
+				if (inputSampleR > 0.0) inputSampleR = bridgerectifier;
+				else inputSampleR = -bridgerectifier;
+				
+				silhouette = rand()/(double)RAND_MAX;
+				silhouette -= 0.5;
+				silhouette *= 2.0;
+				silhouette *= fabs(inputSampleR);
+				
+				smoother = rand()/(double)RAND_MAX;
+				smoother -= 0.5;
+				smoother *= 2.0;
+				smoother *= fabs(lastSampleR);
+				lastSampleR = inputSampleR;
+				
+				silhouette += smoother;
+				
+				bridgerectifier = fabs(silhouette)*1.57079633;
+				if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633;
+				bridgerectifier = sin(bridgerectifier);
+				if (silhouette > 0.0) silhouette = bridgerectifier;
+				else silhouette = -bridgerectifier;
+				
+				inputSampleR = (silhouette + outSampleR) / 2.0;
+				outSampleR = silhouette;
+				//end R
+				break;
+		}
+		
+		flip = !flip;
+		//several dithers use this
+		
+		if (highRes) {inputSampleL /= 256.0; inputSampleR /= 256.0;} //256 for 16/24 version
+		if (dithering) {inputSampleL /= 32768.0; inputSampleR /= 32768.0;}
+		
+		if (dtype == 8) {
+			noiseShapingL += inputSampleL - drySampleL;
+			noiseShapingR += inputSampleR - drySampleR;
+		}
+		
+		*out1 = inputSampleL;
+		*out2 = inputSampleR;
+
+		*in1++;
+		*in2++;
+		*out1++;
+		*out2++;
+    }
+}