trnr/tlib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

clang format

Browse Source
This commit is contained in:
Chris
2023-08-12 09:49:26 +02:00
parent 537fba98c4
commit 044f42374b
22 changed files with 3090 additions and 3216 deletions
Download Patch File Download Diff File Expand all files Collapse all files

177
clip/aw_cliponly2.h
View File

@@ -5,96 +5,117 @@ namespace trnr {
// Clipper based on ClipOnly2 by Chris Johnson
class aw_cliponly2 {
public:
aw_cliponly2() {
samplerate = 44100;
aw_cliponly2()
{
samplerate = 44100;
lastSampleL = 0.0;
wasPosClipL = false;
wasNegClipL = false;
lastSampleR = 0.0;
wasPosClipR = false;
wasNegClipR = false;
for (int x = 0; x < 16; x++) {intermediateL[x] = 0.0; intermediateR[x] = 0.0;}
//this is reset: values being initialized only once. Startup values, whatever they are.
}
lastSampleL = 0.0;
wasPosClipL = false;
wasNegClipL = false;
lastSampleR = 0.0;
wasPosClipR = false;
wasNegClipR = false;
for (int x = 0; x < 16; x++) {
intermediateL[x] = 0.0;
intermediateR[x] = 0.0;
}
// this is reset: values being initialized only once. Startup values, whatever they are.
}
void set_samplerate(double _samplerate) {
samplerate = _samplerate;
}
void set_samplerate(double _samplerate) { samplerate = _samplerate; }
void process_block(double** inputs, double** outputs, long sample_frames) {
double* in1 = inputs[0];
double* in2 = inputs[1];
double* out1 = outputs[0];
double* out2 = outputs[1];
void process_block(double** inputs, double** outputs, long sample_frames)
{
double* in1 = inputs[0];
double* in2 = inputs[1];
double* out1 = outputs[0];
double* out2 = outputs[1];
double overallscale = 1.0;
overallscale /= 44100.0;
overallscale *= samplerate;
int spacing = floor(overallscale); //should give us working basic scaling, usually 2 or 4
if (spacing < 1) spacing = 1; if (spacing > 16) spacing = 16;
while (--sample_frames >= 0)
{
double inputSampleL = *in1;
double inputSampleR = *in2;
//begin ClipOnly2 stereo as a little, compressed chunk that can be dropped into code
if (inputSampleL > 4.0) inputSampleL = 4.0; if (inputSampleL < -4.0) inputSampleL = -4.0;
if (wasPosClipL == true) { //current will be over
if (inputSampleL<lastSampleL) lastSampleL=0.7058208+(inputSampleL*0.2609148);
else lastSampleL = 0.2491717+(lastSampleL*0.7390851);
} wasPosClipL = false;
if (inputSampleL>0.9549925859) {wasPosClipL=true;inputSampleL=0.7058208+(lastSampleL*0.2609148);}
if (wasNegClipL == true) { //current will be -over
if (inputSampleL > lastSampleL) lastSampleL=-0.7058208+(inputSampleL*0.2609148);
else lastSampleL=-0.2491717+(lastSampleL*0.7390851);
} wasNegClipL = false;
if (inputSampleL<-0.9549925859) {wasNegClipL=true;inputSampleL=-0.7058208+(lastSampleL*0.2609148);}
intermediateL[spacing] = inputSampleL;
inputSampleL = lastSampleL; //Latency is however many samples equals one 44.1k sample
for (int x = spacing; x > 0; x--) intermediateL[x-1] = intermediateL[x];
lastSampleL = intermediateL[0]; //run a little buffer to handle this
if (inputSampleR > 4.0) inputSampleR = 4.0; if (inputSampleR < -4.0) inputSampleR = -4.0;
if (wasPosClipR == true) { //current will be over
if (inputSampleR<lastSampleR) lastSampleR=0.7058208+(inputSampleR*0.2609148);
else lastSampleR = 0.2491717+(lastSampleR*0.7390851);
} wasPosClipR = false;
if (inputSampleR>0.9549925859) {wasPosClipR=true;inputSampleR=0.7058208+(lastSampleR*0.2609148);}
if (wasNegClipR == true) { //current will be -over
if (inputSampleR > lastSampleR) lastSampleR=-0.7058208+(inputSampleR*0.2609148);
else lastSampleR=-0.2491717+(lastSampleR*0.7390851);
} wasNegClipR = false;
if (inputSampleR<-0.9549925859) {wasNegClipR=true;inputSampleR=-0.7058208+(lastSampleR*0.2609148);}
intermediateR[spacing] = inputSampleR;
inputSampleR = lastSampleR; //Latency is however many samples equals one 44.1k sample
for (int x = spacing; x > 0; x--) intermediateR[x-1] = intermediateR[x];
lastSampleR = intermediateR[0]; //run a little buffer to handle this
//end ClipOnly2 stereo as a little, compressed chunk that can be dropped into code
*out1 = inputSampleL;
*out2 = inputSampleR;
double overallscale = 1.0;
overallscale /= 44100.0;
overallscale *= samplerate;
in1++;
in2++;
out1++;
out2++;
}
}
int spacing = floor(overallscale); // should give us working basic scaling, usually 2 or 4
if (spacing < 1) spacing = 1;
if (spacing > 16) spacing = 16;
while (--sample_frames >= 0) {
double inputSampleL = *in1;
double inputSampleR = *in2;
// begin ClipOnly2 stereo as a little, compressed chunk that can be dropped into code
if (inputSampleL > 4.0) inputSampleL = 4.0;
if (inputSampleL < -4.0) inputSampleL = -4.0;
if (wasPosClipL == true) { // current will be over
if (inputSampleL < lastSampleL) lastSampleL = 0.7058208 + (inputSampleL * 0.2609148);
else lastSampleL = 0.2491717 + (lastSampleL * 0.7390851);
}
wasPosClipL = false;
if (inputSampleL > 0.9549925859) {
wasPosClipL = true;
inputSampleL = 0.7058208 + (lastSampleL * 0.2609148);
}
if (wasNegClipL == true) { // current will be -over
if (inputSampleL > lastSampleL) lastSampleL = -0.7058208 + (inputSampleL * 0.2609148);
else lastSampleL = -0.2491717 + (lastSampleL * 0.7390851);
}
wasNegClipL = false;
if (inputSampleL < -0.9549925859) {
wasNegClipL = true;
inputSampleL = -0.7058208 + (lastSampleL * 0.2609148);
}
intermediateL[spacing] = inputSampleL;
inputSampleL = lastSampleL; // Latency is however many samples equals one 44.1k sample
for (int x = spacing; x > 0; x--) intermediateL[x - 1] = intermediateL[x];
lastSampleL = intermediateL[0]; // run a little buffer to handle this
if (inputSampleR > 4.0) inputSampleR = 4.0;
if (inputSampleR < -4.0) inputSampleR = -4.0;
if (wasPosClipR == true) { // current will be over
if (inputSampleR < lastSampleR) lastSampleR = 0.7058208 + (inputSampleR * 0.2609148);
else lastSampleR = 0.2491717 + (lastSampleR * 0.7390851);
}
wasPosClipR = false;
if (inputSampleR > 0.9549925859) {
wasPosClipR = true;
inputSampleR = 0.7058208 + (lastSampleR * 0.2609148);
}
if (wasNegClipR == true) { // current will be -over
if (inputSampleR > lastSampleR) lastSampleR = -0.7058208 + (inputSampleR * 0.2609148);
else lastSampleR = -0.2491717 + (lastSampleR * 0.7390851);
}
wasNegClipR = false;
if (inputSampleR < -0.9549925859) {
wasNegClipR = true;
inputSampleR = -0.7058208 + (lastSampleR * 0.2609148);
}
intermediateR[spacing] = inputSampleR;
inputSampleR = lastSampleR; // Latency is however many samples equals one 44.1k sample
for (int x = spacing; x > 0; x--) intermediateR[x - 1] = intermediateR[x];
lastSampleR = intermediateR[0]; // run a little buffer to handle this
// end ClipOnly2 stereo as a little, compressed chunk that can be dropped into code
*out1 = inputSampleL;
*out2 = inputSampleR;
in1++;
in2++;
out1++;
out2++;
}
}
private:
double samplerate;
double samplerate;
double lastSampleL;
double lastSampleL;
double intermediateL[16];
bool wasPosClipL;
bool wasNegClipL;
double lastSampleR;
double intermediateR[16];
bool wasPosClipR;
bool wasNegClipR; //Stereo ClipOnly2
//default stuff
bool wasNegClipR; // Stereo ClipOnly2
// default stuff
};
}
} // namespace trnr

