apply procedural approach to clipper+tube
This commit is contained in:
@@ -1,123 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
#include <cmath>
|
|
||||||
#include <cstdlib>
|
|
||||||
|
|
||||||
namespace trnr {
|
|
||||||
// Clipper based on ClipOnly2 by Chris Johnson
|
|
||||||
class aw_cliponly2 {
|
|
||||||
public:
|
|
||||||
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.
|
|
||||||
}
|
|
||||||
|
|
||||||
void set_samplerate(double _samplerate) { samplerate = _samplerate; }
|
|
||||||
|
|
||||||
template <typename t_sample>
|
|
||||||
void process_block(t_sample** inputs, t_sample** outputs, long sample_frames)
|
|
||||||
{
|
|
||||||
t_sample* in1 = inputs[0];
|
|
||||||
t_sample* in2 = inputs[1];
|
|
||||||
t_sample* out1 = outputs[0];
|
|
||||||
t_sample* 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;
|
|
||||||
|
|
||||||
in1++;
|
|
||||||
in2++;
|
|
||||||
out1++;
|
|
||||||
out2++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
double samplerate;
|
|
||||||
|
|
||||||
double lastSampleL;
|
|
||||||
double intermediateL[16];
|
|
||||||
bool wasPosClipL;
|
|
||||||
bool wasNegClipL;
|
|
||||||
double lastSampleR;
|
|
||||||
double intermediateR[16];
|
|
||||||
bool wasPosClipR;
|
|
||||||
bool wasNegClipR; // Stereo ClipOnly2
|
|
||||||
// default stuff
|
|
||||||
};
|
|
||||||
} // namespace trnr
|
|
||||||
209
clip/aw_tube2.h
209
clip/aw_tube2.h
@@ -1,209 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
#include <cstdlib>
|
|
||||||
#include <stdint.h>
|
|
||||||
#include <cmath>
|
|
||||||
|
|
||||||
namespace trnr {
|
|
||||||
// modeled tube preamp based on tube2 by Chris Johnson
|
|
||||||
class aw_tube2 {
|
|
||||||
public:
|
|
||||||
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.
|
|
||||||
}
|
|
||||||
|
|
||||||
void set_input(double value) { A = clamp(value); }
|
|
||||||
|
|
||||||
void set_tube(double value) { B = clamp(value); }
|
|
||||||
|
|
||||||
void set_samplerate(double _samplerate) { samplerate = _samplerate; }
|
|
||||||
|
|
||||||
template <typename t_sample>
|
|
||||||
void process_block(t_sample** inputs, t_sample** outputs, long sampleframes)
|
|
||||||
{
|
|
||||||
t_sample* in1 = inputs[0];
|
|
||||||
t_sample* in2 = inputs[1];
|
|
||||||
t_sample* out1 = outputs[0];
|
|
||||||
t_sample* 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;
|
|
||||||
|
|
||||||
in1++;
|
|
||||||
in2++;
|
|
||||||
out1++;
|
|
||||||
out2++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
double samplerate;
|
|
||||||
|
|
||||||
double previousSampleA;
|
|
||||||
double previousSampleB;
|
|
||||||
double previousSampleC;
|
|
||||||
double previousSampleD;
|
|
||||||
double previousSampleE;
|
|
||||||
double previousSampleF;
|
|
||||||
|
|
||||||
uint32_t fpdL;
|
|
||||||
uint32_t fpdR;
|
|
||||||
// default stuff
|
|
||||||
|
|
||||||
float A;
|
|
||||||
float B;
|
|
||||||
|
|
||||||
double clamp(double& value)
|
|
||||||
{
|
|
||||||
if (value > 1) {
|
|
||||||
value = 1;
|
|
||||||
} else if (value < 0) {
|
|
||||||
value = 0;
|
|
||||||
}
|
|
||||||
return value;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
} // namespace trnr
|
|
||||||
119
clip/clip.h
Normal file
119
clip/clip.h
Normal file
@@ -0,0 +1,119 @@
|
|||||||
|
#pragma once
|
||||||
|
#include <cmath>
|
||||||
|
#include <cstdlib>
|
||||||
|
|
||||||
|
namespace trnr {
|
||||||
|
// clipper based on ClipOnly2 by Chris Johnson (MIT License)
|
||||||
|
struct clip {
|
||||||
|
double samplerate;
|
||||||
|
|
||||||
|
double last_sample_l;
|
||||||
|
double intermediate_l[16];
|
||||||
|
bool was_pos_clip_l;
|
||||||
|
bool was_neg_clip_l;
|
||||||
|
|
||||||
|
double last_sample_r;
|
||||||
|
double intermediate_r[16];
|
||||||
|
bool was_pos_clip_r;
|
||||||
|
bool was_neg_clip_r;
|
||||||
|
};
|
||||||
|
|
||||||
|
inline void clip_init(clip& c, double _samplerate)
|
||||||
|
{
|
||||||
|
c.samplerate = 44100;
|
||||||
|
|
||||||
|
c.last_sample_l = 0.0;
|
||||||
|
c.was_pos_clip_l = false;
|
||||||
|
c.was_neg_clip_l = false;
|
||||||
|
c.last_sample_r = 0.0;
|
||||||
|
c.was_pos_clip_r = false;
|
||||||
|
c.was_neg_clip_r = false;
|
||||||
|
|
||||||
|
for (int x = 0; x < 16; x++) {
|
||||||
|
c.intermediate_l[x] = 0.0;
|
||||||
|
c.intermediate_r[x] = 0.0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename t_sample>
|
||||||
|
inline void clip_process_block(clip& c, t_sample** inputs, t_sample** outputs, long sample_frames)
|
||||||
|
{
|
||||||
|
t_sample* in1 = inputs[0];
|
||||||
|
t_sample* in2 = inputs[1];
|
||||||
|
t_sample* out1 = outputs[0];
|
||||||
|
t_sample* out2 = outputs[1];
|
||||||
|
|
||||||
|
double overallscale = 1.0;
|
||||||
|
overallscale /= 44100.0;
|
||||||
|
overallscale *= c.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 input_l = *in1;
|
||||||
|
double input_r = *in2;
|
||||||
|
|
||||||
|
// begin ClipOnly2 stereo as a little, compressed chunk that can be dropped into code
|
||||||
|
if (input_l > 4.0) input_l = 4.0;
|
||||||
|
if (input_l < -4.0) input_l = -4.0;
|
||||||
|
if (c.was_pos_clip_l == true) { // current will be over
|
||||||
|
if (input_l < c.last_sample_l) c.last_sample_l = 0.7058208 + (input_l * 0.2609148);
|
||||||
|
else c.last_sample_l = 0.2491717 + (c.last_sample_l * 0.7390851);
|
||||||
|
}
|
||||||
|
c.was_pos_clip_l = false;
|
||||||
|
if (input_l > 0.9549925859) {
|
||||||
|
c.was_pos_clip_l = true;
|
||||||
|
input_l = 0.7058208 + (c.last_sample_l * 0.2609148);
|
||||||
|
}
|
||||||
|
if (c.was_neg_clip_l == true) { // current will be -over
|
||||||
|
if (input_l > c.last_sample_l) c.last_sample_l = -0.7058208 + (input_l * 0.2609148);
|
||||||
|
else c.last_sample_l = -0.2491717 + (c.last_sample_l * 0.7390851);
|
||||||
|
}
|
||||||
|
c.was_neg_clip_l = false;
|
||||||
|
if (input_l < -0.9549925859) {
|
||||||
|
c.was_neg_clip_l = true;
|
||||||
|
input_l = -0.7058208 + (c.last_sample_l * 0.2609148);
|
||||||
|
}
|
||||||
|
c.intermediate_l[spacing] = input_l;
|
||||||
|
input_l = c.last_sample_l; // Latency is however many samples equals one 44.1k sample
|
||||||
|
for (int x = spacing; x > 0; x--) c.intermediate_l[x - 1] = c.intermediate_l[x];
|
||||||
|
c.last_sample_l = c.intermediate_l[0]; // run a little buffer to handle this
|
||||||
|
|
||||||
|
if (input_r > 4.0) input_r = 4.0;
|
||||||
|
if (input_r < -4.0) input_r = -4.0;
|
||||||
|
if (c.was_pos_clip_r == true) { // current will be over
|
||||||
|
if (input_r < c.last_sample_r) c.last_sample_r = 0.7058208 + (input_r * 0.2609148);
|
||||||
|
else c.last_sample_r = 0.2491717 + (c.last_sample_r * 0.7390851);
|
||||||
|
}
|
||||||
|
c.was_pos_clip_r = false;
|
||||||
|
if (input_r > 0.9549925859) {
|
||||||
|
c.was_pos_clip_r = true;
|
||||||
|
input_r = 0.7058208 + (c.last_sample_r * 0.2609148);
|
||||||
|
}
|
||||||
|
if (c.was_neg_clip_r == true) { // current will be -over
|
||||||
|
if (input_r > c.last_sample_r) c.last_sample_r = -0.7058208 + (input_r * 0.2609148);
|
||||||
|
else c.last_sample_r = -0.2491717 + (c.last_sample_r * 0.7390851);
|
||||||
|
}
|
||||||
|
c.was_neg_clip_r = false;
|
||||||
|
if (input_r < -0.9549925859) {
|
||||||
|
c.was_neg_clip_r = true;
|
||||||
|
input_r = -0.7058208 + (c.last_sample_r * 0.2609148);
|
||||||
|
}
|
||||||
|
c.intermediate_r[spacing] = input_r;
|
||||||
|
input_r = c.last_sample_r; // Latency is however many samples equals one 44.1k sample
|
||||||
|
for (int x = spacing; x > 0; x--) c.intermediate_r[x - 1] = c.intermediate_r[x];
|
||||||
|
c.last_sample_r = c.intermediate_r[0]; // run a little buffer to handle this
|
||||||
|
// end ClipOnly2 stereo as a little, compressed chunk that can be dropped into code
|
||||||
|
|
||||||
|
*out1 = input_l;
|
||||||
|
*out2 = input_r;
|
||||||
|
|
||||||
|
in1++;
|
||||||
|
in2++;
|
||||||
|
out1++;
|
||||||
|
out2++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} // namespace trnr
|
||||||
194
clip/tube.h
Normal file
194
clip/tube.h
Normal file
@@ -0,0 +1,194 @@
|
|||||||
|
#pragma once
|
||||||
|
#include <algorithm>
|
||||||
|
#include <cmath>
|
||||||
|
#include <cstdlib>
|
||||||
|
#include <stdint.h>
|
||||||
|
|
||||||
|
namespace trnr {
|
||||||
|
// modeled tube preamp based on tube2 by Chris Johnson (MIT License)
|
||||||
|
struct tube {
|
||||||
|
double samplerate;
|
||||||
|
|
||||||
|
double prev_sample_a;
|
||||||
|
double prev_sample_b;
|
||||||
|
double prev_sample_c;
|
||||||
|
double prev_sample_d;
|
||||||
|
double prev_sample_e;
|
||||||
|
double prev_sample_f;
|
||||||
|
|
||||||
|
uint32_t fdp_l;
|
||||||
|
uint32_t fdp_r;
|
||||||
|
|
||||||
|
float input_vol;
|
||||||
|
float tube_amt;
|
||||||
|
|
||||||
|
void set_input(double value) { input_vol = std::clamp(value, 0.0, 1.0); }
|
||||||
|
|
||||||
|
void set_tube(double value) { tube_amt = std::clamp(value, 0.0, 1.0); }
|
||||||
|
};
|
||||||
|
|
||||||
|
inline void tube_init(tube& t, double samplerate)
|
||||||
|
{
|
||||||
|
t.samplerate = 44100;
|
||||||
|
|
||||||
|
t.input_vol = 0.5;
|
||||||
|
t.tube_amt = 0.5;
|
||||||
|
t.prev_sample_a = 0.0;
|
||||||
|
t.prev_sample_b = 0.0;
|
||||||
|
t.prev_sample_c = 0.0;
|
||||||
|
t.prev_sample_d = 0.0;
|
||||||
|
t.prev_sample_e = 0.0;
|
||||||
|
t.prev_sample_f = 0.0;
|
||||||
|
t.fdp_l = 1.0;
|
||||||
|
while (t.fdp_l < 16386) t.fdp_l = rand() * UINT32_MAX;
|
||||||
|
t.fdp_r = 1.0;
|
||||||
|
while (t.fdp_r < 16386) t.fdp_r = rand() * UINT32_MAX;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename t_sample>
|
||||||
|
inline void tube_process_block(tube& t, t_sample** inputs, t_sample** outputs, long sampleframes)
|
||||||
|
{
|
||||||
|
t_sample* in1 = inputs[0];
|
||||||
|
t_sample* in2 = inputs[1];
|
||||||
|
t_sample* out1 = outputs[0];
|
||||||
|
t_sample* out2 = outputs[1];
|
||||||
|
|
||||||
|
double overallscale = 1.0;
|
||||||
|
overallscale /= 44100.0;
|
||||||
|
overallscale *= t.samplerate;
|
||||||
|
|
||||||
|
double input_pad = t.input_vol;
|
||||||
|
double iterations = 1.0 - t.tube_amt;
|
||||||
|
int powerfactor = (9.0 * iterations) + 1;
|
||||||
|
double asym_pad = (double)powerfactor;
|
||||||
|
double gainscaling = 1.0 / (double)(powerfactor + 1);
|
||||||
|
double outputscaling = 1.0 + (1.0 / (double)(powerfactor));
|
||||||
|
|
||||||
|
while (--sampleframes >= 0) {
|
||||||
|
double input_l = *in1;
|
||||||
|
double input_r = *in2;
|
||||||
|
if (fabs(input_l) < 1.18e-23) input_l = t.fdp_l * 1.18e-17;
|
||||||
|
if (fabs(input_r) < 1.18e-23) input_r = t.fdp_r * 1.18e-17;
|
||||||
|
|
||||||
|
if (input_pad < 1.0) {
|
||||||
|
input_l *= input_pad;
|
||||||
|
input_r *= input_pad;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (overallscale > 1.9) {
|
||||||
|
double stored = input_l;
|
||||||
|
input_l += t.prev_sample_a;
|
||||||
|
t.prev_sample_a = stored;
|
||||||
|
input_l *= 0.5;
|
||||||
|
stored = input_r;
|
||||||
|
input_r += t.prev_sample_b;
|
||||||
|
t.prev_sample_b = stored;
|
||||||
|
input_r *= 0.5;
|
||||||
|
} // for high sample rates on this plugin we are going to do a simple average
|
||||||
|
|
||||||
|
if (input_l > 1.0) input_l = 1.0;
|
||||||
|
if (input_l < -1.0) input_l = -1.0;
|
||||||
|
if (input_r > 1.0) input_r = 1.0;
|
||||||
|
if (input_r < -1.0) input_r = -1.0;
|
||||||
|
|
||||||
|
// flatten bottom, point top of sine waveshaper L
|
||||||
|
input_l /= asym_pad;
|
||||||
|
double sharpen = -input_l;
|
||||||
|
if (sharpen > 0.0) sharpen = 1.0 + sqrt(sharpen);
|
||||||
|
else sharpen = 1.0 - sqrt(-sharpen);
|
||||||
|
input_l -= input_l * fabs(input_l) * sharpen * 0.25;
|
||||||
|
// this will take input from exactly -1.0 to 1.0 max
|
||||||
|
input_l *= asym_pad;
|
||||||
|
// flatten bottom, point top of sine waveshaper R
|
||||||
|
input_r /= asym_pad;
|
||||||
|
sharpen = -input_r;
|
||||||
|
if (sharpen > 0.0) sharpen = 1.0 + sqrt(sharpen);
|
||||||
|
else sharpen = 1.0 - sqrt(-sharpen);
|
||||||
|
input_r -= input_r * fabs(input_r) * sharpen * 0.25;
|
||||||
|
// this will take input from exactly -1.0 to 1.0 max
|
||||||
|
input_r *= asym_pad;
|
||||||
|
// 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 = input_l; // Left channel
|
||||||
|
for (int x = 0; x < powerfactor; x++) factor *= input_l;
|
||||||
|
if ((powerfactor % 2 == 1) && (input_l != 0.0)) factor = (factor / input_l) * fabs(input_l);
|
||||||
|
factor *= gainscaling;
|
||||||
|
input_l -= factor;
|
||||||
|
input_l *= outputscaling;
|
||||||
|
factor = input_r; // Right channel
|
||||||
|
for (int x = 0; x < powerfactor; x++) factor *= input_r;
|
||||||
|
if ((powerfactor % 2 == 1) && (input_r != 0.0)) factor = (factor / input_r) * fabs(input_r);
|
||||||
|
factor *= gainscaling;
|
||||||
|
input_r -= factor;
|
||||||
|
input_r *= outputscaling;
|
||||||
|
|
||||||
|
if (overallscale > 1.9) {
|
||||||
|
double stored = input_l;
|
||||||
|
input_l += t.prev_sample_c;
|
||||||
|
t.prev_sample_c = stored;
|
||||||
|
input_l *= 0.5;
|
||||||
|
stored = input_r;
|
||||||
|
input_r += t.prev_sample_d;
|
||||||
|
t.prev_sample_d = stored;
|
||||||
|
input_r *= 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 = t.prev_sample_e - input_l;
|
||||||
|
if (overallscale > 1.9) {
|
||||||
|
double stored = input_l;
|
||||||
|
input_l += t.prev_sample_e;
|
||||||
|
t.prev_sample_e = stored;
|
||||||
|
input_l *= 0.5;
|
||||||
|
} else t.prev_sample_e = input_l; // for this, need previousSampleC always
|
||||||
|
if (slew > 0.0) slew = 1.0 + (sqrt(slew) * 0.5);
|
||||||
|
else slew = 1.0 - (sqrt(-slew) * 0.5);
|
||||||
|
input_l -= input_l * fabs(input_l) * slew * gainscaling;
|
||||||
|
// reusing gainscaling that's part of another algorithm
|
||||||
|
if (input_l > 0.52) input_l = 0.52;
|
||||||
|
if (input_l < -0.52) input_l = -0.52;
|
||||||
|
input_l *= 1.923076923076923;
|
||||||
|
// hysteresis and spiky fuzz R
|
||||||
|
slew = t.prev_sample_f - input_r;
|
||||||
|
if (overallscale > 1.9) {
|
||||||
|
double stored = input_r;
|
||||||
|
input_r += t.prev_sample_f;
|
||||||
|
t.prev_sample_f = stored;
|
||||||
|
input_r *= 0.5;
|
||||||
|
} else t.prev_sample_f = input_r; // for this, need previousSampleC always
|
||||||
|
if (slew > 0.0) slew = 1.0 + (sqrt(slew) * 0.5);
|
||||||
|
else slew = 1.0 - (sqrt(-slew) * 0.5);
|
||||||
|
input_r -= input_r * fabs(input_r) * slew * gainscaling;
|
||||||
|
// reusing gainscaling that's part of another algorithm
|
||||||
|
if (input_r > 0.52) input_r = 0.52;
|
||||||
|
if (input_r < -0.52) input_r = -0.52;
|
||||||
|
input_r *= 1.923076923076923;
|
||||||
|
// end hysteresis and spiky fuzz section
|
||||||
|
|
||||||
|
// begin 64 bit stereo floating point dither
|
||||||
|
// int expon; frexp((double)inputSampleL, &expon);
|
||||||
|
t.fdp_l ^= t.fdp_l << 13;
|
||||||
|
t.fdp_l ^= t.fdp_l >> 17;
|
||||||
|
t.fdp_l ^= t.fdp_l << 5;
|
||||||
|
// inputSampleL += ((double(fpdL)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62));
|
||||||
|
// frexp((double)inputSampleR, &expon);
|
||||||
|
t.fdp_r ^= t.fdp_r << 13;
|
||||||
|
t.fdp_r ^= t.fdp_r >> 17;
|
||||||
|
t.fdp_r ^= t.fdp_r << 5;
|
||||||
|
// inputSampleR += ((double(fpdR)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62));
|
||||||
|
// end 64 bit stereo floating point dither
|
||||||
|
|
||||||
|
*out1 = input_l;
|
||||||
|
*out2 = input_r;
|
||||||
|
|
||||||
|
in1++;
|
||||||
|
in2++;
|
||||||
|
out1++;
|
||||||
|
out2++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} // namespace trnr
|
||||||
Reference in New Issue
Block a user