|
|
/* ========================================
* 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 * 24.999)+1; // +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 > 11){highRes = true; dtype -= 11;}
if (dtype > 11){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;
if (inputSampleL<1.2e-38 && -inputSampleL<1.2e-38) {
static int noisesource = 0;
//this declares a variable before anything else is compiled. It won't keep assigning
//it to 0 for every sample, it's as if the declaration doesn't exist in this context,
//but it lets me add this denormalization fix in a single place rather than updating
//it in three different locations. The variable isn't thread-safe but this is only
//a random seed and we can share it with whatever.
noisesource = noisesource % 1700021; noisesource++;
int residue = noisesource * noisesource;
residue = residue % 170003; residue *= residue;
residue = residue % 17011; residue *= residue;
residue = residue % 1709; residue *= residue;
residue = residue % 173; residue *= residue;
residue = residue % 17;
double applyresidue = residue;
applyresidue *= 0.00000001;
applyresidue *= 0.00000001;
inputSampleL = applyresidue;
}
if (inputSampleR<1.2e-38 && -inputSampleR<1.2e-38) {
static int noisesource = 0;
noisesource = noisesource % 1700021; noisesource++;
int residue = noisesource * noisesource;
residue = residue % 170003; residue *= residue;
residue = residue % 17011; residue *= residue;
residue = residue % 1709; residue *= residue;
residue = residue % 173; residue *= residue;
residue = residue % 17;
double applyresidue = residue;
applyresidue *= 0.00000001;
applyresidue *= 0.00000001;
inputSampleR = applyresidue;
//this denormalization routine produces a white noise at -300 dB which the noise
//shaping will interact with to produce a bipolar output, but the noise is actually
//all positive. That should stop any variables from going denormal, and the routine
//only kicks in if digital black is input. As a final touch, if you save to 24-bit
//the silence will return to being digital black again.
}
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:
currentDitherL = (rand()/(double)RAND_MAX);
inputSampleL += currentDitherL;
inputSampleL -= lastSampleL;
inputSampleL = floor(inputSampleL);
lastSampleL = currentDitherL;
currentDitherR = (rand()/(double)RAND_MAX);
inputSampleR += currentDitherR;
inputSampleR -= lastSampleR;
inputSampleR = floor(inputSampleR);
lastSampleR = currentDitherR;
//Paul dither
break;
case 5:
nsL[9] = nsL[8]; nsL[8] = nsL[7]; nsL[7] = nsL[6]; nsL[6] = nsL[5];
nsL[5] = nsL[4]; nsL[4] = nsL[3]; nsL[3] = nsL[2]; nsL[2] = nsL[1];
nsL[1] = nsL[0]; nsL[0] = (rand()/(double)RAND_MAX);
currentDitherL = (nsL[0] * 0.061);
currentDitherL -= (nsL[1] * 0.11);
currentDitherL += (nsL[8] * 0.126);
currentDitherL -= (nsL[7] * 0.23);
currentDitherL += (nsL[2] * 0.25);
currentDitherL -= (nsL[3] * 0.43);
currentDitherL += (nsL[6] * 0.5);
currentDitherL -= nsL[5];
currentDitherL += nsL[4];
//this sounds different from doing it in order of sample position
//cumulative tiny errors seem to build up even at this buss depth
//considerably more pronounced at 32 bit float.
//Therefore we add the most significant components LAST.
//trying to keep values on like exponents of the floating point value.
inputSampleL += currentDitherL;
inputSampleL = floor(inputSampleL);
//done with L
nsR[9] = nsR[8]; nsR[8] = nsR[7]; nsR[7] = nsR[6]; nsR[6] = nsR[5];
nsR[5] = nsR[4]; nsR[4] = nsR[3]; nsR[3] = nsR[2]; nsR[2] = nsR[1];
nsR[1] = nsR[0]; nsR[0] = (rand()/(double)RAND_MAX);
currentDitherR = (nsR[0] * 0.061);
currentDitherR -= (nsR[1] * 0.11);
currentDitherR += (nsR[8] * 0.126);
currentDitherR -= (nsR[7] * 0.23);
currentDitherR += (nsR[2] * 0.25);
currentDitherR -= (nsR[3] * 0.43);
currentDitherR += (nsR[6] * 0.5);
currentDitherR -= nsR[5];
currentDitherR += nsR[4];
//this sounds different from doing it in order of sample position
//cumulative tiny errors seem to build up even at this buss depth
//considerably more pronounced at 32 bit float.
//Therefore we add the most significant components LAST.
//trying to keep values on like exponents of the floating point value.
inputSampleR += currentDitherR;
inputSampleR = floor(inputSampleR);
//done with R
//DoublePaul dither
break;
case 6:
currentDitherL = (rand()/(double)RAND_MAX);
currentDitherR = (rand()/(double)RAND_MAX);
inputSampleL += currentDitherL;
inputSampleR += currentDitherR;
inputSampleL -= nsL[4];
inputSampleR -= nsR[4];
inputSampleL = floor(inputSampleL);
inputSampleR = floor(inputSampleR);
nsL[4] = nsL[3];
nsL[3] = nsL[2];
nsL[2] = nsL[1];
nsL[1] = currentDitherL;
nsR[4] = nsR[3];
nsR[3] = nsR[2];
nsR[2] = nsR[1];
nsR[1] = currentDitherR;
//Tape dither
break;
case 7:
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 8:
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 9:
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 10: //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 11: //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 12:
//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 13:
//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 14:
//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 * 24.999)+1; // +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 > 11){highRes = true; dtype -= 11;}
if (dtype > 11){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;
if (inputSampleL<1.2e-38 && -inputSampleL<1.2e-38) {
static int noisesource = 0;
//this declares a variable before anything else is compiled. It won't keep assigning
//it to 0 for every sample, it's as if the declaration doesn't exist in this context,
//but it lets me add this denormalization fix in a single place rather than updating
//it in three different locations. The variable isn't thread-safe but this is only
//a random seed and we can share it with whatever.
noisesource = noisesource % 1700021; noisesource++;
int residue = noisesource * noisesource;
residue = residue % 170003; residue *= residue;
residue = residue % 17011; residue *= residue;
residue = residue % 1709; residue *= residue;
residue = residue % 173; residue *= residue;
residue = residue % 17;
double applyresidue = residue;
applyresidue *= 0.00000001;
applyresidue *= 0.00000001;
inputSampleL = applyresidue;
}
if (inputSampleR<1.2e-38 && -inputSampleR<1.2e-38) {
static int noisesource = 0;
noisesource = noisesource % 1700021; noisesource++;
int residue = noisesource * noisesource;
residue = residue % 170003; residue *= residue;
residue = residue % 17011; residue *= residue;
residue = residue % 1709; residue *= residue;
residue = residue % 173; residue *= residue;
residue = residue % 17;
double applyresidue = residue;
applyresidue *= 0.00000001;
applyresidue *= 0.00000001;
inputSampleR = applyresidue;
//this denormalization routine produces a white noise at -300 dB which the noise
//shaping will interact with to produce a bipolar output, but the noise is actually
//all positive. That should stop any variables from going denormal, and the routine
//only kicks in if digital black is input. As a final touch, if you save to 24-bit
//the silence will return to being digital black again.
}
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:
currentDitherL = (rand()/(double)RAND_MAX);
inputSampleL += currentDitherL;
inputSampleL -= lastSampleL;
inputSampleL = floor(inputSampleL);
lastSampleL = currentDitherL;
currentDitherR = (rand()/(double)RAND_MAX);
inputSampleR += currentDitherR;
inputSampleR -= lastSampleR;
inputSampleR = floor(inputSampleR);
lastSampleR = currentDitherR;
//Paul dither
break;
case 5:
nsL[9] = nsL[8]; nsL[8] = nsL[7]; nsL[7] = nsL[6]; nsL[6] = nsL[5];
nsL[5] = nsL[4]; nsL[4] = nsL[3]; nsL[3] = nsL[2]; nsL[2] = nsL[1];
nsL[1] = nsL[0]; nsL[0] = (rand()/(double)RAND_MAX);
currentDitherL = (nsL[0] * 0.061);
currentDitherL -= (nsL[1] * 0.11);
currentDitherL += (nsL[8] * 0.126);
currentDitherL -= (nsL[7] * 0.23);
currentDitherL += (nsL[2] * 0.25);
currentDitherL -= (nsL[3] * 0.43);
currentDitherL += (nsL[6] * 0.5);
currentDitherL -= nsL[5];
currentDitherL += nsL[4];
//this sounds different from doing it in order of sample position
//cumulative tiny errors seem to build up even at this buss depth
//considerably more pronounced at 32 bit float.
//Therefore we add the most significant components LAST.
//trying to keep values on like exponents of the floating point value.
inputSampleL += currentDitherL;
inputSampleL = floor(inputSampleL);
//done with L
nsR[9] = nsR[8]; nsR[8] = nsR[7]; nsR[7] = nsR[6]; nsR[6] = nsR[5];
nsR[5] = nsR[4]; nsR[4] = nsR[3]; nsR[3] = nsR[2]; nsR[2] = nsR[1];
nsR[1] = nsR[0]; nsR[0] = (rand()/(double)RAND_MAX);
currentDitherR = (nsR[0] * 0.061);
currentDitherR -= (nsR[1] * 0.11);
currentDitherR += (nsR[8] * 0.126);
currentDitherR -= (nsR[7] * 0.23);
currentDitherR += (nsR[2] * 0.25);
currentDitherR -= (nsR[3] * 0.43);
currentDitherR += (nsR[6] * 0.5);
currentDitherR -= nsR[5];
currentDitherR += nsR[4];
//this sounds different from doing it in order of sample position
//cumulative tiny errors seem to build up even at this buss depth
//considerably more pronounced at 32 bit float.
//Therefore we add the most significant components LAST.
//trying to keep values on like exponents of the floating point value.
inputSampleR += currentDitherR;
inputSampleR = floor(inputSampleR);
//done with R
//DoublePaul dither
break;
case 6:
currentDitherL = (rand()/(double)RAND_MAX);
currentDitherR = (rand()/(double)RAND_MAX);
inputSampleL += currentDitherL;
inputSampleR += currentDitherR;
inputSampleL -= nsL[4];
inputSampleR -= nsR[4];
inputSampleL = floor(inputSampleL);
inputSampleR = floor(inputSampleR);
nsL[4] = nsL[3];
nsL[3] = nsL[2];
nsL[2] = nsL[1];
nsL[1] = currentDitherL;
nsR[4] = nsR[3];
nsR[3] = nsR[2];
nsR[2] = nsR[1];
nsR[1] = currentDitherR;
//Tape dither
break;
case 7:
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 8:
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 9:
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 10: //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 11: //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 12:
//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 13:
//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 14:
//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++;
}
}
|