161
clip/aw_clipsoftly.h
View File

@@ -6,92 +6,103 @@ namespace trnr {
// soft clipper based on ClipSoftly by Chris Johnson
class aw_clipsoftly {
public:
aw_clipsoftly() {
samplerate = 44100;
aw_clipsoftly()
{
samplerate = 44100;
lastSampleL = 0.0;
lastSampleR = 0.0;
for (int x = 0; x < 16; x++) {intermediateL[x] = 0.0; intermediateR[x] = 0.0;}
fpdL = 1.0; while (fpdL < 16386) fpdL = rand()*UINT32_MAX;
fpdR = 1.0; while (fpdR < 16386) fpdR = rand()*UINT32_MAX;
//this is reset: values being initialized only once. Startup values, whatever they are.
}
lastSampleL = 0.0;
lastSampleR = 0.0;
for (int x = 0; x < 16; x++) {
intermediateL[x] = 0.0;
intermediateR[x] = 0.0;
}
fpdL = 1.0;
while (fpdL < 16386) fpdL = rand() * UINT32_MAX;
fpdR = 1.0;
while (fpdR < 16386) fpdR = rand() * UINT32_MAX;
// this is reset: values being initialized only once. Startup values, whatever they are.
}
void set_samplerate(double _samplerate) {
samplerate = _samplerate;
}
void set_samplerate(double _samplerate) { samplerate = _samplerate; }
void process_block(double** inputs, double** outputs, long sample_frames) {
double* in1 = inputs[0];
double* in2 = inputs[1];
double* out1 = outputs[0];
double* out2 = outputs[1];
void process_block(double** inputs, double** outputs, long sample_frames)
{
double* in1 = inputs[0];
double* in2 = inputs[1];
double* out1 = outputs[0];
double* out2 = outputs[1];
double overallscale = 1.0;
overallscale /= 44100.0;
overallscale *= samplerate;
int spacing = floor(overallscale); //should give us working basic scaling, usually 2 or 4
if (spacing < 1) spacing = 1; if (spacing > 16) spacing = 16;
while (--sample_frames >= 0)
{
double inputSampleL = *in1;
double inputSampleR = *in2;
if (fabs(inputSampleL)<1.18e-23) inputSampleL = fpdL * 1.18e-17;
if (fabs(inputSampleR)<1.18e-23) inputSampleR = fpdR * 1.18e-17;
double softSpeed = fabs(inputSampleL);
if (softSpeed < 1.0) softSpeed = 1.0; else softSpeed = 1.0/softSpeed;
if (inputSampleL > 1.57079633) inputSampleL = 1.57079633;
if (inputSampleL < -1.57079633) inputSampleL = -1.57079633;
inputSampleL = sin(inputSampleL)*0.9549925859; //scale to what cliponly uses
inputSampleL = (inputSampleL*softSpeed)+(lastSampleL*(1.0-softSpeed));
softSpeed = fabs(inputSampleR);
if (softSpeed < 1.0) softSpeed = 1.0; else softSpeed = 1.0/softSpeed;
if (inputSampleR > 1.57079633) inputSampleR = 1.57079633;
if (inputSampleR < -1.57079633) inputSampleR = -1.57079633;
inputSampleR = sin(inputSampleR)*0.9549925859; //scale to what cliponly uses
inputSampleR = (inputSampleR*softSpeed)+(lastSampleR*(1.0-softSpeed));
intermediateL[spacing] = inputSampleL;
inputSampleL = lastSampleL; //Latency is however many samples equals one 44.1k sample
for (int x = spacing; x > 0; x--) intermediateL[x-1] = intermediateL[x];
lastSampleL = intermediateL[0]; //run a little buffer to handle this
intermediateR[spacing] = inputSampleR;
inputSampleR = lastSampleR; //Latency is however many samples equals one 44.1k sample
for (int x = spacing; x > 0; x--) intermediateR[x-1] = intermediateR[x];
lastSampleR = intermediateR[0]; //run a little buffer to handle this
//begin 64 bit stereo floating point dither
//int expon; frexp((double)inputSampleL, &expon);
fpdL ^= fpdL << 13; fpdL ^= fpdL >> 17; fpdL ^= fpdL << 5;
//inputSampleL += ((double(fpdL)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62));
//frexp((double)inputSampleR, &expon);
fpdR ^= fpdR << 13; fpdR ^= fpdR >> 17; fpdR ^= fpdR << 5;
//inputSampleR += ((double(fpdR)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62));
//end 64 bit stereo floating point dither
*out1 = inputSampleL;
*out2 = inputSampleR;
double overallscale = 1.0;
overallscale /= 44100.0;
overallscale *= samplerate;
int spacing = floor(overallscale); // should give us working basic scaling, usually 2 or 4
if (spacing < 1) spacing = 1;
if (spacing > 16) spacing = 16;
in1++;
in2++;
out1++;
out2++;
}
}
while (--sample_frames >= 0) {
double inputSampleL = *in1;
double inputSampleR = *in2;
if (fabs(inputSampleL) < 1.18e-23) inputSampleL = fpdL * 1.18e-17;
if (fabs(inputSampleR) < 1.18e-23) inputSampleR = fpdR * 1.18e-17;
double softSpeed = fabs(inputSampleL);
if (softSpeed < 1.0) softSpeed = 1.0;
else softSpeed = 1.0 / softSpeed;
if (inputSampleL > 1.57079633) inputSampleL = 1.57079633;
if (inputSampleL < -1.57079633) inputSampleL = -1.57079633;
inputSampleL = sin(inputSampleL) * 0.9549925859; // scale to what cliponly uses
inputSampleL = (inputSampleL * softSpeed) + (lastSampleL * (1.0 - softSpeed));
softSpeed = fabs(inputSampleR);
if (softSpeed < 1.0) softSpeed = 1.0;
else softSpeed = 1.0 / softSpeed;
if (inputSampleR > 1.57079633) inputSampleR = 1.57079633;
if (inputSampleR < -1.57079633) inputSampleR = -1.57079633;
inputSampleR = sin(inputSampleR) * 0.9549925859; // scale to what cliponly uses
inputSampleR = (inputSampleR * softSpeed) + (lastSampleR * (1.0 - softSpeed));
intermediateL[spacing] = inputSampleL;
inputSampleL = lastSampleL; // Latency is however many samples equals one 44.1k sample
for (int x = spacing; x > 0; x--) intermediateL[x - 1] = intermediateL[x];
lastSampleL = intermediateL[0]; // run a little buffer to handle this
intermediateR[spacing] = inputSampleR;
inputSampleR = lastSampleR; // Latency is however many samples equals one 44.1k sample
for (int x = spacing; x > 0; x--) intermediateR[x - 1] = intermediateR[x];
lastSampleR = intermediateR[0]; // run a little buffer to handle this
// begin 64 bit stereo floating point dither
// int expon; frexp((double)inputSampleL, &expon);
fpdL ^= fpdL << 13;
fpdL ^= fpdL >> 17;
fpdL ^= fpdL << 5;
// inputSampleL += ((double(fpdL)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62));
// frexp((double)inputSampleR, &expon);
fpdR ^= fpdR << 13;
fpdR ^= fpdR >> 17;
fpdR ^= fpdR << 5;
// inputSampleR += ((double(fpdR)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62));
// end 64 bit stereo floating point dither
*out1 = inputSampleL;
*out2 = inputSampleR;
in1++;
in2++;
out1++;
out2++;
}
}
private:
double samplerate;
double samplerate;
double lastSampleL;
double lastSampleL;
double intermediateL[16];
double lastSampleR;
double intermediateR[16];
uint32_t fpdL;
uint32_t fpdR;
//default stuff
// default stuff
};
}
} // namespace trnr

344
clip/aw_tube2.h
View File

@@ -6,188 +6,202 @@ namespace trnr {
// modeled tube preamp based on tube2 by Chris Johnson
class aw_tube2 {
public:
aw_tube2() {
samplerate = 44100;
aw_tube2()
{
samplerate = 44100;
A = 0.5;
B = 0.5;
previousSampleA = 0.0;
previousSampleB = 0.0;
previousSampleC = 0.0;
previousSampleD = 0.0;
previousSampleE = 0.0;
previousSampleF = 0.0;
fpdL = 1.0; while (fpdL < 16386) fpdL = rand()*UINT32_MAX;
fpdR = 1.0; while (fpdR < 16386) fpdR = rand()*UINT32_MAX;
//this is reset: values being initialized only once. Startup values, whatever they are.
}
A = 0.5;
B = 0.5;
previousSampleA = 0.0;
previousSampleB = 0.0;
previousSampleC = 0.0;
previousSampleD = 0.0;
previousSampleE = 0.0;
previousSampleF = 0.0;
fpdL = 1.0;
while (fpdL < 16386) fpdL = rand() * UINT32_MAX;
fpdR = 1.0;
while (fpdR < 16386) fpdR = rand() * UINT32_MAX;
// this is reset: values being initialized only once. Startup values, whatever they are.
}
void set_input(double value) {
A = clamp(value);
}
void set_input(double value) { A = clamp(value); }
void set_tube(double value) {
B = clamp(value);
}
void set_tube(double value) { B = clamp(value); }
void set_samplerate(double _samplerate) {
samplerate = _samplerate;
}
void set_samplerate(double _samplerate) { samplerate = _samplerate; }
void process_block(double **inputs, double **outputs, long sampleframes) {
double* in1 = inputs[0];
double* in2 = inputs[1];
double* out1 = outputs[0];
double* out2 = outputs[1];
void process_block(double** inputs, double** outputs, long sampleframes)
{
double* in1 = inputs[0];
double* in2 = inputs[1];
double* out1 = outputs[0];
double* out2 = outputs[1];
double overallscale = 1.0;
overallscale /= 44100.0;
overallscale *= samplerate;
double inputPad = A;
double iterations = 1.0-B;
int powerfactor = (9.0*iterations)+1;
double asymPad = (double)powerfactor;
double gainscaling = 1.0/(double)(powerfactor+1);
double outputscaling = 1.0 + (1.0/(double)(powerfactor));
while (--sampleframes >= 0)
{
double inputSampleL = *in1;
double inputSampleR = *in2;
if (fabs(inputSampleL)<1.18e-23) inputSampleL = fpdL * 1.18e-17;
if (fabs(inputSampleR)<1.18e-23) inputSampleR = fpdR * 1.18e-17;
if (inputPad < 1.0) {
inputSampleL *= inputPad;
inputSampleR *= inputPad;
}
if (overallscale > 1.9) {
double stored = inputSampleL;
inputSampleL += previousSampleA; previousSampleA = stored; inputSampleL *= 0.5;
stored = inputSampleR;
inputSampleR += previousSampleB; previousSampleB = stored; inputSampleR *= 0.5;
} //for high sample rates on this plugin we are going to do a simple average
if (inputSampleL > 1.0) inputSampleL = 1.0;
if (inputSampleL < -1.0) inputSampleL = -1.0;
if (inputSampleR > 1.0) inputSampleR = 1.0;
if (inputSampleR < -1.0) inputSampleR = -1.0;
//flatten bottom, point top of sine waveshaper L
inputSampleL /= asymPad;
double sharpen = -inputSampleL;
if (sharpen > 0.0) sharpen = 1.0+sqrt(sharpen);
else sharpen = 1.0-sqrt(-sharpen);
inputSampleL -= inputSampleL*fabs(inputSampleL)*sharpen*0.25;
//this will take input from exactly -1.0 to 1.0 max
inputSampleL *= asymPad;
//flatten bottom, point top of sine waveshaper R
inputSampleR /= asymPad;
sharpen = -inputSampleR;
if (sharpen > 0.0) sharpen = 1.0+sqrt(sharpen);
else sharpen = 1.0-sqrt(-sharpen);
inputSampleR -= inputSampleR*fabs(inputSampleR)*sharpen*0.25;
//this will take input from exactly -1.0 to 1.0 max
inputSampleR *= asymPad;
//end first asym section: later boosting can mitigate the extreme
//softclipping of one side of the wave
//and we are asym clipping more when Tube is cranked, to compensate
//original Tube algorithm: powerfactor widens the more linear region of the wave
double factor = inputSampleL; //Left channel
for (int x = 0; x < powerfactor; x++) factor *= inputSampleL;
if ((powerfactor % 2 == 1) && (inputSampleL != 0.0)) factor = (factor/inputSampleL)*fabs(inputSampleL);
factor *= gainscaling;
inputSampleL -= factor;
inputSampleL *= outputscaling;
factor = inputSampleR; //Right channel
for (int x = 0; x < powerfactor; x++) factor *= inputSampleR;
if ((powerfactor % 2 == 1) && (inputSampleR != 0.0)) factor = (factor/inputSampleR)*fabs(inputSampleR);
factor *= gainscaling;
inputSampleR -= factor;
inputSampleR *= outputscaling;
if (overallscale > 1.9) {
double stored = inputSampleL;
inputSampleL += previousSampleC; previousSampleC = stored; inputSampleL *= 0.5;
stored = inputSampleR;
inputSampleR += previousSampleD; previousSampleD = stored; inputSampleR *= 0.5;
} //for high sample rates on this plugin we are going to do a simple average
//end original Tube. Now we have a boosted fat sound peaking at 0dB exactly
//hysteresis and spiky fuzz L
double slew = previousSampleE - inputSampleL;
if (overallscale > 1.9) {
double stored = inputSampleL;
inputSampleL += previousSampleE; previousSampleE = stored; inputSampleL *= 0.5;
} else previousSampleE = inputSampleL; //for this, need previousSampleC always
if (slew > 0.0) slew = 1.0+(sqrt(slew)*0.5);
else slew = 1.0-(sqrt(-slew)*0.5);
inputSampleL -= inputSampleL*fabs(inputSampleL)*slew*gainscaling;
//reusing gainscaling that's part of another algorithm
if (inputSampleL > 0.52) inputSampleL = 0.52;
if (inputSampleL < -0.52) inputSampleL = -0.52;
inputSampleL *= 1.923076923076923;
//hysteresis and spiky fuzz R
slew = previousSampleF - inputSampleR;
if (overallscale > 1.9) {
double stored = inputSampleR;
inputSampleR += previousSampleF; previousSampleF = stored; inputSampleR *= 0.5;
} else previousSampleF = inputSampleR; //for this, need previousSampleC always
if (slew > 0.0) slew = 1.0+(sqrt(slew)*0.5);
else slew = 1.0-(sqrt(-slew)*0.5);
inputSampleR -= inputSampleR*fabs(inputSampleR)*slew*gainscaling;
//reusing gainscaling that's part of another algorithm
if (inputSampleR > 0.52) inputSampleR = 0.52;
if (inputSampleR < -0.52) inputSampleR = -0.52;
inputSampleR *= 1.923076923076923;
//end hysteresis and spiky fuzz section
//begin 64 bit stereo floating point dither
//int expon; frexp((double)inputSampleL, &expon);
fpdL ^= fpdL << 13; fpdL ^= fpdL >> 17; fpdL ^= fpdL << 5;
//inputSampleL += ((double(fpdL)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62));
//frexp((double)inputSampleR, &expon);
fpdR ^= fpdR << 13; fpdR ^= fpdR >> 17; fpdR ^= fpdR << 5;
//inputSampleR += ((double(fpdR)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62));
//end 64 bit stereo floating point dither
*out1 = inputSampleL;
*out2 = inputSampleR;
double overallscale = 1.0;
overallscale /= 44100.0;
overallscale *= samplerate;
in1++;
in2++;
out1++;
out2++;
}
}
double inputPad = A;
double iterations = 1.0 - B;
int powerfactor = (9.0 * iterations) + 1;
double asymPad = (double)powerfactor;
double gainscaling = 1.0 / (double)(powerfactor + 1);
double outputscaling = 1.0 + (1.0 / (double)(powerfactor));
while (--sampleframes >= 0) {
double inputSampleL = *in1;
double inputSampleR = *in2;
if (fabs(inputSampleL) < 1.18e-23) inputSampleL = fpdL * 1.18e-17;
if (fabs(inputSampleR) < 1.18e-23) inputSampleR = fpdR * 1.18e-17;
if (inputPad < 1.0) {
inputSampleL *= inputPad;
inputSampleR *= inputPad;
}
if (overallscale > 1.9) {
double stored = inputSampleL;
inputSampleL += previousSampleA;
previousSampleA = stored;
inputSampleL *= 0.5;
stored = inputSampleR;
inputSampleR += previousSampleB;
previousSampleB = stored;
inputSampleR *= 0.5;
} // for high sample rates on this plugin we are going to do a simple average
if (inputSampleL > 1.0) inputSampleL = 1.0;
if (inputSampleL < -1.0) inputSampleL = -1.0;
if (inputSampleR > 1.0) inputSampleR = 1.0;
if (inputSampleR < -1.0) inputSampleR = -1.0;
// flatten bottom, point top of sine waveshaper L
inputSampleL /= asymPad;
double sharpen = -inputSampleL;
if (sharpen > 0.0) sharpen = 1.0 + sqrt(sharpen);
else sharpen = 1.0 - sqrt(-sharpen);
inputSampleL -= inputSampleL * fabs(inputSampleL) * sharpen * 0.25;
// this will take input from exactly -1.0 to 1.0 max
inputSampleL *= asymPad;
// flatten bottom, point top of sine waveshaper R
inputSampleR /= asymPad;
sharpen = -inputSampleR;
if (sharpen > 0.0) sharpen = 1.0 + sqrt(sharpen);
else sharpen = 1.0 - sqrt(-sharpen);
inputSampleR -= inputSampleR * fabs(inputSampleR) * sharpen * 0.25;
// this will take input from exactly -1.0 to 1.0 max
inputSampleR *= asymPad;
// end first asym section: later boosting can mitigate the extreme
// softclipping of one side of the wave
// and we are asym clipping more when Tube is cranked, to compensate
// original Tube algorithm: powerfactor widens the more linear region of the wave
double factor = inputSampleL; // Left channel
for (int x = 0; x < powerfactor; x++) factor *= inputSampleL;
if ((powerfactor % 2 == 1) && (inputSampleL != 0.0)) factor = (factor / inputSampleL) * fabs(inputSampleL);
factor *= gainscaling;
inputSampleL -= factor;
inputSampleL *= outputscaling;
factor = inputSampleR; // Right channel
for (int x = 0; x < powerfactor; x++) factor *= inputSampleR;
if ((powerfactor % 2 == 1) && (inputSampleR != 0.0)) factor = (factor / inputSampleR) * fabs(inputSampleR);
factor *= gainscaling;
inputSampleR -= factor;
inputSampleR *= outputscaling;
if (overallscale > 1.9) {
double stored = inputSampleL;
inputSampleL += previousSampleC;
previousSampleC = stored;
inputSampleL *= 0.5;
stored = inputSampleR;
inputSampleR += previousSampleD;
previousSampleD = stored;
inputSampleR *= 0.5;
} // for high sample rates on this plugin we are going to do a simple average
// end original Tube. Now we have a boosted fat sound peaking at 0dB exactly
// hysteresis and spiky fuzz L
double slew = previousSampleE - inputSampleL;
if (overallscale > 1.9) {
double stored = inputSampleL;
inputSampleL += previousSampleE;
previousSampleE = stored;
inputSampleL *= 0.5;
} else previousSampleE = inputSampleL; // for this, need previousSampleC always
if (slew > 0.0) slew = 1.0 + (sqrt(slew) * 0.5);
else slew = 1.0 - (sqrt(-slew) * 0.5);
inputSampleL -= inputSampleL * fabs(inputSampleL) * slew * gainscaling;
// reusing gainscaling that's part of another algorithm
if (inputSampleL > 0.52) inputSampleL = 0.52;
if (inputSampleL < -0.52) inputSampleL = -0.52;
inputSampleL *= 1.923076923076923;
// hysteresis and spiky fuzz R
slew = previousSampleF - inputSampleR;
if (overallscale > 1.9) {
double stored = inputSampleR;
inputSampleR += previousSampleF;
previousSampleF = stored;
inputSampleR *= 0.5;
} else previousSampleF = inputSampleR; // for this, need previousSampleC always
if (slew > 0.0) slew = 1.0 + (sqrt(slew) * 0.5);
else slew = 1.0 - (sqrt(-slew) * 0.5);
inputSampleR -= inputSampleR * fabs(inputSampleR) * slew * gainscaling;
// reusing gainscaling that's part of another algorithm
if (inputSampleR > 0.52) inputSampleR = 0.52;
if (inputSampleR < -0.52) inputSampleR = -0.52;
inputSampleR *= 1.923076923076923;
// end hysteresis and spiky fuzz section
// begin 64 bit stereo floating point dither
// int expon; frexp((double)inputSampleL, &expon);
fpdL ^= fpdL << 13;
fpdL ^= fpdL >> 17;
fpdL ^= fpdL << 5;
// inputSampleL += ((double(fpdL)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62));
// frexp((double)inputSampleR, &expon);
fpdR ^= fpdR << 13;
fpdR ^= fpdR >> 17;
fpdR ^= fpdR << 5;
// inputSampleR += ((double(fpdR)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62));
// end 64 bit stereo floating point dither
*out1 = inputSampleL;
*out2 = inputSampleR;
in1++;
in2++;
out1++;
out2++;
}
}
private:
double samplerate;
double samplerate;
double previousSampleA;
double previousSampleA;
double previousSampleB;
double previousSampleC;
double previousSampleD;
double previousSampleE;
double previousSampleF;
uint32_t fpdL;
uint32_t fpdR;
//default stuff
// default stuff
float A;
float B;
float A;
float B;
double clamp(double& value) {
if (value > 1) {
value = 1;
} else if (value < 0) {
value = 0;
}
return value;
}
double clamp(double& value)
{
if (value > 1) {
value = 1;
} else if (value < 0) {
value = 0;
}
return value;
}
};
}
} // namespace trnr