initial commit
This commit is contained in:
Christopher Herb
100
clip/aw_cliponly2.h
Normal file
100
clip/aw_cliponly2.h
Normal file
@@ -0,0 +1,100 @@
|
|||||||
|
#pragma once
|
||||||
|
#include <cstdlib>
|
||||||
|
|
||||||
|
namespace trnr::lib::clip {
|
||||||
|
// 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;
|
||||||
|
}
|
||||||
|
|
||||||
|
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;
|
||||||
|
|
||||||
|
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
|
||||||
|
};
|
||||||
|
}
|
||||||
97
clip/aw_clipsoftly.h
Normal file
97
clip/aw_clipsoftly.h
Normal file
@@ -0,0 +1,97 @@
|
|||||||
|
#pragma once
|
||||||
|
#include <cstdlib>
|
||||||
|
#include <stdint.h>
|
||||||
|
|
||||||
|
namespace trnr::lib::clip {
|
||||||
|
// soft clipper based on ClipSoftly by Chris Johnson
|
||||||
|
class aw_clipsoftly {
|
||||||
|
public:
|
||||||
|
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.
|
||||||
|
}
|
||||||
|
|
||||||
|
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];
|
||||||
|
|
||||||
|
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;
|
||||||
|
|
||||||
|
in1++;
|
||||||
|
in2++;
|
||||||
|
out1++;
|
||||||
|
out2++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
double samplerate;
|
||||||
|
|
||||||
|
double lastSampleL;
|
||||||
|
double intermediateL[16];
|
||||||
|
double lastSampleR;
|
||||||
|
double intermediateR[16];
|
||||||
|
uint32_t fpdL;
|
||||||
|
uint32_t fpdR;
|
||||||
|
//default stuff
|
||||||
|
};
|
||||||
|
}
|
||||||
193
clip/aw_tube2.h
Normal file
193
clip/aw_tube2.h
Normal file
@@ -0,0 +1,193 @@
|
|||||||
|
#pragma once
|
||||||
|
#include <cstdlib>
|
||||||
|
#include <stdint.h>
|
||||||
|
|
||||||
|
namespace trnr::lib::clip {
|
||||||
|
// 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;
|
||||||
|
}
|
||||||
|
|
||||||
|
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;
|
||||||
|
|
||||||
|
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;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
47
companding/mulaw.h
Normal file
47
companding/mulaw.h
Normal file
@@ -0,0 +1,47 @@
|
|||||||
|
#pragma once
|
||||||
|
#include <cstdint>
|
||||||
|
|
||||||
|
namespace trnr::lib::companding {
|
||||||
|
// mulaw companding based on code by Emilie Gillet / Mutable Instruments
|
||||||
|
class mulaw {
|
||||||
|
public:
|
||||||
|
int8_t encode_samples(int16_t pcm_val) {
|
||||||
|
int16_t mask;
|
||||||
|
int16_t seg;
|
||||||
|
uint8_t uval;
|
||||||
|
pcm_val = pcm_val >> 2;
|
||||||
|
if (pcm_val < 0) {
|
||||||
|
pcm_val = -pcm_val;
|
||||||
|
mask = 0x7f;
|
||||||
|
} else {
|
||||||
|
mask = 0xff;
|
||||||
|
}
|
||||||
|
if (pcm_val > 8159) pcm_val = 8159;
|
||||||
|
pcm_val += (0x84 >> 2);
|
||||||
|
|
||||||
|
if (pcm_val <= 0x3f) seg = 0;
|
||||||
|
else if (pcm_val <= 0x7f) seg = 1;
|
||||||
|
else if (pcm_val <= 0xff) seg = 2;
|
||||||
|
else if (pcm_val <= 0x1ff) seg = 3;
|
||||||
|
else if (pcm_val <= 0x3ff) seg = 4;
|
||||||
|
else if (pcm_val <= 0x7ff) seg = 5;
|
||||||
|
else if (pcm_val <= 0xfff) seg = 6;
|
||||||
|
else if (pcm_val <= 0x1fff) seg = 7;
|
||||||
|
else seg = 8;
|
||||||
|
if (seg >= 8)
|
||||||
|
return static_cast<uint8_t>(0x7f ^ mask);
|
||||||
|
else {
|
||||||
|
uval = static_cast<uint8_t>((seg << 4) | ((pcm_val >> (seg + 1)) & 0x0f));
|
||||||
|
return (uval ^ mask);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int16_t decode_samples(uint8_t u_val) {
|
||||||
|
int16_t t;
|
||||||
|
u_val = ~u_val;
|
||||||
|
t = ((u_val & 0xf) << 3) + 0x84;
|
||||||
|
t <<= ((unsigned)u_val & 0x70) >> 4;
|
||||||
|
return ((u_val & 0x80) ? (0x84 - t) : (t - 0x84));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
93
companding/ulaw.h
Normal file
93
companding/ulaw.h
Normal file
@@ -0,0 +1,93 @@
|
|||||||
|
#pragma once
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <cstdint>
|
||||||
|
#include <cmath>
|
||||||
|
|
||||||
|
namespace trnr::lib::companding {
|
||||||
|
// ulaw compansion based on code by Chris Johnson
|
||||||
|
class ulaw {
|
||||||
|
public:
|
||||||
|
ulaw() {
|
||||||
|
fpd_l = 1.0; while (fpd_l < 16386) fpd_l = rand()*UINT32_MAX;
|
||||||
|
fpd_r = 1.0; while (fpd_r < 16386) fpd_r = rand()*UINT32_MAX;
|
||||||
|
}
|
||||||
|
|
||||||
|
void encode_samples(double& input_sample_l, double& input_sample_r) {
|
||||||
|
|
||||||
|
// ulaw encoding
|
||||||
|
static int noisesource_l = 0;
|
||||||
|
static int noisesource_r = 850010;
|
||||||
|
int residue;
|
||||||
|
double applyresidue;
|
||||||
|
|
||||||
|
noisesource_l = noisesource_l % 1700021; noisesource_l++;
|
||||||
|
residue = noisesource_l * noisesource_l;
|
||||||
|
residue = residue % 170003; residue *= residue;
|
||||||
|
residue = residue % 17011; residue *= residue;
|
||||||
|
residue = residue % 1709; residue *= residue;
|
||||||
|
residue = residue % 173; residue *= residue;
|
||||||
|
residue = residue % 17;
|
||||||
|
applyresidue = residue;
|
||||||
|
applyresidue *= 0.00000001;
|
||||||
|
applyresidue *= 0.00000001;
|
||||||
|
input_sample_l += applyresidue;
|
||||||
|
if (input_sample_l<1.2e-38 && -input_sample_l<1.2e-38) {
|
||||||
|
input_sample_l -= applyresidue;
|
||||||
|
}
|
||||||
|
|
||||||
|
noisesource_r = noisesource_r % 1700021; noisesource_r++;
|
||||||
|
residue = noisesource_r * noisesource_r;
|
||||||
|
residue = residue % 170003; residue *= residue;
|
||||||
|
residue = residue % 17011; residue *= residue;
|
||||||
|
residue = residue % 1709; residue *= residue;
|
||||||
|
residue = residue % 173; residue *= residue;
|
||||||
|
residue = residue % 17;
|
||||||
|
applyresidue = residue;
|
||||||
|
applyresidue *= 0.00000001;
|
||||||
|
applyresidue *= 0.00000001;
|
||||||
|
input_sample_r += applyresidue;
|
||||||
|
if (input_sample_r<1.2e-38 && -input_sample_r<1.2e-38) {
|
||||||
|
input_sample_r -= applyresidue;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (input_sample_l > 1.0) input_sample_l = 1.0;
|
||||||
|
if (input_sample_l < -1.0) input_sample_l = -1.0;
|
||||||
|
|
||||||
|
if (input_sample_r > 1.0) input_sample_r = 1.0;
|
||||||
|
if (input_sample_r < -1.0) input_sample_r = -1.0;
|
||||||
|
|
||||||
|
if (input_sample_l > 0) input_sample_l = log(1.0+(255*fabs(input_sample_l))) / log(256);
|
||||||
|
if (input_sample_l < 0) input_sample_l = -log(1.0+(255*fabs(input_sample_l))) / log(256);
|
||||||
|
|
||||||
|
if (input_sample_r > 0) input_sample_r = log(1.0+(255*fabs(input_sample_r))) / log(256);
|
||||||
|
if (input_sample_r < 0) input_sample_r = -log(1.0+(255*fabs(input_sample_r))) / log(256);
|
||||||
|
}
|
||||||
|
|
||||||
|
void decode_samples(double& input_sample_l, double& input_sample_r) {
|
||||||
|
|
||||||
|
// ulaw decoding
|
||||||
|
if (fabs(input_sample_l)<1.18e-23) input_sample_l = fpd_l * 1.18e-17;
|
||||||
|
if (fabs(input_sample_r)<1.18e-23) input_sample_r = fpd_r * 1.18e-17;
|
||||||
|
|
||||||
|
if (input_sample_l > 1.0) input_sample_l = 1.0;
|
||||||
|
if (input_sample_l < -1.0) input_sample_l = -1.0;
|
||||||
|
|
||||||
|
if (input_sample_r > 1.0) input_sample_r = 1.0;
|
||||||
|
if (input_sample_r < -1.0) input_sample_r = -1.0;
|
||||||
|
|
||||||
|
if (input_sample_l > 0) input_sample_l = (pow(256,fabs(input_sample_l))-1.0) / 255;
|
||||||
|
if (input_sample_l < 0) input_sample_l = -(pow(256,fabs(input_sample_l))-1.0) / 255;
|
||||||
|
|
||||||
|
if (input_sample_r > 0) input_sample_r = (pow(256,fabs(input_sample_r))-1.0) / 255;
|
||||||
|
if (input_sample_r < 0) input_sample_r = -(pow(256,fabs(input_sample_r))-1.0) / 255;
|
||||||
|
|
||||||
|
// 64 bit stereo floating point dither
|
||||||
|
fpd_l ^= fpd_l << 13; fpd_l ^= fpd_l >> 17; fpd_l ^= fpd_l << 5;
|
||||||
|
fpd_r ^= fpd_r << 13; fpd_r ^= fpd_r >> 17; fpd_r ^= fpd_r << 5;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
uint32_t fpd_l;
|
||||||
|
uint32_t fpd_r;
|
||||||
|
};
|
||||||
|
}
|
||||||
312
dynamics/aw_pop2.h
Normal file
312
dynamics/aw_pop2.h
Normal file
@@ -0,0 +1,312 @@
|
|||||||
|
#pragma once
|
||||||
|
#include <cstdlib>
|
||||||
|
#include <stdint.h>
|
||||||
|
|
||||||
|
namespace trnr::lib::dynamics {
|
||||||
|
// compressor based on pop2 by Chris Johnson
|
||||||
|
class aw_pop2 {
|
||||||
|
public:
|
||||||
|
aw_pop2() {
|
||||||
|
samplerate = 44100;
|
||||||
|
|
||||||
|
A = 0.5;
|
||||||
|
B = 0.5;
|
||||||
|
C = 0.5;
|
||||||
|
D = 0.5;
|
||||||
|
E = 1.0;
|
||||||
|
fpdL = 1.0; while (fpdL < 16386) fpdL = rand()*UINT32_MAX;
|
||||||
|
fpdR = 1.0; while (fpdR < 16386) fpdR = rand()*UINT32_MAX;
|
||||||
|
|
||||||
|
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;}
|
||||||
|
|
||||||
|
muVaryL = 0.0;
|
||||||
|
muAttackL = 0.0;
|
||||||
|
muNewSpeedL = 1000.0;
|
||||||
|
muSpeedAL = 1000.0;
|
||||||
|
muSpeedBL = 1000.0;
|
||||||
|
muCoefficientAL = 1.0;
|
||||||
|
muCoefficientBL = 1.0;
|
||||||
|
|
||||||
|
muVaryR = 0.0;
|
||||||
|
muAttackR = 0.0;
|
||||||
|
muNewSpeedR = 1000.0;
|
||||||
|
muSpeedAR = 1000.0;
|
||||||
|
muSpeedBR = 1000.0;
|
||||||
|
muCoefficientAR = 1.0;
|
||||||
|
muCoefficientBR = 1.0;
|
||||||
|
|
||||||
|
flip = false;
|
||||||
|
//this is reset: values being initialized only once. Startup values, whatever they are.
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_compression(double value) {
|
||||||
|
A = clamp(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_attack(double value) {
|
||||||
|
B = clamp(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_release(double value) {
|
||||||
|
C = clamp(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_drive(double value) {
|
||||||
|
D = clamp(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_drywet(double value) {
|
||||||
|
E = clamp(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
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];
|
||||||
|
|
||||||
|
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;
|
||||||
|
|
||||||
|
double threshold = 1.0 - ((1.0-pow(1.0-A,2))*0.9);
|
||||||
|
double attack = ((pow(B,4)*100000.0)+10.0)*overallscale;
|
||||||
|
double release = ((pow(C,5)*2000000.0)+20.0)*overallscale;
|
||||||
|
double maxRelease = release * 4.0;
|
||||||
|
double muPreGain = 1.0/threshold;
|
||||||
|
double muMakeupGain = sqrt(1.0 / threshold)*D;
|
||||||
|
double wet = E;
|
||||||
|
//compressor section
|
||||||
|
|
||||||
|
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;
|
||||||
|
double drySampleL = inputSampleL;
|
||||||
|
double drySampleR = inputSampleR;
|
||||||
|
|
||||||
|
//begin compressor section
|
||||||
|
inputSampleL *= muPreGain;
|
||||||
|
inputSampleR *= muPreGain;
|
||||||
|
//adjust coefficients for L
|
||||||
|
if (flip) {
|
||||||
|
if (fabs(inputSampleL) > threshold) {
|
||||||
|
muVaryL = threshold / fabs(inputSampleL);
|
||||||
|
muAttackL = sqrt(fabs(muSpeedAL));
|
||||||
|
muCoefficientAL = muCoefficientAL * (muAttackL-1.0);
|
||||||
|
if (muVaryL < threshold) muCoefficientAL = muCoefficientAL + threshold;
|
||||||
|
else muCoefficientAL = muCoefficientAL + muVaryL;
|
||||||
|
muCoefficientAL = muCoefficientAL / muAttackL;
|
||||||
|
muNewSpeedL = muSpeedAL * (muSpeedAL-1.0);
|
||||||
|
muNewSpeedL = muNewSpeedL + release;
|
||||||
|
muSpeedAL = muNewSpeedL / muSpeedAL;
|
||||||
|
if (muSpeedAL > maxRelease) muSpeedAL = maxRelease;
|
||||||
|
} else {
|
||||||
|
muCoefficientAL = muCoefficientAL * ((muSpeedAL * muSpeedAL)-1.0);
|
||||||
|
muCoefficientAL = muCoefficientAL + 1.0;
|
||||||
|
muCoefficientAL = muCoefficientAL / (muSpeedAL * muSpeedAL);
|
||||||
|
muNewSpeedL = muSpeedAL * (muSpeedAL-1.0);
|
||||||
|
muNewSpeedL = muNewSpeedL + attack;
|
||||||
|
muSpeedAL = muNewSpeedL / muSpeedAL;}
|
||||||
|
} else {
|
||||||
|
if (fabs(inputSampleL) > threshold) {
|
||||||
|
muVaryL = threshold / fabs(inputSampleL);
|
||||||
|
muAttackL = sqrt(fabs(muSpeedBL));
|
||||||
|
muCoefficientBL = muCoefficientBL * (muAttackL-1);
|
||||||
|
if (muVaryL < threshold) muCoefficientBL = muCoefficientBL + threshold;
|
||||||
|
else muCoefficientBL = muCoefficientBL + muVaryL;
|
||||||
|
muCoefficientBL = muCoefficientBL / muAttackL;
|
||||||
|
muNewSpeedL = muSpeedBL * (muSpeedBL-1.0);
|
||||||
|
muNewSpeedL = muNewSpeedL + release;
|
||||||
|
muSpeedBL = muNewSpeedL / muSpeedBL;
|
||||||
|
if (muSpeedBL > maxRelease) muSpeedBL = maxRelease;
|
||||||
|
} else {
|
||||||
|
muCoefficientBL = muCoefficientBL * ((muSpeedBL * muSpeedBL)-1.0);
|
||||||
|
muCoefficientBL = muCoefficientBL + 1.0;
|
||||||
|
muCoefficientBL = muCoefficientBL / (muSpeedBL * muSpeedBL);
|
||||||
|
muNewSpeedL = muSpeedBL * (muSpeedBL-1.0);
|
||||||
|
muNewSpeedL = muNewSpeedL + attack;
|
||||||
|
muSpeedBL = muNewSpeedL / muSpeedBL;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
//got coefficients, adjusted speeds for L
|
||||||
|
|
||||||
|
//adjust coefficients for R
|
||||||
|
if (flip) {
|
||||||
|
if (fabs(inputSampleR) > threshold) {
|
||||||
|
muVaryR = threshold / fabs(inputSampleR);
|
||||||
|
muAttackR = sqrt(fabs(muSpeedAR));
|
||||||
|
muCoefficientAR = muCoefficientAR * (muAttackR-1.0);
|
||||||
|
if (muVaryR < threshold) muCoefficientAR = muCoefficientAR + threshold;
|
||||||
|
else muCoefficientAR = muCoefficientAR + muVaryR;
|
||||||
|
muCoefficientAR = muCoefficientAR / muAttackR;
|
||||||
|
muNewSpeedR = muSpeedAR * (muSpeedAR-1.0);
|
||||||
|
muNewSpeedR = muNewSpeedR + release;
|
||||||
|
muSpeedAR = muNewSpeedR / muSpeedAR;
|
||||||
|
if (muSpeedAR > maxRelease) muSpeedAR = maxRelease;
|
||||||
|
} else {
|
||||||
|
muCoefficientAR = muCoefficientAR * ((muSpeedAR * muSpeedAR)-1.0);
|
||||||
|
muCoefficientAR = muCoefficientAR + 1.0;
|
||||||
|
muCoefficientAR = muCoefficientAR / (muSpeedAR * muSpeedAR);
|
||||||
|
muNewSpeedR = muSpeedAR * (muSpeedAR-1.0);
|
||||||
|
muNewSpeedR = muNewSpeedR + attack;
|
||||||
|
muSpeedAR = muNewSpeedR / muSpeedAR;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
if (fabs(inputSampleR) > threshold) {
|
||||||
|
muVaryR = threshold / fabs(inputSampleR);
|
||||||
|
muAttackR = sqrt(fabs(muSpeedBR));
|
||||||
|
muCoefficientBR = muCoefficientBR * (muAttackR-1);
|
||||||
|
if (muVaryR < threshold) muCoefficientBR = muCoefficientBR + threshold;
|
||||||
|
else muCoefficientBR = muCoefficientBR + muVaryR;
|
||||||
|
muCoefficientBR = muCoefficientBR / muAttackR;
|
||||||
|
muNewSpeedR = muSpeedBR * (muSpeedBR-1.0);
|
||||||
|
muNewSpeedR = muNewSpeedR + release;
|
||||||
|
muSpeedBR = muNewSpeedR / muSpeedBR;
|
||||||
|
if (muSpeedBR > maxRelease) muSpeedBR = maxRelease;
|
||||||
|
} else {
|
||||||
|
muCoefficientBR = muCoefficientBR * ((muSpeedBR * muSpeedBR)-1.0);
|
||||||
|
muCoefficientBR = muCoefficientBR + 1.0;
|
||||||
|
muCoefficientBR = muCoefficientBR / (muSpeedBR * muSpeedBR);
|
||||||
|
muNewSpeedR = muSpeedBR * (muSpeedBR-1.0);
|
||||||
|
muNewSpeedR = muNewSpeedR + attack;
|
||||||
|
muSpeedBR = muNewSpeedR / muSpeedBR;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
//got coefficients, adjusted speeds for R
|
||||||
|
|
||||||
|
if (flip) {
|
||||||
|
inputSampleL *= pow(muCoefficientAL,2);
|
||||||
|
inputSampleR *= pow(muCoefficientAR,2);
|
||||||
|
} else {
|
||||||
|
inputSampleL *= pow(muCoefficientBL,2);
|
||||||
|
inputSampleR *= pow(muCoefficientBR,2);
|
||||||
|
}
|
||||||
|
inputSampleL *= muMakeupGain;
|
||||||
|
inputSampleR *= muMakeupGain;
|
||||||
|
flip = !flip;
|
||||||
|
//end compressor section
|
||||||
|
|
||||||
|
//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
|
||||||
|
|
||||||
|
if (wet<1.0) {
|
||||||
|
inputSampleL = (drySampleL*(1.0-wet))+(inputSampleL*wet);
|
||||||
|
inputSampleR = (drySampleR*(1.0-wet))+(inputSampleR*wet);
|
||||||
|
}
|
||||||
|
|
||||||
|
//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;
|
||||||
|
|
||||||
|
uint32_t fpdL;
|
||||||
|
uint32_t fpdR;
|
||||||
|
//default stuff
|
||||||
|
|
||||||
|
double muVaryL;
|
||||||
|
double muAttackL;
|
||||||
|
double muNewSpeedL;
|
||||||
|
double muSpeedAL;
|
||||||
|
double muSpeedBL;
|
||||||
|
double muCoefficientAL;
|
||||||
|
double muCoefficientBL;
|
||||||
|
|
||||||
|
double muVaryR;
|
||||||
|
double muAttackR;
|
||||||
|
double muNewSpeedR;
|
||||||
|
double muSpeedAR;
|
||||||
|
double muSpeedBR;
|
||||||
|
double muCoefficientAR;
|
||||||
|
double muCoefficientBR;
|
||||||
|
|
||||||
|
bool flip;
|
||||||
|
|
||||||
|
double lastSampleL;
|
||||||
|
double intermediateL[16];
|
||||||
|
bool wasPosClipL;
|
||||||
|
bool wasNegClipL;
|
||||||
|
double lastSampleR;
|
||||||
|
double intermediateR[16];
|
||||||
|
bool wasPosClipR;
|
||||||
|
bool wasNegClipR; //Stereo ClipOnly2
|
||||||
|
|
||||||
|
float A;
|
||||||
|
float B;
|
||||||
|
float C;
|
||||||
|
float D;
|
||||||
|
float E; //parameters. Always 0-1, and we scale/alter them elsewhere.
|
||||||
|
|
||||||
|
double clamp(double& value) {
|
||||||
|
if (value > 1) {
|
||||||
|
value = 1;
|
||||||
|
} else if (value < 0) {
|
||||||
|
value = 0;
|
||||||
|
}
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
677
filter/aw_eq.h
Normal file
677
filter/aw_eq.h
Normal file
@@ -0,0 +1,677 @@
|
|||||||
|
#pragma once
|
||||||
|
#include <cstdlib>
|
||||||
|
#include <stdint.h>
|
||||||
|
|
||||||
|
namespace trnr::lib::filter {
|
||||||
|
// 3 band equalizer with high/lowpass filters based on EQ by Chris Johnson.
|
||||||
|
class aw_eq {
|
||||||
|
public:
|
||||||
|
aw_eq() {
|
||||||
|
samplerate = 44100;
|
||||||
|
|
||||||
|
A = 0.5; //Treble -12 to 12
|
||||||
|
B = 0.5; //Mid -12 to 12
|
||||||
|
C = 0.5; //Bass -12 to 12
|
||||||
|
D = 1.0; //Lowpass 16.0K log 1 to 16 defaulting to 16K
|
||||||
|
E = 0.4; //TrebFrq 6.0 log 1 to 16 defaulting to 6K
|
||||||
|
F = 0.4; //BassFrq 100.0 log 30 to 1600 defaulting to 100 hz
|
||||||
|
G = 0.0; //Hipass 30.0 log 30 to 1600 defaulting to 30
|
||||||
|
H = 0.5; //OutGain -18 to 18
|
||||||
|
|
||||||
|
lastSampleL = 0.0;
|
||||||
|
last2SampleL = 0.0;
|
||||||
|
lastSampleR = 0.0;
|
||||||
|
last2SampleR = 0.0;
|
||||||
|
|
||||||
|
iirHighSampleLA = 0.0;
|
||||||
|
iirHighSampleLB = 0.0;
|
||||||
|
iirHighSampleLC = 0.0;
|
||||||
|
iirHighSampleLD = 0.0;
|
||||||
|
iirHighSampleLE = 0.0;
|
||||||
|
iirLowSampleLA = 0.0;
|
||||||
|
iirLowSampleLB = 0.0;
|
||||||
|
iirLowSampleLC = 0.0;
|
||||||
|
iirLowSampleLD = 0.0;
|
||||||
|
iirLowSampleLE = 0.0;
|
||||||
|
iirHighSampleL = 0.0;
|
||||||
|
iirLowSampleL = 0.0;
|
||||||
|
|
||||||
|
iirHighSampleRA = 0.0;
|
||||||
|
iirHighSampleRB = 0.0;
|
||||||
|
iirHighSampleRC = 0.0;
|
||||||
|
iirHighSampleRD = 0.0;
|
||||||
|
iirHighSampleRE = 0.0;
|
||||||
|
iirLowSampleRA = 0.0;
|
||||||
|
iirLowSampleRB = 0.0;
|
||||||
|
iirLowSampleRC = 0.0;
|
||||||
|
iirLowSampleRD = 0.0;
|
||||||
|
iirLowSampleRE = 0.0;
|
||||||
|
iirHighSampleR = 0.0;
|
||||||
|
iirLowSampleR = 0.0;
|
||||||
|
|
||||||
|
tripletLA = 0.0;
|
||||||
|
tripletLB = 0.0;
|
||||||
|
tripletLC = 0.0;
|
||||||
|
tripletFactorL = 0.0;
|
||||||
|
|
||||||
|
tripletRA = 0.0;
|
||||||
|
tripletRB = 0.0;
|
||||||
|
tripletRC = 0.0;
|
||||||
|
tripletFactorR = 0.0;
|
||||||
|
|
||||||
|
lowpassSampleLAA = 0.0;
|
||||||
|
lowpassSampleLAB = 0.0;
|
||||||
|
lowpassSampleLBA = 0.0;
|
||||||
|
lowpassSampleLBB = 0.0;
|
||||||
|
lowpassSampleLCA = 0.0;
|
||||||
|
lowpassSampleLCB = 0.0;
|
||||||
|
lowpassSampleLDA = 0.0;
|
||||||
|
lowpassSampleLDB = 0.0;
|
||||||
|
lowpassSampleLE = 0.0;
|
||||||
|
lowpassSampleLF = 0.0;
|
||||||
|
lowpassSampleLG = 0.0;
|
||||||
|
|
||||||
|
lowpassSampleRAA = 0.0;
|
||||||
|
lowpassSampleRAB = 0.0;
|
||||||
|
lowpassSampleRBA = 0.0;
|
||||||
|
lowpassSampleRBB = 0.0;
|
||||||
|
lowpassSampleRCA = 0.0;
|
||||||
|
lowpassSampleRCB = 0.0;
|
||||||
|
lowpassSampleRDA = 0.0;
|
||||||
|
lowpassSampleRDB = 0.0;
|
||||||
|
lowpassSampleRE = 0.0;
|
||||||
|
lowpassSampleRF = 0.0;
|
||||||
|
lowpassSampleRG = 0.0;
|
||||||
|
|
||||||
|
highpassSampleLAA = 0.0;
|
||||||
|
highpassSampleLAB = 0.0;
|
||||||
|
highpassSampleLBA = 0.0;
|
||||||
|
highpassSampleLBB = 0.0;
|
||||||
|
highpassSampleLCA = 0.0;
|
||||||
|
highpassSampleLCB = 0.0;
|
||||||
|
highpassSampleLDA = 0.0;
|
||||||
|
highpassSampleLDB = 0.0;
|
||||||
|
highpassSampleLE = 0.0;
|
||||||
|
highpassSampleLF = 0.0;
|
||||||
|
|
||||||
|
highpassSampleRAA = 0.0;
|
||||||
|
highpassSampleRAB = 0.0;
|
||||||
|
highpassSampleRBA = 0.0;
|
||||||
|
highpassSampleRBB = 0.0;
|
||||||
|
highpassSampleRCA = 0.0;
|
||||||
|
highpassSampleRCB = 0.0;
|
||||||
|
highpassSampleRDA = 0.0;
|
||||||
|
highpassSampleRDB = 0.0;
|
||||||
|
highpassSampleRE = 0.0;
|
||||||
|
highpassSampleRF = 0.0;
|
||||||
|
|
||||||
|
flip = false;
|
||||||
|
flipthree = 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_treble(double value) {
|
||||||
|
A = clamp(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_mid(double value) {
|
||||||
|
B = clamp(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_bass(double value) {
|
||||||
|
C = clamp(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_lowpass(double value) {
|
||||||
|
D = clamp(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_treble_frq(double value) {
|
||||||
|
E = clamp(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_bass_frq(double value) {
|
||||||
|
F = clamp(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_hipass(double value) {
|
||||||
|
G = clamp(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_out_gain(double value) {
|
||||||
|
H = clamp(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
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];
|
||||||
|
|
||||||
|
double overallscale = 1.0;
|
||||||
|
overallscale /= 44100.0;
|
||||||
|
double compscale = overallscale;
|
||||||
|
overallscale = samplerate;
|
||||||
|
compscale = compscale * overallscale;
|
||||||
|
//compscale is the one that's 1 or something like 2.2 for 96K rates
|
||||||
|
|
||||||
|
double inputSampleL;
|
||||||
|
double inputSampleR;
|
||||||
|
|
||||||
|
double highSampleL = 0.0;
|
||||||
|
double midSampleL = 0.0;
|
||||||
|
double bassSampleL = 0.0;
|
||||||
|
|
||||||
|
double highSampleR = 0.0;
|
||||||
|
double midSampleR = 0.0;
|
||||||
|
double bassSampleR = 0.0;
|
||||||
|
|
||||||
|
double densityA = (A*12.0)-6.0;
|
||||||
|
double densityB = (B*12.0)-6.0;
|
||||||
|
double densityC = (C*12.0)-6.0;
|
||||||
|
bool engageEQ = true;
|
||||||
|
if ( (0.0 == densityA) && (0.0 == densityB) && (0.0 == densityC) ) engageEQ = false;
|
||||||
|
|
||||||
|
densityA = pow(10.0,densityA/20.0)-1.0;
|
||||||
|
densityB = pow(10.0,densityB/20.0)-1.0;
|
||||||
|
densityC = pow(10.0,densityC/20.0)-1.0;
|
||||||
|
//convert to 0 to X multiplier with 1.0 being O db
|
||||||
|
//minus one gives nearly -1 to ? (should top out at 1)
|
||||||
|
//calibrate so that X db roughly equals X db with maximum topping out at 1 internally
|
||||||
|
|
||||||
|
double tripletIntensity = -densityA;
|
||||||
|
|
||||||
|
double iirAmountC = (((D*D*15.0)+1.0)*0.0188) + 0.7;
|
||||||
|
if (iirAmountC > 1.0) iirAmountC = 1.0;
|
||||||
|
bool engageLowpass = false;
|
||||||
|
if (((D*D*15.0)+1.0) < 15.99) engageLowpass = true;
|
||||||
|
|
||||||
|
double iirAmountA = (((E*E*15.0)+1.0)*1000)/overallscale;
|
||||||
|
double iirAmountB = (((F*F*1570.0)+30.0)*10)/overallscale;
|
||||||
|
double iirAmountD = (((G*G*1570.0)+30.0)*1.0)/overallscale;
|
||||||
|
bool engageHighpass = false;
|
||||||
|
if (((G*G*1570.0)+30.0) > 30.01) engageHighpass = true;
|
||||||
|
//bypass the highpass and lowpass if set to extremes
|
||||||
|
double bridgerectifier;
|
||||||
|
double outA = fabs(densityA);
|
||||||
|
double outB = fabs(densityB);
|
||||||
|
double outC = fabs(densityC);
|
||||||
|
//end EQ
|
||||||
|
double outputgain = pow(10.0,((H*36.0)-18.0)/20.0);
|
||||||
|
|
||||||
|
while (--sampleframes >= 0)
|
||||||
|
{
|
||||||
|
inputSampleL = *in1;
|
||||||
|
inputSampleR = *in2;
|
||||||
|
if (fabs(inputSampleL)<1.18e-23) inputSampleL = fpdL * 1.18e-17;
|
||||||
|
if (fabs(inputSampleR)<1.18e-23) inputSampleR = fpdR * 1.18e-17;
|
||||||
|
|
||||||
|
last2SampleL = lastSampleL;
|
||||||
|
lastSampleL = inputSampleL;
|
||||||
|
|
||||||
|
last2SampleR = lastSampleR;
|
||||||
|
lastSampleR = inputSampleR;
|
||||||
|
|
||||||
|
flip = !flip;
|
||||||
|
flipthree++;
|
||||||
|
if (flipthree < 1 || flipthree > 3) flipthree = 1;
|
||||||
|
//counters
|
||||||
|
|
||||||
|
//begin highpass
|
||||||
|
if (engageHighpass)
|
||||||
|
{
|
||||||
|
if (flip)
|
||||||
|
{
|
||||||
|
highpassSampleLAA = (highpassSampleLAA * (1.0 - iirAmountD)) + (inputSampleL * iirAmountD);
|
||||||
|
inputSampleL -= highpassSampleLAA;
|
||||||
|
highpassSampleLBA = (highpassSampleLBA * (1.0 - iirAmountD)) + (inputSampleL * iirAmountD);
|
||||||
|
inputSampleL -= highpassSampleLBA;
|
||||||
|
highpassSampleLCA = (highpassSampleLCA * (1.0 - iirAmountD)) + (inputSampleL * iirAmountD);
|
||||||
|
inputSampleL -= highpassSampleLCA;
|
||||||
|
highpassSampleLDA = (highpassSampleLDA * (1.0 - iirAmountD)) + (inputSampleL * iirAmountD);
|
||||||
|
inputSampleL -= highpassSampleLDA;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
highpassSampleLAB = (highpassSampleLAB * (1.0 - iirAmountD)) + (inputSampleL * iirAmountD);
|
||||||
|
inputSampleL -= highpassSampleLAB;
|
||||||
|
highpassSampleLBB = (highpassSampleLBB * (1.0 - iirAmountD)) + (inputSampleL * iirAmountD);
|
||||||
|
inputSampleL -= highpassSampleLBB;
|
||||||
|
highpassSampleLCB = (highpassSampleLCB * (1.0 - iirAmountD)) + (inputSampleL * iirAmountD);
|
||||||
|
inputSampleL -= highpassSampleLCB;
|
||||||
|
highpassSampleLDB = (highpassSampleLDB * (1.0 - iirAmountD)) + (inputSampleL * iirAmountD);
|
||||||
|
inputSampleL -= highpassSampleLDB;
|
||||||
|
}
|
||||||
|
highpassSampleLE = (highpassSampleLE * (1.0 - iirAmountD)) + (inputSampleL * iirAmountD);
|
||||||
|
inputSampleL -= highpassSampleLE;
|
||||||
|
highpassSampleLF = (highpassSampleLF * (1.0 - iirAmountD)) + (inputSampleL * iirAmountD);
|
||||||
|
inputSampleL -= highpassSampleLF;
|
||||||
|
|
||||||
|
if (flip)
|
||||||
|
{
|
||||||
|
highpassSampleRAA = (highpassSampleRAA * (1.0 - iirAmountD)) + (inputSampleR * iirAmountD);
|
||||||
|
inputSampleR -= highpassSampleRAA;
|
||||||
|
highpassSampleRBA = (highpassSampleRBA * (1.0 - iirAmountD)) + (inputSampleR * iirAmountD);
|
||||||
|
inputSampleR -= highpassSampleRBA;
|
||||||
|
highpassSampleRCA = (highpassSampleRCA * (1.0 - iirAmountD)) + (inputSampleR * iirAmountD);
|
||||||
|
inputSampleR -= highpassSampleRCA;
|
||||||
|
highpassSampleRDA = (highpassSampleRDA * (1.0 - iirAmountD)) + (inputSampleR * iirAmountD);
|
||||||
|
inputSampleR -= highpassSampleRDA;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
highpassSampleRAB = (highpassSampleRAB * (1.0 - iirAmountD)) + (inputSampleR * iirAmountD);
|
||||||
|
inputSampleR -= highpassSampleRAB;
|
||||||
|
highpassSampleRBB = (highpassSampleRBB * (1.0 - iirAmountD)) + (inputSampleR * iirAmountD);
|
||||||
|
inputSampleR -= highpassSampleRBB;
|
||||||
|
highpassSampleRCB = (highpassSampleRCB * (1.0 - iirAmountD)) + (inputSampleR * iirAmountD);
|
||||||
|
inputSampleR -= highpassSampleRCB;
|
||||||
|
highpassSampleRDB = (highpassSampleRDB * (1.0 - iirAmountD)) + (inputSampleR * iirAmountD);
|
||||||
|
inputSampleR -= highpassSampleRDB;
|
||||||
|
}
|
||||||
|
highpassSampleRE = (highpassSampleRE * (1 - iirAmountD)) + (inputSampleR * iirAmountD);
|
||||||
|
inputSampleR -= highpassSampleRE;
|
||||||
|
highpassSampleRF = (highpassSampleRF * (1 - iirAmountD)) + (inputSampleR * iirAmountD);
|
||||||
|
inputSampleR -= highpassSampleRF;
|
||||||
|
|
||||||
|
}
|
||||||
|
//end highpass
|
||||||
|
|
||||||
|
//begin EQ
|
||||||
|
if (engageEQ)
|
||||||
|
{
|
||||||
|
switch (flipthree)
|
||||||
|
{
|
||||||
|
case 1:
|
||||||
|
tripletFactorL = last2SampleL - inputSampleL;
|
||||||
|
tripletLA += tripletFactorL;
|
||||||
|
tripletLC -= tripletFactorL;
|
||||||
|
tripletFactorL = tripletLA * tripletIntensity;
|
||||||
|
iirHighSampleLC = (iirHighSampleLC * (1.0 - iirAmountA)) + (inputSampleL * iirAmountA);
|
||||||
|
highSampleL = inputSampleL - iirHighSampleLC;
|
||||||
|
iirLowSampleLC = (iirLowSampleLC * (1.0 - iirAmountB)) + (inputSampleL * iirAmountB);
|
||||||
|
bassSampleL = iirLowSampleLC;
|
||||||
|
|
||||||
|
tripletFactorR = last2SampleR - inputSampleR;
|
||||||
|
tripletRA += tripletFactorR;
|
||||||
|
tripletRC -= tripletFactorR;
|
||||||
|
tripletFactorR = tripletRA * tripletIntensity;
|
||||||
|
iirHighSampleRC = (iirHighSampleRC * (1.0 - iirAmountA)) + (inputSampleR * iirAmountA);
|
||||||
|
highSampleR = inputSampleR - iirHighSampleRC;
|
||||||
|
iirLowSampleRC = (iirLowSampleRC * (1.0 - iirAmountB)) + (inputSampleR * iirAmountB);
|
||||||
|
bassSampleR = iirLowSampleRC;
|
||||||
|
break;
|
||||||
|
case 2:
|
||||||
|
tripletFactorL = last2SampleL - inputSampleL;
|
||||||
|
tripletLB += tripletFactorL;
|
||||||
|
tripletLA -= tripletFactorL;
|
||||||
|
tripletFactorL = tripletLB * tripletIntensity;
|
||||||
|
iirHighSampleLD = (iirHighSampleLD * (1.0 - iirAmountA)) + (inputSampleL * iirAmountA);
|
||||||
|
highSampleL = inputSampleL - iirHighSampleLD;
|
||||||
|
iirLowSampleLD = (iirLowSampleLD * (1.0 - iirAmountB)) + (inputSampleL * iirAmountB);
|
||||||
|
bassSampleL = iirLowSampleLD;
|
||||||
|
|
||||||
|
tripletFactorR = last2SampleR - inputSampleR;
|
||||||
|
tripletRB += tripletFactorR;
|
||||||
|
tripletRA -= tripletFactorR;
|
||||||
|
tripletFactorR = tripletRB * tripletIntensity;
|
||||||
|
iirHighSampleRD = (iirHighSampleRD * (1.0 - iirAmountA)) + (inputSampleR * iirAmountA);
|
||||||
|
highSampleR = inputSampleR - iirHighSampleRD;
|
||||||
|
iirLowSampleRD = (iirLowSampleRD * (1.0 - iirAmountB)) + (inputSampleR * iirAmountB);
|
||||||
|
bassSampleR = iirLowSampleRD;
|
||||||
|
break;
|
||||||
|
case 3:
|
||||||
|
tripletFactorL = last2SampleL - inputSampleL;
|
||||||
|
tripletLC += tripletFactorL;
|
||||||
|
tripletLB -= tripletFactorL;
|
||||||
|
tripletFactorL = tripletLC * tripletIntensity;
|
||||||
|
iirHighSampleLE = (iirHighSampleLE * (1.0 - iirAmountA)) + (inputSampleL * iirAmountA);
|
||||||
|
highSampleL = inputSampleL - iirHighSampleLE;
|
||||||
|
iirLowSampleLE = (iirLowSampleLE * (1.0 - iirAmountB)) + (inputSampleL * iirAmountB);
|
||||||
|
bassSampleL = iirLowSampleLE;
|
||||||
|
|
||||||
|
tripletFactorR = last2SampleR - inputSampleR;
|
||||||
|
tripletRC += tripletFactorR;
|
||||||
|
tripletRB -= tripletFactorR;
|
||||||
|
tripletFactorR = tripletRC * tripletIntensity;
|
||||||
|
iirHighSampleRE = (iirHighSampleRE * (1.0 - iirAmountA)) + (inputSampleR * iirAmountA);
|
||||||
|
highSampleR = inputSampleR - iirHighSampleRE;
|
||||||
|
iirLowSampleRE = (iirLowSampleRE * (1.0 - iirAmountB)) + (inputSampleR * iirAmountB);
|
||||||
|
bassSampleR = iirLowSampleRE;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
tripletLA /= 2.0;
|
||||||
|
tripletLB /= 2.0;
|
||||||
|
tripletLC /= 2.0;
|
||||||
|
highSampleL = highSampleL + tripletFactorL;
|
||||||
|
|
||||||
|
tripletRA /= 2.0;
|
||||||
|
tripletRB /= 2.0;
|
||||||
|
tripletRC /= 2.0;
|
||||||
|
highSampleR = highSampleR + tripletFactorR;
|
||||||
|
|
||||||
|
if (flip)
|
||||||
|
{
|
||||||
|
iirHighSampleLA = (iirHighSampleLA * (1.0 - iirAmountA)) + (highSampleL * iirAmountA);
|
||||||
|
highSampleL -= iirHighSampleLA;
|
||||||
|
iirLowSampleLA = (iirLowSampleLA * (1.0 - iirAmountB)) + (bassSampleL * iirAmountB);
|
||||||
|
bassSampleL = iirLowSampleLA;
|
||||||
|
|
||||||
|
iirHighSampleRA = (iirHighSampleRA * (1.0 - iirAmountA)) + (highSampleR * iirAmountA);
|
||||||
|
highSampleR -= iirHighSampleRA;
|
||||||
|
iirLowSampleRA = (iirLowSampleRA * (1.0 - iirAmountB)) + (bassSampleR * iirAmountB);
|
||||||
|
bassSampleR = iirLowSampleRA;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
iirHighSampleLB = (iirHighSampleLB * (1.0 - iirAmountA)) + (highSampleL * iirAmountA);
|
||||||
|
highSampleL -= iirHighSampleLB;
|
||||||
|
iirLowSampleLB = (iirLowSampleLB * (1.0 - iirAmountB)) + (bassSampleL * iirAmountB);
|
||||||
|
bassSampleL = iirLowSampleLB;
|
||||||
|
|
||||||
|
iirHighSampleRB = (iirHighSampleRB * (1.0 - iirAmountA)) + (highSampleR * iirAmountA);
|
||||||
|
highSampleR -= iirHighSampleRB;
|
||||||
|
iirLowSampleRB = (iirLowSampleRB * (1.0 - iirAmountB)) + (bassSampleR * iirAmountB);
|
||||||
|
bassSampleR = iirLowSampleRB;
|
||||||
|
}
|
||||||
|
|
||||||
|
iirHighSampleL = (iirHighSampleL * (1.0 - iirAmountA)) + (highSampleL * iirAmountA);
|
||||||
|
highSampleL -= iirHighSampleL;
|
||||||
|
iirLowSampleL = (iirLowSampleL * (1.0 - iirAmountB)) + (bassSampleL * iirAmountB);
|
||||||
|
bassSampleL = iirLowSampleL;
|
||||||
|
|
||||||
|
iirHighSampleR = (iirHighSampleR * (1.0 - iirAmountA)) + (highSampleR * iirAmountA);
|
||||||
|
highSampleR -= iirHighSampleR;
|
||||||
|
iirLowSampleR = (iirLowSampleR * (1.0 - iirAmountB)) + (bassSampleR * iirAmountB);
|
||||||
|
bassSampleR = iirLowSampleR;
|
||||||
|
|
||||||
|
midSampleL = (inputSampleL-bassSampleL)-highSampleL;
|
||||||
|
midSampleR = (inputSampleR-bassSampleR)-highSampleR;
|
||||||
|
|
||||||
|
//drive section
|
||||||
|
highSampleL *= (densityA+1.0);
|
||||||
|
bridgerectifier = fabs(highSampleL)*1.57079633;
|
||||||
|
if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633;
|
||||||
|
//max value for sine function
|
||||||
|
if (densityA > 0) bridgerectifier = sin(bridgerectifier);
|
||||||
|
else bridgerectifier = 1-cos(bridgerectifier);
|
||||||
|
//produce either boosted or starved version
|
||||||
|
if (highSampleL > 0) highSampleL = (highSampleL*(1-outA))+(bridgerectifier*outA);
|
||||||
|
else highSampleL = (highSampleL*(1-outA))-(bridgerectifier*outA);
|
||||||
|
//blend according to densityA control
|
||||||
|
|
||||||
|
highSampleR *= (densityA+1.0);
|
||||||
|
bridgerectifier = fabs(highSampleR)*1.57079633;
|
||||||
|
if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633;
|
||||||
|
//max value for sine function
|
||||||
|
if (densityA > 0) bridgerectifier = sin(bridgerectifier);
|
||||||
|
else bridgerectifier = 1-cos(bridgerectifier);
|
||||||
|
//produce either boosted or starved version
|
||||||
|
if (highSampleR > 0) highSampleR = (highSampleR*(1-outA))+(bridgerectifier*outA);
|
||||||
|
else highSampleR = (highSampleR*(1-outA))-(bridgerectifier*outA);
|
||||||
|
//blend according to densityA control
|
||||||
|
|
||||||
|
midSampleL *= (densityB+1.0);
|
||||||
|
bridgerectifier = fabs(midSampleL)*1.57079633;
|
||||||
|
if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633;
|
||||||
|
//max value for sine function
|
||||||
|
if (densityB > 0) bridgerectifier = sin(bridgerectifier);
|
||||||
|
else bridgerectifier = 1-cos(bridgerectifier);
|
||||||
|
//produce either boosted or starved version
|
||||||
|
if (midSampleL > 0) midSampleL = (midSampleL*(1-outB))+(bridgerectifier*outB);
|
||||||
|
else midSampleL = (midSampleL*(1-outB))-(bridgerectifier*outB);
|
||||||
|
//blend according to densityB control
|
||||||
|
|
||||||
|
midSampleR *= (densityB+1.0);
|
||||||
|
bridgerectifier = fabs(midSampleR)*1.57079633;
|
||||||
|
if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633;
|
||||||
|
//max value for sine function
|
||||||
|
if (densityB > 0) bridgerectifier = sin(bridgerectifier);
|
||||||
|
else bridgerectifier = 1-cos(bridgerectifier);
|
||||||
|
//produce either boosted or starved version
|
||||||
|
if (midSampleR > 0) midSampleR = (midSampleR*(1-outB))+(bridgerectifier*outB);
|
||||||
|
else midSampleR = (midSampleR*(1-outB))-(bridgerectifier*outB);
|
||||||
|
//blend according to densityB control
|
||||||
|
|
||||||
|
bassSampleL *= (densityC+1.0);
|
||||||
|
bridgerectifier = fabs(bassSampleL)*1.57079633;
|
||||||
|
if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633;
|
||||||
|
//max value for sine function
|
||||||
|
if (densityC > 0) bridgerectifier = sin(bridgerectifier);
|
||||||
|
else bridgerectifier = 1-cos(bridgerectifier);
|
||||||
|
//produce either boosted or starved version
|
||||||
|
if (bassSampleL > 0) bassSampleL = (bassSampleL*(1-outC))+(bridgerectifier*outC);
|
||||||
|
else bassSampleL = (bassSampleL*(1-outC))-(bridgerectifier*outC);
|
||||||
|
//blend according to densityC control
|
||||||
|
|
||||||
|
bassSampleR *= (densityC+1.0);
|
||||||
|
bridgerectifier = fabs(bassSampleR)*1.57079633;
|
||||||
|
if (bridgerectifier > 1.57079633) bridgerectifier = 1.57079633;
|
||||||
|
//max value for sine function
|
||||||
|
if (densityC > 0) bridgerectifier = sin(bridgerectifier);
|
||||||
|
else bridgerectifier = 1-cos(bridgerectifier);
|
||||||
|
//produce either boosted or starved version
|
||||||
|
if (bassSampleR > 0) bassSampleR = (bassSampleR*(1-outC))+(bridgerectifier*outC);
|
||||||
|
else bassSampleR = (bassSampleR*(1-outC))-(bridgerectifier*outC);
|
||||||
|
//blend according to densityC control
|
||||||
|
|
||||||
|
inputSampleL = midSampleL;
|
||||||
|
inputSampleL += highSampleL;
|
||||||
|
inputSampleL += bassSampleL;
|
||||||
|
|
||||||
|
inputSampleR = midSampleR;
|
||||||
|
inputSampleR += highSampleR;
|
||||||
|
inputSampleR += bassSampleR;
|
||||||
|
}
|
||||||
|
//end EQ
|
||||||
|
|
||||||
|
//EQ lowpass is after all processing like the compressor that might produce hash
|
||||||
|
if (engageLowpass)
|
||||||
|
{
|
||||||
|
if (flip)
|
||||||
|
{
|
||||||
|
lowpassSampleLAA = (lowpassSampleLAA * (1.0 - iirAmountC)) + (inputSampleL * iirAmountC);
|
||||||
|
inputSampleL = lowpassSampleLAA;
|
||||||
|
lowpassSampleLBA = (lowpassSampleLBA * (1.0 - iirAmountC)) + (inputSampleL * iirAmountC);
|
||||||
|
inputSampleL = lowpassSampleLBA;
|
||||||
|
lowpassSampleLCA = (lowpassSampleLCA * (1.0 - iirAmountC)) + (inputSampleL * iirAmountC);
|
||||||
|
inputSampleL = lowpassSampleLCA;
|
||||||
|
lowpassSampleLDA = (lowpassSampleLDA * (1.0 - iirAmountC)) + (inputSampleL * iirAmountC);
|
||||||
|
inputSampleL = lowpassSampleLDA;
|
||||||
|
lowpassSampleLE = (lowpassSampleLE * (1.0 - iirAmountC)) + (inputSampleL * iirAmountC);
|
||||||
|
inputSampleL = lowpassSampleLE;
|
||||||
|
|
||||||
|
lowpassSampleRAA = (lowpassSampleRAA * (1.0 - iirAmountC)) + (inputSampleR * iirAmountC);
|
||||||
|
inputSampleR = lowpassSampleRAA;
|
||||||
|
lowpassSampleRBA = (lowpassSampleRBA * (1.0 - iirAmountC)) + (inputSampleR * iirAmountC);
|
||||||
|
inputSampleR = lowpassSampleRBA;
|
||||||
|
lowpassSampleRCA = (lowpassSampleRCA * (1.0 - iirAmountC)) + (inputSampleR * iirAmountC);
|
||||||
|
inputSampleR = lowpassSampleRCA;
|
||||||
|
lowpassSampleRDA = (lowpassSampleRDA * (1.0 - iirAmountC)) + (inputSampleR * iirAmountC);
|
||||||
|
inputSampleR = lowpassSampleRDA;
|
||||||
|
lowpassSampleRE = (lowpassSampleRE * (1.0 - iirAmountC)) + (inputSampleR * iirAmountC);
|
||||||
|
inputSampleR = lowpassSampleRE;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
lowpassSampleLAB = (lowpassSampleLAB * (1.0 - iirAmountC)) + (inputSampleL * iirAmountC);
|
||||||
|
inputSampleL = lowpassSampleLAB;
|
||||||
|
lowpassSampleLBB = (lowpassSampleLBB * (1.0 - iirAmountC)) + (inputSampleL * iirAmountC);
|
||||||
|
inputSampleL = lowpassSampleLBB;
|
||||||
|
lowpassSampleLCB = (lowpassSampleLCB * (1.0 - iirAmountC)) + (inputSampleL * iirAmountC);
|
||||||
|
inputSampleL = lowpassSampleLCB;
|
||||||
|
lowpassSampleLDB = (lowpassSampleLDB * (1.0 - iirAmountC)) + (inputSampleL * iirAmountC);
|
||||||
|
inputSampleL = lowpassSampleLDB;
|
||||||
|
lowpassSampleLF = (lowpassSampleLF * (1.0 - iirAmountC)) + (inputSampleL * iirAmountC);
|
||||||
|
inputSampleL = lowpassSampleLF;
|
||||||
|
|
||||||
|
lowpassSampleRAB = (lowpassSampleRAB * (1.0 - iirAmountC)) + (inputSampleR * iirAmountC);
|
||||||
|
inputSampleR = lowpassSampleRAB;
|
||||||
|
lowpassSampleRBB = (lowpassSampleRBB * (1.0 - iirAmountC)) + (inputSampleR * iirAmountC);
|
||||||
|
inputSampleR = lowpassSampleRBB;
|
||||||
|
lowpassSampleRCB = (lowpassSampleRCB * (1.0 - iirAmountC)) + (inputSampleR * iirAmountC);
|
||||||
|
inputSampleR = lowpassSampleRCB;
|
||||||
|
lowpassSampleRDB = (lowpassSampleRDB * (1.0 - iirAmountC)) + (inputSampleR * iirAmountC);
|
||||||
|
inputSampleR = lowpassSampleRDB;
|
||||||
|
lowpassSampleRF = (lowpassSampleRF * (1.0 - iirAmountC)) + (inputSampleR * iirAmountC);
|
||||||
|
inputSampleR = lowpassSampleRF;
|
||||||
|
}
|
||||||
|
lowpassSampleLG = (lowpassSampleLG * (1.0 - iirAmountC)) + (inputSampleL * iirAmountC);
|
||||||
|
lowpassSampleRG = (lowpassSampleRG * (1.0 - iirAmountC)) + (inputSampleR * iirAmountC);
|
||||||
|
|
||||||
|
inputSampleL = (lowpassSampleLG * (1.0 - iirAmountC)) + (inputSampleL * iirAmountC);
|
||||||
|
inputSampleR = (lowpassSampleRG * (1.0 - iirAmountC)) + (inputSampleR * iirAmountC);
|
||||||
|
}
|
||||||
|
|
||||||
|
//built in output trim and dry/wet if desired
|
||||||
|
if (outputgain != 1.0) {
|
||||||
|
inputSampleL *= outputgain;
|
||||||
|
inputSampleR *= outputgain;
|
||||||
|
}
|
||||||
|
|
||||||
|
//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;
|
||||||
|
|
||||||
|
uint32_t fpdL;
|
||||||
|
uint32_t fpdR;
|
||||||
|
//default stuff
|
||||||
|
|
||||||
|
double lastSampleL;
|
||||||
|
double last2SampleL;
|
||||||
|
double lastSampleR;
|
||||||
|
double last2SampleR;
|
||||||
|
|
||||||
|
//begin EQ
|
||||||
|
double iirHighSampleLA;
|
||||||
|
double iirHighSampleLB;
|
||||||
|
double iirHighSampleLC;
|
||||||
|
double iirHighSampleLD;
|
||||||
|
double iirHighSampleLE;
|
||||||
|
double iirLowSampleLA;
|
||||||
|
double iirLowSampleLB;
|
||||||
|
double iirLowSampleLC;
|
||||||
|
double iirLowSampleLD;
|
||||||
|
double iirLowSampleLE;
|
||||||
|
double iirHighSampleL;
|
||||||
|
double iirLowSampleL;
|
||||||
|
|
||||||
|
double iirHighSampleRA;
|
||||||
|
double iirHighSampleRB;
|
||||||
|
double iirHighSampleRC;
|
||||||
|
double iirHighSampleRD;
|
||||||
|
double iirHighSampleRE;
|
||||||
|
double iirLowSampleRA;
|
||||||
|
double iirLowSampleRB;
|
||||||
|
double iirLowSampleRC;
|
||||||
|
double iirLowSampleRD;
|
||||||
|
double iirLowSampleRE;
|
||||||
|
double iirHighSampleR;
|
||||||
|
double iirLowSampleR;
|
||||||
|
|
||||||
|
double tripletLA;
|
||||||
|
double tripletLB;
|
||||||
|
double tripletLC;
|
||||||
|
double tripletFactorL;
|
||||||
|
|
||||||
|
double tripletRA;
|
||||||
|
double tripletRB;
|
||||||
|
double tripletRC;
|
||||||
|
double tripletFactorR;
|
||||||
|
|
||||||
|
double lowpassSampleLAA;
|
||||||
|
double lowpassSampleLAB;
|
||||||
|
double lowpassSampleLBA;
|
||||||
|
double lowpassSampleLBB;
|
||||||
|
double lowpassSampleLCA;
|
||||||
|
double lowpassSampleLCB;
|
||||||
|
double lowpassSampleLDA;
|
||||||
|
double lowpassSampleLDB;
|
||||||
|
double lowpassSampleLE;
|
||||||
|
double lowpassSampleLF;
|
||||||
|
double lowpassSampleLG;
|
||||||
|
|
||||||
|
double lowpassSampleRAA;
|
||||||
|
double lowpassSampleRAB;
|
||||||
|
double lowpassSampleRBA;
|
||||||
|
double lowpassSampleRBB;
|
||||||
|
double lowpassSampleRCA;
|
||||||
|
double lowpassSampleRCB;
|
||||||
|
double lowpassSampleRDA;
|
||||||
|
double lowpassSampleRDB;
|
||||||
|
double lowpassSampleRE;
|
||||||
|
double lowpassSampleRF;
|
||||||
|
double lowpassSampleRG;
|
||||||
|
|
||||||
|
double highpassSampleLAA;
|
||||||
|
double highpassSampleLAB;
|
||||||
|
double highpassSampleLBA;
|
||||||
|
double highpassSampleLBB;
|
||||||
|
double highpassSampleLCA;
|
||||||
|
double highpassSampleLCB;
|
||||||
|
double highpassSampleLDA;
|
||||||
|
double highpassSampleLDB;
|
||||||
|
double highpassSampleLE;
|
||||||
|
double highpassSampleLF;
|
||||||
|
|
||||||
|
double highpassSampleRAA;
|
||||||
|
double highpassSampleRAB;
|
||||||
|
double highpassSampleRBA;
|
||||||
|
double highpassSampleRBB;
|
||||||
|
double highpassSampleRCA;
|
||||||
|
double highpassSampleRCB;
|
||||||
|
double highpassSampleRDA;
|
||||||
|
double highpassSampleRDB;
|
||||||
|
double highpassSampleRE;
|
||||||
|
double highpassSampleRF;
|
||||||
|
|
||||||
|
bool flip;
|
||||||
|
int flipthree;
|
||||||
|
//end EQ
|
||||||
|
|
||||||
|
|
||||||
|
float A;
|
||||||
|
float B;
|
||||||
|
float C;
|
||||||
|
float D;
|
||||||
|
float E;
|
||||||
|
float F;
|
||||||
|
float G;
|
||||||
|
float H;
|
||||||
|
|
||||||
|
double clamp(double& value) {
|
||||||
|
if (value > 1) {
|
||||||
|
value = 1;
|
||||||
|
} else if (value < 0) {
|
||||||
|
value = 0;
|
||||||
|
}
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
80
filter/chebyshev.h
Normal file
80
filter/chebyshev.h
Normal file
@@ -0,0 +1,80 @@
|
|||||||
|
#pragma once
|
||||||
|
#define _USE_MATH_DEFINES
|
||||||
|
#include <math.h>
|
||||||
|
#include <array>
|
||||||
|
|
||||||
|
namespace trnr::lib::filter {
|
||||||
|
class chebyshev {
|
||||||
|
public:
|
||||||
|
void set_samplerate(double _samplerate) {
|
||||||
|
samplerate = _samplerate;
|
||||||
|
}
|
||||||
|
|
||||||
|
void process_sample(double& input, double frequency) {
|
||||||
|
|
||||||
|
if (frequency >= 20000.f) {
|
||||||
|
frequency = 20000.f;
|
||||||
|
}
|
||||||
|
|
||||||
|
// First calculate the prewarped digital frequency :
|
||||||
|
auto K = tanf(M_PI * frequency / samplerate);
|
||||||
|
|
||||||
|
// Now we calc some Coefficients :
|
||||||
|
auto sg = sinh(passband_ripple);
|
||||||
|
auto cg = cosh(passband_ripple);
|
||||||
|
cg *= cg;
|
||||||
|
|
||||||
|
std::array<double, 4> coeff;
|
||||||
|
coeff[0] = 1 / (cg - 0.85355339059327376220042218105097);
|
||||||
|
coeff[1] = K * coeff[0] * sg * 1.847759065022573512256366378792;
|
||||||
|
coeff[2] = 1 / (cg - 0.14644660940672623779957781894758);
|
||||||
|
coeff[3] = K * coeff[2] * sg * 0.76536686473017954345691996806;
|
||||||
|
|
||||||
|
K *= K; // (just to optimize it a little bit)
|
||||||
|
|
||||||
|
// Calculate the first biquad:
|
||||||
|
a0 = 1 / (coeff[1] + K + coeff[0]);
|
||||||
|
a1 = 2 * (coeff[0] - K) * a0;
|
||||||
|
a2 = (coeff[1] - K - coeff[0]) * a0;
|
||||||
|
b0 = a0 * K;
|
||||||
|
b1 = 2 * b0;
|
||||||
|
b2 = b0;
|
||||||
|
|
||||||
|
// Calculate the second biquad:
|
||||||
|
a3 = 1 / (coeff[3] + K + coeff[2]);
|
||||||
|
a4 = 2 * (coeff[2] - K) * a3;
|
||||||
|
a5 = (coeff[3] - K - coeff[2]) * a3;
|
||||||
|
b3 = a3 * K;
|
||||||
|
b4 = 2 * b3;
|
||||||
|
b5 = b3;
|
||||||
|
|
||||||
|
// Then calculate the output as follows:
|
||||||
|
auto Stage1 = b0 * input + state0;
|
||||||
|
state0 = b1 * input + a1 * Stage1 + state1;
|
||||||
|
state1 = b2 * input + a2 * Stage1;
|
||||||
|
input = b3 * Stage1 + state2;
|
||||||
|
state2 = b4 * Stage1 + a4 * input + state3;
|
||||||
|
state3 = b5 * Stage1 + a5 * input;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
double samplerate = 0;
|
||||||
|
double a0 = 0;
|
||||||
|
double a1 = 0;
|
||||||
|
double a2 = 0;
|
||||||
|
double a3 = 0;
|
||||||
|
double a4 = 0;
|
||||||
|
double a5 = 0;
|
||||||
|
double b0 = 0;
|
||||||
|
double b1 = 0;
|
||||||
|
double b2 = 0;
|
||||||
|
double b3 = 0;
|
||||||
|
double b4 = 0;
|
||||||
|
double b5 = 0;
|
||||||
|
double state0 = 0;
|
||||||
|
double state1 = 0;
|
||||||
|
double state2 = 0;
|
||||||
|
double state3 = 0;
|
||||||
|
double passband_ripple = 1;
|
||||||
|
};
|
||||||
|
}
|
||||||
313
filter/ybandpass.h
Normal file
313
filter/ybandpass.h
Normal file
@@ -0,0 +1,313 @@
|
|||||||
|
#pragma once
|
||||||
|
#define _USE_MATH_DEFINES
|
||||||
|
#include <math.h>
|
||||||
|
#include <array>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
namespace trnr::lib::filter {
|
||||||
|
// Bandpass filter based on YBandpass by Chris Johnson
|
||||||
|
class ybandpass {
|
||||||
|
public:
|
||||||
|
ybandpass(double _samplerate)
|
||||||
|
: samplerate { _samplerate }
|
||||||
|
, A { 0.1f }
|
||||||
|
, B { 1.0f }
|
||||||
|
, C { 0.0f }
|
||||||
|
, D { 0.1f }
|
||||||
|
, E { 0.9f }
|
||||||
|
, F { 1.0f }
|
||||||
|
, fpdL { 0 }
|
||||||
|
, fpdR { 0 }
|
||||||
|
, biquad { 0 }
|
||||||
|
{
|
||||||
|
for (int x = 0; x < biq_total; x++) {
|
||||||
|
biquad[x] = 0.0;
|
||||||
|
}
|
||||||
|
powFactorA = 1.0;
|
||||||
|
powFactorB = 1.0;
|
||||||
|
inTrimA = 0.1;
|
||||||
|
inTrimB = 0.1;
|
||||||
|
outTrimA = 1.0;
|
||||||
|
outTrimB = 1.0;
|
||||||
|
for (int x = 0; x < fix_total; x++) {
|
||||||
|
fixA[x] = 0.0;
|
||||||
|
fixB[x] = 0.0;
|
||||||
|
}
|
||||||
|
|
||||||
|
fpdL = 1.0;
|
||||||
|
while (fpdL < 16386)
|
||||||
|
fpdL = rand() * UINT32_MAX;
|
||||||
|
fpdR = 1.0;
|
||||||
|
while (fpdR < 16386)
|
||||||
|
fpdR = rand() * UINT32_MAX;
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_samplerate(double _samplerate) {
|
||||||
|
samplerate = _samplerate;
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_drive(float value)
|
||||||
|
{
|
||||||
|
A = value * 0.9 + 0.1;
|
||||||
|
}
|
||||||
|
void set_frequency(float value)
|
||||||
|
{
|
||||||
|
B = value;
|
||||||
|
}
|
||||||
|
void set_resonance(float value)
|
||||||
|
{
|
||||||
|
C = value;
|
||||||
|
}
|
||||||
|
void set_edge(float value)
|
||||||
|
{
|
||||||
|
D = value;
|
||||||
|
}
|
||||||
|
void set_output(float value)
|
||||||
|
{
|
||||||
|
E = value;
|
||||||
|
}
|
||||||
|
void set_mix(float value)
|
||||||
|
{
|
||||||
|
F = value;
|
||||||
|
}
|
||||||
|
void processblock(double** inputs, double** outputs, int blockSize)
|
||||||
|
{
|
||||||
|
double* in1 = inputs[0];
|
||||||
|
double* in2 = inputs[1];
|
||||||
|
double* out1 = outputs[0];
|
||||||
|
double* out2 = outputs[1];
|
||||||
|
|
||||||
|
int inFramesToProcess = blockSize;
|
||||||
|
double overallscale = 1.0;
|
||||||
|
overallscale /= 44100.0;
|
||||||
|
overallscale *= samplerate;
|
||||||
|
|
||||||
|
inTrimA = inTrimB;
|
||||||
|
inTrimB = A * 10.0;
|
||||||
|
|
||||||
|
biquad[biq_freq] = pow(B, 3) * 20000.0;
|
||||||
|
if (biquad[biq_freq] < 15.0)
|
||||||
|
biquad[biq_freq] = 15.0;
|
||||||
|
biquad[biq_freq] /= samplerate;
|
||||||
|
biquad[biq_reso] = (pow(C, 2) * 15.0) + 0.5571;
|
||||||
|
biquad[biq_aA0] = biquad[biq_aB0];
|
||||||
|
// biquad[biq_aA1] = biquad[biq_aB1];
|
||||||
|
biquad[biq_aA2] = biquad[biq_aB2];
|
||||||
|
biquad[biq_bA1] = biquad[biq_bB1];
|
||||||
|
biquad[biq_bA2] = biquad[biq_bB2];
|
||||||
|
// previous run through the buffer is still in the filter, so we move it
|
||||||
|
// to the A section and now it's the new starting point.
|
||||||
|
double K = tan(M_PI * biquad[biq_freq]);
|
||||||
|
double norm = 1.0 / (1.0 + K / biquad[biq_reso] + K * K);
|
||||||
|
biquad[biq_aB0] = K / biquad[biq_reso] * norm;
|
||||||
|
// biquad[biq_aB1] = 0.0; //bandpass can simplify the biquad kernel: leave out this multiply
|
||||||
|
biquad[biq_aB2] = -biquad[biq_aB0];
|
||||||
|
biquad[biq_bB1] = 2.0 * (K * K - 1.0) * norm;
|
||||||
|
biquad[biq_bB2] = (1.0 - K / biquad[biq_reso] + K * K) * norm;
|
||||||
|
// for the coefficient-interpolated biquad filter
|
||||||
|
|
||||||
|
powFactorA = powFactorB;
|
||||||
|
powFactorB = pow(D + 0.9, 4);
|
||||||
|
|
||||||
|
// 1.0 == target neutral
|
||||||
|
|
||||||
|
outTrimA = outTrimB;
|
||||||
|
outTrimB = E;
|
||||||
|
|
||||||
|
double wet = F;
|
||||||
|
|
||||||
|
fixA[fix_freq] = fixB[fix_freq] = 20000.0 / samplerate;
|
||||||
|
fixA[fix_reso] = fixB[fix_reso] = 0.7071; // butterworth Q
|
||||||
|
|
||||||
|
K = tan(M_PI * fixA[fix_freq]);
|
||||||
|
norm = 1.0 / (1.0 + K / fixA[fix_reso] + K * K);
|
||||||
|
fixA[fix_a0] = fixB[fix_a0] = K * K * norm;
|
||||||
|
fixA[fix_a1] = fixB[fix_a1] = 2.0 * fixA[fix_a0];
|
||||||
|
fixA[fix_a2] = fixB[fix_a2] = fixA[fix_a0];
|
||||||
|
fixA[fix_b1] = fixB[fix_b1] = 2.0 * (K * K - 1.0) * norm;
|
||||||
|
fixA[fix_b2] = fixB[fix_b2] = (1.0 - K / fixA[fix_reso] + K * K) * norm;
|
||||||
|
// for the fixed-position biquad filter
|
||||||
|
|
||||||
|
for (int s = 0; s < blockSize; s++) {
|
||||||
|
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 drySampleL = inputSampleL;
|
||||||
|
double drySampleR = inputSampleR;
|
||||||
|
|
||||||
|
double temp = (double)s / inFramesToProcess;
|
||||||
|
biquad[biq_a0] = (biquad[biq_aA0] * temp) + (biquad[biq_aB0] * (1.0 - temp));
|
||||||
|
// biquad[biq_a1] = (biquad[biq_aA1]*temp)+(biquad[biq_aB1]*(1.0-temp));
|
||||||
|
biquad[biq_a2] = (biquad[biq_aA2] * temp) + (biquad[biq_aB2] * (1.0 - temp));
|
||||||
|
biquad[biq_b1] = (biquad[biq_bA1] * temp) + (biquad[biq_bB1] * (1.0 - temp));
|
||||||
|
biquad[biq_b2] = (biquad[biq_bA2] * temp) + (biquad[biq_bB2] * (1.0 - temp));
|
||||||
|
// this is the interpolation code for the biquad
|
||||||
|
double powFactor = (powFactorA * temp) + (powFactorB * (1.0 - temp));
|
||||||
|
double inTrim = (inTrimA * temp) + (inTrimB * (1.0 - temp));
|
||||||
|
double outTrim = (outTrimA * temp) + (outTrimB * (1.0 - temp));
|
||||||
|
|
||||||
|
inputSampleL *= inTrim;
|
||||||
|
inputSampleR *= inTrim;
|
||||||
|
|
||||||
|
temp = (inputSampleL * fixA[fix_a0]) + fixA[fix_sL1];
|
||||||
|
fixA[fix_sL1] = (inputSampleL * fixA[fix_a1]) - (temp * fixA[fix_b1]) + fixA[fix_sL2];
|
||||||
|
fixA[fix_sL2] = (inputSampleL * fixA[fix_a2]) - (temp * fixA[fix_b2]);
|
||||||
|
inputSampleL = temp; // fixed biquad filtering ultrasonics
|
||||||
|
temp = (inputSampleR * fixA[fix_a0]) + fixA[fix_sR1];
|
||||||
|
fixA[fix_sR1] = (inputSampleR * fixA[fix_a1]) - (temp * fixA[fix_b1]) + fixA[fix_sR2];
|
||||||
|
fixA[fix_sR2] = (inputSampleR * fixA[fix_a2]) - (temp * fixA[fix_b2]);
|
||||||
|
inputSampleR = temp; // fixed biquad filtering ultrasonics
|
||||||
|
|
||||||
|
// encode/decode courtesy of torridgristle under the MIT license
|
||||||
|
if (inputSampleL > 1.0)
|
||||||
|
inputSampleL = 1.0;
|
||||||
|
else if (inputSampleL > 0.0)
|
||||||
|
inputSampleL = 1.0 - pow(1.0 - inputSampleL, powFactor);
|
||||||
|
if (inputSampleL < -1.0)
|
||||||
|
inputSampleL = -1.0;
|
||||||
|
else if (inputSampleL < 0.0)
|
||||||
|
inputSampleL = -1.0 + pow(1.0 + inputSampleL, powFactor);
|
||||||
|
if (inputSampleR > 1.0)
|
||||||
|
inputSampleR = 1.0;
|
||||||
|
else if (inputSampleR > 0.0)
|
||||||
|
inputSampleR = 1.0 - pow(1.0 - inputSampleR, powFactor);
|
||||||
|
if (inputSampleR < -1.0)
|
||||||
|
inputSampleR = -1.0;
|
||||||
|
else if (inputSampleR < 0.0)
|
||||||
|
inputSampleR = -1.0 + pow(1.0 + inputSampleR, powFactor);
|
||||||
|
|
||||||
|
temp = (inputSampleL * biquad[biq_a0]) + biquad[biq_sL1];
|
||||||
|
biquad[biq_sL1] = -(temp * biquad[biq_b1]) + biquad[biq_sL2];
|
||||||
|
biquad[biq_sL2] = (inputSampleL * biquad[biq_a2]) - (temp * biquad[biq_b2]);
|
||||||
|
inputSampleL = temp; // coefficient interpolating biquad filter
|
||||||
|
temp = (inputSampleR * biquad[biq_a0]) + biquad[biq_sR1];
|
||||||
|
biquad[biq_sR1] = -(temp * biquad[biq_b1]) + biquad[biq_sR2];
|
||||||
|
biquad[biq_sR2] = (inputSampleR * biquad[biq_a2]) - (temp * biquad[biq_b2]);
|
||||||
|
inputSampleR = temp; // coefficient interpolating biquad filter
|
||||||
|
|
||||||
|
// encode/decode courtesy of torridgristle under the MIT license
|
||||||
|
if (inputSampleL > 1.0)
|
||||||
|
inputSampleL = 1.0;
|
||||||
|
else if (inputSampleL > 0.0)
|
||||||
|
inputSampleL = 1.0 - pow(1.0 - inputSampleL, (1.0 / powFactor));
|
||||||
|
if (inputSampleL < -1.0)
|
||||||
|
inputSampleL = -1.0;
|
||||||
|
else if (inputSampleL < 0.0)
|
||||||
|
inputSampleL = -1.0 + pow(1.0 + inputSampleL, (1.0 / powFactor));
|
||||||
|
if (inputSampleR > 1.0)
|
||||||
|
inputSampleR = 1.0;
|
||||||
|
else if (inputSampleR > 0.0)
|
||||||
|
inputSampleR = 1.0 - pow(1.0 - inputSampleR, (1.0 / powFactor));
|
||||||
|
if (inputSampleR < -1.0)
|
||||||
|
inputSampleR = -1.0;
|
||||||
|
else if (inputSampleR < 0.0)
|
||||||
|
inputSampleR = -1.0 + pow(1.0 + inputSampleR, (1.0 / powFactor));
|
||||||
|
|
||||||
|
inputSampleL *= outTrim;
|
||||||
|
inputSampleR *= outTrim;
|
||||||
|
|
||||||
|
temp = (inputSampleL * fixB[fix_a0]) + fixB[fix_sL1];
|
||||||
|
fixB[fix_sL1] = (inputSampleL * fixB[fix_a1]) - (temp * fixB[fix_b1]) + fixB[fix_sL2];
|
||||||
|
fixB[fix_sL2] = (inputSampleL * fixB[fix_a2]) - (temp * fixB[fix_b2]);
|
||||||
|
inputSampleL = temp; // fixed biquad filtering ultrasonics
|
||||||
|
temp = (inputSampleR * fixB[fix_a0]) + fixB[fix_sR1];
|
||||||
|
fixB[fix_sR1] = (inputSampleR * fixB[fix_a1]) - (temp * fixB[fix_b1]) + fixB[fix_sR2];
|
||||||
|
fixB[fix_sR2] = (inputSampleR * fixB[fix_a2]) - (temp * fixB[fix_b2]);
|
||||||
|
inputSampleR = temp; // fixed biquad filtering ultrasonics
|
||||||
|
|
||||||
|
if (wet < 1.0) {
|
||||||
|
inputSampleL = (inputSampleL * wet) + (drySampleL * (1.0 - wet));
|
||||||
|
inputSampleR = (inputSampleR * wet) + (drySampleR * (1.0 - wet));
|
||||||
|
}
|
||||||
|
|
||||||
|
// begin 32 bit stereo floating point dither
|
||||||
|
int expon;
|
||||||
|
frexpf((float)inputSampleL, &expon);
|
||||||
|
fpdL ^= fpdL << 13;
|
||||||
|
fpdL ^= fpdL >> 17;
|
||||||
|
fpdL ^= fpdL << 5;
|
||||||
|
inputSampleL += ((double(fpdL) - uint32_t(0x7fffffff)) * 5.5e-36l * pow(2, expon + 62));
|
||||||
|
frexpf((float)inputSampleR, &expon);
|
||||||
|
fpdR ^= fpdR << 13;
|
||||||
|
fpdR ^= fpdR >> 17;
|
||||||
|
fpdR ^= fpdR << 5;
|
||||||
|
inputSampleR += ((double(fpdR) - uint32_t(0x7fffffff)) * 5.5e-36l * pow(2, expon + 62));
|
||||||
|
// end 32 bit stereo floating point dither
|
||||||
|
|
||||||
|
*out1 = inputSampleL;
|
||||||
|
*out2 = inputSampleR;
|
||||||
|
|
||||||
|
in1++;
|
||||||
|
in2++;
|
||||||
|
out1++;
|
||||||
|
out2++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
double samplerate;
|
||||||
|
enum {
|
||||||
|
biq_freq,
|
||||||
|
biq_reso,
|
||||||
|
biq_a0,
|
||||||
|
biq_a1,
|
||||||
|
biq_a2,
|
||||||
|
biq_b1,
|
||||||
|
biq_b2,
|
||||||
|
biq_aA0,
|
||||||
|
biq_aA1,
|
||||||
|
biq_aA2,
|
||||||
|
biq_bA1,
|
||||||
|
biq_bA2,
|
||||||
|
biq_aB0,
|
||||||
|
biq_aB1,
|
||||||
|
biq_aB2,
|
||||||
|
biq_bB1,
|
||||||
|
biq_bB2,
|
||||||
|
biq_sL1,
|
||||||
|
biq_sL2,
|
||||||
|
biq_sR1,
|
||||||
|
biq_sR2,
|
||||||
|
biq_total
|
||||||
|
}; // coefficient interpolating biquad filter, stereo
|
||||||
|
std::array<double, biq_total> biquad;
|
||||||
|
|
||||||
|
double powFactorA;
|
||||||
|
double powFactorB;
|
||||||
|
double inTrimA;
|
||||||
|
double inTrimB;
|
||||||
|
double outTrimA;
|
||||||
|
double outTrimB;
|
||||||
|
|
||||||
|
enum {
|
||||||
|
fix_freq,
|
||||||
|
fix_reso,
|
||||||
|
fix_a0,
|
||||||
|
fix_a1,
|
||||||
|
fix_a2,
|
||||||
|
fix_b1,
|
||||||
|
fix_b2,
|
||||||
|
fix_sL1,
|
||||||
|
fix_sL2,
|
||||||
|
fix_sR1,
|
||||||
|
fix_sR2,
|
||||||
|
fix_total
|
||||||
|
}; // fixed frequency biquad filter for ultrasonics, stereo
|
||||||
|
std::array<double, fix_total> fixA;
|
||||||
|
std::array<double, fix_total> fixB;
|
||||||
|
|
||||||
|
uint32_t fpdL;
|
||||||
|
uint32_t fpdR;
|
||||||
|
// default stuff
|
||||||
|
|
||||||
|
float A;
|
||||||
|
float B;
|
||||||
|
float C;
|
||||||
|
float D;
|
||||||
|
float E;
|
||||||
|
float F; // parameters. Always 0-1, and we scale/alter them elsewhere.
|
||||||
|
};
|
||||||
|
}
|
||||||
313
filter/yhighpass.h
Normal file
313
filter/yhighpass.h
Normal file
@@ -0,0 +1,313 @@
|
|||||||
|
#pragma once
|
||||||
|
#define _USE_MATH_DEFINES
|
||||||
|
#include <math.h>
|
||||||
|
#include <array>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
namespace trnr::lib::filter {
|
||||||
|
// Highpass filter based on YHighpass by Chris Johnson
|
||||||
|
class yhighpass {
|
||||||
|
public:
|
||||||
|
yhighpass(double _samplerate)
|
||||||
|
: samplerate { _samplerate }
|
||||||
|
, A { 0.1f }
|
||||||
|
, B { 1.0f }
|
||||||
|
, C { 0.0f }
|
||||||
|
, D { 0.1f }
|
||||||
|
, E { 0.9f }
|
||||||
|
, F { 1.0f }
|
||||||
|
, fpdL { 0 }
|
||||||
|
, fpdR { 0 }
|
||||||
|
, biquad { 0 }
|
||||||
|
{
|
||||||
|
for (int x = 0; x < biq_total; x++) {
|
||||||
|
biquad[x] = 0.0;
|
||||||
|
}
|
||||||
|
powFactorA = 1.0;
|
||||||
|
powFactorB = 1.0;
|
||||||
|
inTrimA = 0.1;
|
||||||
|
inTrimB = 0.1;
|
||||||
|
outTrimA = 1.0;
|
||||||
|
outTrimB = 1.0;
|
||||||
|
for (int x = 0; x < fix_total; x++) {
|
||||||
|
fixA[x] = 0.0;
|
||||||
|
fixB[x] = 0.0;
|
||||||
|
}
|
||||||
|
|
||||||
|
fpdL = 1.0;
|
||||||
|
while (fpdL < 16386)
|
||||||
|
fpdL = rand() * UINT32_MAX;
|
||||||
|
fpdR = 1.0;
|
||||||
|
while (fpdR < 16386)
|
||||||
|
fpdR = rand() * UINT32_MAX;
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_samplerate(double _samplerate) {
|
||||||
|
samplerate = _samplerate;
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_drive(float value)
|
||||||
|
{
|
||||||
|
A = value * 0.9 + 0.1;
|
||||||
|
}
|
||||||
|
void set_frequency(float value)
|
||||||
|
{
|
||||||
|
B = value;
|
||||||
|
}
|
||||||
|
void set_resonance(float value)
|
||||||
|
{
|
||||||
|
C = value;
|
||||||
|
}
|
||||||
|
void set_edge(float value)
|
||||||
|
{
|
||||||
|
D = value;
|
||||||
|
}
|
||||||
|
void set_output(float value)
|
||||||
|
{
|
||||||
|
E = value;
|
||||||
|
}
|
||||||
|
void set_mix(float value)
|
||||||
|
{
|
||||||
|
F = value;
|
||||||
|
}
|
||||||
|
void processblock(double** inputs, double** outputs, int blockSize)
|
||||||
|
{
|
||||||
|
double* in1 = inputs[0];
|
||||||
|
double* in2 = inputs[1];
|
||||||
|
double* out1 = outputs[0];
|
||||||
|
double* out2 = outputs[1];
|
||||||
|
|
||||||
|
int inFramesToProcess = blockSize;
|
||||||
|
double overallscale = 1.0;
|
||||||
|
overallscale /= 44100.0;
|
||||||
|
overallscale *= samplerate;
|
||||||
|
|
||||||
|
inTrimA = inTrimB;
|
||||||
|
inTrimB = A * 10.0;
|
||||||
|
|
||||||
|
biquad[biq_freq] = pow(B, 3) * 20000.0;
|
||||||
|
if (biquad[biq_freq] < 15.0)
|
||||||
|
biquad[biq_freq] = 15.0;
|
||||||
|
biquad[biq_freq] /= samplerate;
|
||||||
|
biquad[biq_reso] = (pow(C, 2) * 15.0) + 0.5571;
|
||||||
|
biquad[biq_aA0] = biquad[biq_aB0];
|
||||||
|
biquad[biq_aA1] = biquad[biq_aB1];
|
||||||
|
biquad[biq_aA2] = biquad[biq_aB2];
|
||||||
|
biquad[biq_bA1] = biquad[biq_bB1];
|
||||||
|
biquad[biq_bA2] = biquad[biq_bB2];
|
||||||
|
// previous run through the buffer is still in the filter, so we move it
|
||||||
|
// to the A section and now it's the new starting point.
|
||||||
|
double K = tan(M_PI * biquad[biq_freq]);
|
||||||
|
double norm = 1.0 / (1.0 + K / biquad[biq_reso] + K * K);
|
||||||
|
biquad[biq_aB0] = norm;
|
||||||
|
biquad[biq_aB1] = -2.0 * biquad[biq_aB0];
|
||||||
|
biquad[biq_aB2] = biquad[biq_aB0];
|
||||||
|
biquad[biq_bB1] = 2.0 * (K * K - 1.0) * norm;
|
||||||
|
biquad[biq_bB2] = (1.0 - K / biquad[biq_reso] + K * K) * norm;
|
||||||
|
// for the coefficient-interpolated biquad filter
|
||||||
|
|
||||||
|
powFactorA = powFactorB;
|
||||||
|
powFactorB = pow(D + 0.9, 4);
|
||||||
|
|
||||||
|
// 1.0 == target neutral
|
||||||
|
|
||||||
|
outTrimA = outTrimB;
|
||||||
|
outTrimB = E;
|
||||||
|
|
||||||
|
double wet = F;
|
||||||
|
|
||||||
|
fixA[fix_freq] = fixB[fix_freq] = 20000.0 / samplerate;
|
||||||
|
fixA[fix_reso] = fixB[fix_reso] = 0.7071; // butterworth Q
|
||||||
|
|
||||||
|
K = tan(M_PI * fixA[fix_freq]);
|
||||||
|
norm = 1.0 / (1.0 + K / fixA[fix_reso] + K * K);
|
||||||
|
fixA[fix_a0] = fixB[fix_a0] = K * K * norm;
|
||||||
|
fixA[fix_a1] = fixB[fix_a1] = 2.0 * fixA[fix_a0];
|
||||||
|
fixA[fix_a2] = fixB[fix_a2] = fixA[fix_a0];
|
||||||
|
fixA[fix_b1] = fixB[fix_b1] = 2.0 * (K * K - 1.0) * norm;
|
||||||
|
fixA[fix_b2] = fixB[fix_b2] = (1.0 - K / fixA[fix_reso] + K * K) * norm;
|
||||||
|
// for the fixed-position biquad filter
|
||||||
|
|
||||||
|
for (int s = 0; s < blockSize; s++) {
|
||||||
|
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 drySampleL = inputSampleL;
|
||||||
|
double drySampleR = inputSampleR;
|
||||||
|
|
||||||
|
double temp = (double)s / inFramesToProcess;
|
||||||
|
biquad[biq_a0] = (biquad[biq_aA0] * temp) + (biquad[biq_aB0] * (1.0 - temp));
|
||||||
|
biquad[biq_a1] = (biquad[biq_aA1] * temp) + (biquad[biq_aB1] * (1.0 - temp));
|
||||||
|
biquad[biq_a2] = (biquad[biq_aA2] * temp) + (biquad[biq_aB2] * (1.0 - temp));
|
||||||
|
biquad[biq_b1] = (biquad[biq_bA1] * temp) + (biquad[biq_bB1] * (1.0 - temp));
|
||||||
|
biquad[biq_b2] = (biquad[biq_bA2] * temp) + (biquad[biq_bB2] * (1.0 - temp));
|
||||||
|
// this is the interpolation code for the biquad
|
||||||
|
double powFactor = (powFactorA * temp) + (powFactorB * (1.0 - temp));
|
||||||
|
double inTrim = (inTrimA * temp) + (inTrimB * (1.0 - temp));
|
||||||
|
double outTrim = (outTrimA * temp) + (outTrimB * (1.0 - temp));
|
||||||
|
|
||||||
|
inputSampleL *= inTrim;
|
||||||
|
inputSampleR *= inTrim;
|
||||||
|
|
||||||
|
temp = (inputSampleL * fixA[fix_a0]) + fixA[fix_sL1];
|
||||||
|
fixA[fix_sL1] = (inputSampleL * fixA[fix_a1]) - (temp * fixA[fix_b1]) + fixA[fix_sL2];
|
||||||
|
fixA[fix_sL2] = (inputSampleL * fixA[fix_a2]) - (temp * fixA[fix_b2]);
|
||||||
|
inputSampleL = temp; // fixed biquad filtering ultrasonics
|
||||||
|
temp = (inputSampleR * fixA[fix_a0]) + fixA[fix_sR1];
|
||||||
|
fixA[fix_sR1] = (inputSampleR * fixA[fix_a1]) - (temp * fixA[fix_b1]) + fixA[fix_sR2];
|
||||||
|
fixA[fix_sR2] = (inputSampleR * fixA[fix_a2]) - (temp * fixA[fix_b2]);
|
||||||
|
inputSampleR = temp; // fixed biquad filtering ultrasonics
|
||||||
|
|
||||||
|
// encode/decode courtesy of torridgristle under the MIT license
|
||||||
|
if (inputSampleL > 1.0)
|
||||||
|
inputSampleL = 1.0;
|
||||||
|
else if (inputSampleL > 0.0)
|
||||||
|
inputSampleL = 1.0 - pow(1.0 - inputSampleL, powFactor);
|
||||||
|
if (inputSampleL < -1.0)
|
||||||
|
inputSampleL = -1.0;
|
||||||
|
else if (inputSampleL < 0.0)
|
||||||
|
inputSampleL = -1.0 + pow(1.0 + inputSampleL, powFactor);
|
||||||
|
if (inputSampleR > 1.0)
|
||||||
|
inputSampleR = 1.0;
|
||||||
|
else if (inputSampleR > 0.0)
|
||||||
|
inputSampleR = 1.0 - pow(1.0 - inputSampleR, powFactor);
|
||||||
|
if (inputSampleR < -1.0)
|
||||||
|
inputSampleR = -1.0;
|
||||||
|
else if (inputSampleR < 0.0)
|
||||||
|
inputSampleR = -1.0 + pow(1.0 + inputSampleR, powFactor);
|
||||||
|
|
||||||
|
temp = (inputSampleL * biquad[biq_a0]) + biquad[biq_sL1];
|
||||||
|
biquad[biq_sL1] = (inputSampleL * biquad[biq_a1]) - (temp * biquad[biq_b1]) + biquad[biq_sL2];
|
||||||
|
biquad[biq_sL2] = (inputSampleL * biquad[biq_a2]) - (temp * biquad[biq_b2]);
|
||||||
|
inputSampleL = temp; // coefficient interpolating biquad filter
|
||||||
|
temp = (inputSampleR * biquad[biq_a0]) + biquad[biq_sR1];
|
||||||
|
biquad[biq_sR1] = (inputSampleR * biquad[biq_a1]) - (temp * biquad[biq_b1]) + biquad[biq_sR2];
|
||||||
|
biquad[biq_sR2] = (inputSampleR * biquad[biq_a2]) - (temp * biquad[biq_b2]);
|
||||||
|
inputSampleR = temp; // coefficient interpolating biquad filter
|
||||||
|
|
||||||
|
// encode/decode courtesy of torridgristle under the MIT license
|
||||||
|
if (inputSampleL > 1.0)
|
||||||
|
inputSampleL = 1.0;
|
||||||
|
else if (inputSampleL > 0.0)
|
||||||
|
inputSampleL = 1.0 - pow(1.0 - inputSampleL, (1.0 / powFactor));
|
||||||
|
if (inputSampleL < -1.0)
|
||||||
|
inputSampleL = -1.0;
|
||||||
|
else if (inputSampleL < 0.0)
|
||||||
|
inputSampleL = -1.0 + pow(1.0 + inputSampleL, (1.0 / powFactor));
|
||||||
|
if (inputSampleR > 1.0)
|
||||||
|
inputSampleR = 1.0;
|
||||||
|
else if (inputSampleR > 0.0)
|
||||||
|
inputSampleR = 1.0 - pow(1.0 - inputSampleR, (1.0 / powFactor));
|
||||||
|
if (inputSampleR < -1.0)
|
||||||
|
inputSampleR = -1.0;
|
||||||
|
else if (inputSampleR < 0.0)
|
||||||
|
inputSampleR = -1.0 + pow(1.0 + inputSampleR, (1.0 / powFactor));
|
||||||
|
|
||||||
|
inputSampleL *= outTrim;
|
||||||
|
inputSampleR *= outTrim;
|
||||||
|
|
||||||
|
temp = (inputSampleL * fixB[fix_a0]) + fixB[fix_sL1];
|
||||||
|
fixB[fix_sL1] = (inputSampleL * fixB[fix_a1]) - (temp * fixB[fix_b1]) + fixB[fix_sL2];
|
||||||
|
fixB[fix_sL2] = (inputSampleL * fixB[fix_a2]) - (temp * fixB[fix_b2]);
|
||||||
|
inputSampleL = temp; // fixed biquad filtering ultrasonics
|
||||||
|
temp = (inputSampleR * fixB[fix_a0]) + fixB[fix_sR1];
|
||||||
|
fixB[fix_sR1] = (inputSampleR * fixB[fix_a1]) - (temp * fixB[fix_b1]) + fixB[fix_sR2];
|
||||||
|
fixB[fix_sR2] = (inputSampleR * fixB[fix_a2]) - (temp * fixB[fix_b2]);
|
||||||
|
inputSampleR = temp; // fixed biquad filtering ultrasonics
|
||||||
|
|
||||||
|
if (wet < 1.0) {
|
||||||
|
inputSampleL = (inputSampleL * wet) + (drySampleL * (1.0 - wet));
|
||||||
|
inputSampleR = (inputSampleR * wet) + (drySampleR * (1.0 - wet));
|
||||||
|
}
|
||||||
|
|
||||||
|
// begin 32 bit stereo floating point dither
|
||||||
|
int expon;
|
||||||
|
frexpf((float)inputSampleL, &expon);
|
||||||
|
fpdL ^= fpdL << 13;
|
||||||
|
fpdL ^= fpdL >> 17;
|
||||||
|
fpdL ^= fpdL << 5;
|
||||||
|
inputSampleL += ((double(fpdL) - uint32_t(0x7fffffff)) * 5.5e-36l * pow(2, expon + 62));
|
||||||
|
frexpf((float)inputSampleR, &expon);
|
||||||
|
fpdR ^= fpdR << 13;
|
||||||
|
fpdR ^= fpdR >> 17;
|
||||||
|
fpdR ^= fpdR << 5;
|
||||||
|
inputSampleR += ((double(fpdR) - uint32_t(0x7fffffff)) * 5.5e-36l * pow(2, expon + 62));
|
||||||
|
// end 32 bit stereo floating point dither
|
||||||
|
|
||||||
|
*out1 = inputSampleL;
|
||||||
|
*out2 = inputSampleR;
|
||||||
|
|
||||||
|
in1++;
|
||||||
|
in2++;
|
||||||
|
out1++;
|
||||||
|
out2++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
double samplerate;
|
||||||
|
enum {
|
||||||
|
biq_freq,
|
||||||
|
biq_reso,
|
||||||
|
biq_a0,
|
||||||
|
biq_a1,
|
||||||
|
biq_a2,
|
||||||
|
biq_b1,
|
||||||
|
biq_b2,
|
||||||
|
biq_aA0,
|
||||||
|
biq_aA1,
|
||||||
|
biq_aA2,
|
||||||
|
biq_bA1,
|
||||||
|
biq_bA2,
|
||||||
|
biq_aB0,
|
||||||
|
biq_aB1,
|
||||||
|
biq_aB2,
|
||||||
|
biq_bB1,
|
||||||
|
biq_bB2,
|
||||||
|
biq_sL1,
|
||||||
|
biq_sL2,
|
||||||
|
biq_sR1,
|
||||||
|
biq_sR2,
|
||||||
|
biq_total
|
||||||
|
}; // coefficient interpolating biquad filter, stereo
|
||||||
|
std::array<double, biq_total> biquad;
|
||||||
|
|
||||||
|
double powFactorA;
|
||||||
|
double powFactorB;
|
||||||
|
double inTrimA;
|
||||||
|
double inTrimB;
|
||||||
|
double outTrimA;
|
||||||
|
double outTrimB;
|
||||||
|
|
||||||
|
enum {
|
||||||
|
fix_freq,
|
||||||
|
fix_reso,
|
||||||
|
fix_a0,
|
||||||
|
fix_a1,
|
||||||
|
fix_a2,
|
||||||
|
fix_b1,
|
||||||
|
fix_b2,
|
||||||
|
fix_sL1,
|
||||||
|
fix_sL2,
|
||||||
|
fix_sR1,
|
||||||
|
fix_sR2,
|
||||||
|
fix_total
|
||||||
|
}; // fixed frequency biquad filter for ultrasonics, stereo
|
||||||
|
std::array<double, fix_total> fixA;
|
||||||
|
std::array<double, fix_total> fixB;
|
||||||
|
|
||||||
|
uint32_t fpdL;
|
||||||
|
uint32_t fpdR;
|
||||||
|
// default stuff
|
||||||
|
|
||||||
|
float A;
|
||||||
|
float B;
|
||||||
|
float C;
|
||||||
|
float D;
|
||||||
|
float E;
|
||||||
|
float F; // parameters. Always 0-1, and we scale/alter them elsewhere.
|
||||||
|
};
|
||||||
|
}
|
||||||
313
filter/ylowpass.h
Normal file
313
filter/ylowpass.h
Normal file
@@ -0,0 +1,313 @@
|
|||||||
|
#pragma once
|
||||||
|
#define _USE_MATH_DEFINES
|
||||||
|
#include <math.h>
|
||||||
|
#include <array>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
namespace trnr::lib::filter {
|
||||||
|
// Lowpass filter based on YLowpass by Chris Johnson
|
||||||
|
class ylowpass {
|
||||||
|
public:
|
||||||
|
ylowpass(double _samplerate)
|
||||||
|
: samplerate { _samplerate }
|
||||||
|
, A { 0.1f }
|
||||||
|
, B { 1.0f }
|
||||||
|
, C { 0.0f }
|
||||||
|
, D { 0.1f }
|
||||||
|
, E { 0.9f }
|
||||||
|
, F { 1.0f }
|
||||||
|
, fpdL { 0 }
|
||||||
|
, fpdR { 0 }
|
||||||
|
, biquad { 0 }
|
||||||
|
{
|
||||||
|
for (int x = 0; x < biq_total; x++) {
|
||||||
|
biquad[x] = 0.0;
|
||||||
|
}
|
||||||
|
powFactorA = 1.0;
|
||||||
|
powFactorB = 1.0;
|
||||||
|
inTrimA = 0.1;
|
||||||
|
inTrimB = 0.1;
|
||||||
|
outTrimA = 1.0;
|
||||||
|
outTrimB = 1.0;
|
||||||
|
for (int x = 0; x < fix_total; x++) {
|
||||||
|
fixA[x] = 0.0;
|
||||||
|
fixB[x] = 0.0;
|
||||||
|
}
|
||||||
|
|
||||||
|
fpdL = 1.0;
|
||||||
|
while (fpdL < 16386)
|
||||||
|
fpdL = rand() * UINT32_MAX;
|
||||||
|
fpdR = 1.0;
|
||||||
|
while (fpdR < 16386)
|
||||||
|
fpdR = rand() * UINT32_MAX;
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_samplerate(double _samplerate) {
|
||||||
|
samplerate = _samplerate;
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_drive(float value)
|
||||||
|
{
|
||||||
|
A = value * 0.9 + 0.1;
|
||||||
|
}
|
||||||
|
void set_frequency(float value)
|
||||||
|
{
|
||||||
|
B = value;
|
||||||
|
}
|
||||||
|
void set_resonance(float value)
|
||||||
|
{
|
||||||
|
C = value;
|
||||||
|
}
|
||||||
|
void set_edge(float value)
|
||||||
|
{
|
||||||
|
D = value;
|
||||||
|
}
|
||||||
|
void set_output(float value)
|
||||||
|
{
|
||||||
|
E = value;
|
||||||
|
}
|
||||||
|
void set_mix(float value)
|
||||||
|
{
|
||||||
|
F = value;
|
||||||
|
}
|
||||||
|
void processblock(double** inputs, double** outputs, int blockSize)
|
||||||
|
{
|
||||||
|
double* in1 = inputs[0];
|
||||||
|
double* in2 = inputs[1];
|
||||||
|
double* out1 = outputs[0];
|
||||||
|
double* out2 = outputs[1];
|
||||||
|
|
||||||
|
int inFramesToProcess = blockSize;
|
||||||
|
double overallscale = 1.0;
|
||||||
|
overallscale /= 44100.0;
|
||||||
|
overallscale *= samplerate;
|
||||||
|
|
||||||
|
inTrimA = inTrimB;
|
||||||
|
inTrimB = A * 10.0;
|
||||||
|
|
||||||
|
biquad[biq_freq] = pow(B, 3) * 20000.0;
|
||||||
|
if (biquad[biq_freq] < 15.0)
|
||||||
|
biquad[biq_freq] = 15.0;
|
||||||
|
biquad[biq_freq] /= samplerate;
|
||||||
|
biquad[biq_reso] = (pow(C, 2) * 15.0) + 0.5571;
|
||||||
|
biquad[biq_aA0] = biquad[biq_aB0];
|
||||||
|
biquad[biq_aA1] = biquad[biq_aB1];
|
||||||
|
biquad[biq_aA2] = biquad[biq_aB2];
|
||||||
|
biquad[biq_bA1] = biquad[biq_bB1];
|
||||||
|
biquad[biq_bA2] = biquad[biq_bB2];
|
||||||
|
// previous run through the buffer is still in the filter, so we move it
|
||||||
|
// to the A section and now it's the new starting point.
|
||||||
|
double K = tan(M_PI * biquad[biq_freq]);
|
||||||
|
double norm = 1.0 / (1.0 + K / biquad[biq_reso] + K * K);
|
||||||
|
biquad[biq_aB0] = K * K * norm;
|
||||||
|
biquad[biq_aB1] = 2.0 * biquad[biq_aB0];
|
||||||
|
biquad[biq_aB2] = biquad[biq_aB0];
|
||||||
|
biquad[biq_bB1] = 2.0 * (K * K - 1.0) * norm;
|
||||||
|
biquad[biq_bB2] = (1.0 - K / biquad[biq_reso] + K * K) * norm;
|
||||||
|
// for the coefficient-interpolated biquad filter
|
||||||
|
|
||||||
|
powFactorA = powFactorB;
|
||||||
|
powFactorB = pow(D + 0.9, 4);
|
||||||
|
|
||||||
|
// 1.0 == target neutral
|
||||||
|
|
||||||
|
outTrimA = outTrimB;
|
||||||
|
outTrimB = E;
|
||||||
|
|
||||||
|
double wet = F;
|
||||||
|
|
||||||
|
fixA[fix_freq] = fixB[fix_freq] = 20000.0 / samplerate;
|
||||||
|
fixA[fix_reso] = fixB[fix_reso] = 0.7071; // butterworth Q
|
||||||
|
|
||||||
|
K = tan(M_PI * fixA[fix_freq]);
|
||||||
|
norm = 1.0 / (1.0 + K / fixA[fix_reso] + K * K);
|
||||||
|
fixA[fix_a0] = fixB[fix_a0] = K * K * norm;
|
||||||
|
fixA[fix_a1] = fixB[fix_a1] = 2.0 * fixA[fix_a0];
|
||||||
|
fixA[fix_a2] = fixB[fix_a2] = fixA[fix_a0];
|
||||||
|
fixA[fix_b1] = fixB[fix_b1] = 2.0 * (K * K - 1.0) * norm;
|
||||||
|
fixA[fix_b2] = fixB[fix_b2] = (1.0 - K / fixA[fix_reso] + K * K) * norm;
|
||||||
|
// for the fixed-position biquad filter
|
||||||
|
|
||||||
|
for (int s = 0; s < blockSize; s++) {
|
||||||
|
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 drySampleL = inputSampleL;
|
||||||
|
double drySampleR = inputSampleR;
|
||||||
|
|
||||||
|
double temp = (double)s / inFramesToProcess;
|
||||||
|
biquad[biq_a0] = (biquad[biq_aA0] * temp) + (biquad[biq_aB0] * (1.0 - temp));
|
||||||
|
biquad[biq_a1] = (biquad[biq_aA1] * temp) + (biquad[biq_aB1] * (1.0 - temp));
|
||||||
|
biquad[biq_a2] = (biquad[biq_aA2] * temp) + (biquad[biq_aB2] * (1.0 - temp));
|
||||||
|
biquad[biq_b1] = (biquad[biq_bA1] * temp) + (biquad[biq_bB1] * (1.0 - temp));
|
||||||
|
biquad[biq_b2] = (biquad[biq_bA2] * temp) + (biquad[biq_bB2] * (1.0 - temp));
|
||||||
|
// this is the interpolation code for the biquad
|
||||||
|
double powFactor = (powFactorA * temp) + (powFactorB * (1.0 - temp));
|
||||||
|
double inTrim = (inTrimA * temp) + (inTrimB * (1.0 - temp));
|
||||||
|
double outTrim = (outTrimA * temp) + (outTrimB * (1.0 - temp));
|
||||||
|
|
||||||
|
inputSampleL *= inTrim;
|
||||||
|
inputSampleR *= inTrim;
|
||||||
|
|
||||||
|
temp = (inputSampleL * fixA[fix_a0]) + fixA[fix_sL1];
|
||||||
|
fixA[fix_sL1] = (inputSampleL * fixA[fix_a1]) - (temp * fixA[fix_b1]) + fixA[fix_sL2];
|
||||||
|
fixA[fix_sL2] = (inputSampleL * fixA[fix_a2]) - (temp * fixA[fix_b2]);
|
||||||
|
inputSampleL = temp; // fixed biquad filtering ultrasonics
|
||||||
|
temp = (inputSampleR * fixA[fix_a0]) + fixA[fix_sR1];
|
||||||
|
fixA[fix_sR1] = (inputSampleR * fixA[fix_a1]) - (temp * fixA[fix_b1]) + fixA[fix_sR2];
|
||||||
|
fixA[fix_sR2] = (inputSampleR * fixA[fix_a2]) - (temp * fixA[fix_b2]);
|
||||||
|
inputSampleR = temp; // fixed biquad filtering ultrasonics
|
||||||
|
|
||||||
|
// encode/decode courtesy of torridgristle under the MIT license
|
||||||
|
if (inputSampleL > 1.0)
|
||||||
|
inputSampleL = 1.0;
|
||||||
|
else if (inputSampleL > 0.0)
|
||||||
|
inputSampleL = 1.0 - pow(1.0 - inputSampleL, powFactor);
|
||||||
|
if (inputSampleL < -1.0)
|
||||||
|
inputSampleL = -1.0;
|
||||||
|
else if (inputSampleL < 0.0)
|
||||||
|
inputSampleL = -1.0 + pow(1.0 + inputSampleL, powFactor);
|
||||||
|
if (inputSampleR > 1.0)
|
||||||
|
inputSampleR = 1.0;
|
||||||
|
else if (inputSampleR > 0.0)
|
||||||
|
inputSampleR = 1.0 - pow(1.0 - inputSampleR, powFactor);
|
||||||
|
if (inputSampleR < -1.0)
|
||||||
|
inputSampleR = -1.0;
|
||||||
|
else if (inputSampleR < 0.0)
|
||||||
|
inputSampleR = -1.0 + pow(1.0 + inputSampleR, powFactor);
|
||||||
|
|
||||||
|
temp = (inputSampleL * biquad[biq_a0]) + biquad[biq_sL1];
|
||||||
|
biquad[biq_sL1] = (inputSampleL * biquad[biq_a1]) - (temp * biquad[biq_b1]) + biquad[biq_sL2];
|
||||||
|
biquad[biq_sL2] = (inputSampleL * biquad[biq_a2]) - (temp * biquad[biq_b2]);
|
||||||
|
inputSampleL = temp; // coefficient interpolating biquad filter
|
||||||
|
temp = (inputSampleR * biquad[biq_a0]) + biquad[biq_sR1];
|
||||||
|
biquad[biq_sR1] = (inputSampleR * biquad[biq_a1]) - (temp * biquad[biq_b1]) + biquad[biq_sR2];
|
||||||
|
biquad[biq_sR2] = (inputSampleR * biquad[biq_a2]) - (temp * biquad[biq_b2]);
|
||||||
|
inputSampleR = temp; // coefficient interpolating biquad filter
|
||||||
|
|
||||||
|
// encode/decode courtesy of torridgristle under the MIT license
|
||||||
|
if (inputSampleL > 1.0)
|
||||||
|
inputSampleL = 1.0;
|
||||||
|
else if (inputSampleL > 0.0)
|
||||||
|
inputSampleL = 1.0 - pow(1.0 - inputSampleL, (1.0 / powFactor));
|
||||||
|
if (inputSampleL < -1.0)
|
||||||
|
inputSampleL = -1.0;
|
||||||
|
else if (inputSampleL < 0.0)
|
||||||
|
inputSampleL = -1.0 + pow(1.0 + inputSampleL, (1.0 / powFactor));
|
||||||
|
if (inputSampleR > 1.0)
|
||||||
|
inputSampleR = 1.0;
|
||||||
|
else if (inputSampleR > 0.0)
|
||||||
|
inputSampleR = 1.0 - pow(1.0 - inputSampleR, (1.0 / powFactor));
|
||||||
|
if (inputSampleR < -1.0)
|
||||||
|
inputSampleR = -1.0;
|
||||||
|
else if (inputSampleR < 0.0)
|
||||||
|
inputSampleR = -1.0 + pow(1.0 + inputSampleR, (1.0 / powFactor));
|
||||||
|
|
||||||
|
inputSampleL *= outTrim;
|
||||||
|
inputSampleR *= outTrim;
|
||||||
|
|
||||||
|
temp = (inputSampleL * fixB[fix_a0]) + fixB[fix_sL1];
|
||||||
|
fixB[fix_sL1] = (inputSampleL * fixB[fix_a1]) - (temp * fixB[fix_b1]) + fixB[fix_sL2];
|
||||||
|
fixB[fix_sL2] = (inputSampleL * fixB[fix_a2]) - (temp * fixB[fix_b2]);
|
||||||
|
inputSampleL = temp; // fixed biquad filtering ultrasonics
|
||||||
|
temp = (inputSampleR * fixB[fix_a0]) + fixB[fix_sR1];
|
||||||
|
fixB[fix_sR1] = (inputSampleR * fixB[fix_a1]) - (temp * fixB[fix_b1]) + fixB[fix_sR2];
|
||||||
|
fixB[fix_sR2] = (inputSampleR * fixB[fix_a2]) - (temp * fixB[fix_b2]);
|
||||||
|
inputSampleR = temp; // fixed biquad filtering ultrasonics
|
||||||
|
|
||||||
|
if (wet < 1.0) {
|
||||||
|
inputSampleL = (inputSampleL * wet) + (drySampleL * (1.0 - wet));
|
||||||
|
inputSampleR = (inputSampleR * wet) + (drySampleR * (1.0 - wet));
|
||||||
|
}
|
||||||
|
|
||||||
|
// begin 32 bit stereo floating point dither
|
||||||
|
int expon;
|
||||||
|
frexpf((float)inputSampleL, &expon);
|
||||||
|
fpdL ^= fpdL << 13;
|
||||||
|
fpdL ^= fpdL >> 17;
|
||||||
|
fpdL ^= fpdL << 5;
|
||||||
|
inputSampleL += ((double(fpdL) - uint32_t(0x7fffffff)) * 5.5e-36l * pow(2, expon + 62));
|
||||||
|
frexpf((float)inputSampleR, &expon);
|
||||||
|
fpdR ^= fpdR << 13;
|
||||||
|
fpdR ^= fpdR >> 17;
|
||||||
|
fpdR ^= fpdR << 5;
|
||||||
|
inputSampleR += ((double(fpdR) - uint32_t(0x7fffffff)) * 5.5e-36l * pow(2, expon + 62));
|
||||||
|
// end 32 bit stereo floating point dither
|
||||||
|
|
||||||
|
*out1 = inputSampleL;
|
||||||
|
*out2 = inputSampleR;
|
||||||
|
|
||||||
|
in1++;
|
||||||
|
in2++;
|
||||||
|
out1++;
|
||||||
|
out2++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
double samplerate;
|
||||||
|
enum {
|
||||||
|
biq_freq,
|
||||||
|
biq_reso,
|
||||||
|
biq_a0,
|
||||||
|
biq_a1,
|
||||||
|
biq_a2,
|
||||||
|
biq_b1,
|
||||||
|
biq_b2,
|
||||||
|
biq_aA0,
|
||||||
|
biq_aA1,
|
||||||
|
biq_aA2,
|
||||||
|
biq_bA1,
|
||||||
|
biq_bA2,
|
||||||
|
biq_aB0,
|
||||||
|
biq_aB1,
|
||||||
|
biq_aB2,
|
||||||
|
biq_bB1,
|
||||||
|
biq_bB2,
|
||||||
|
biq_sL1,
|
||||||
|
biq_sL2,
|
||||||
|
biq_sR1,
|
||||||
|
biq_sR2,
|
||||||
|
biq_total
|
||||||
|
}; // coefficient interpolating biquad filter, stereo
|
||||||
|
std::array<double, biq_total> biquad;
|
||||||
|
|
||||||
|
double powFactorA;
|
||||||
|
double powFactorB;
|
||||||
|
double inTrimA;
|
||||||
|
double inTrimB;
|
||||||
|
double outTrimA;
|
||||||
|
double outTrimB;
|
||||||
|
|
||||||
|
enum {
|
||||||
|
fix_freq,
|
||||||
|
fix_reso,
|
||||||
|
fix_a0,
|
||||||
|
fix_a1,
|
||||||
|
fix_a2,
|
||||||
|
fix_b1,
|
||||||
|
fix_b2,
|
||||||
|
fix_sL1,
|
||||||
|
fix_sL2,
|
||||||
|
fix_sR1,
|
||||||
|
fix_sR2,
|
||||||
|
fix_total
|
||||||
|
}; // fixed frequency biquad filter for ultrasonics, stereo
|
||||||
|
std::array<double, fix_total> fixA;
|
||||||
|
std::array<double, fix_total> fixB;
|
||||||
|
|
||||||
|
uint32_t fpdL;
|
||||||
|
uint32_t fpdR;
|
||||||
|
// default stuff
|
||||||
|
|
||||||
|
float A;
|
||||||
|
float B;
|
||||||
|
float C;
|
||||||
|
float D;
|
||||||
|
float E;
|
||||||
|
float F; // parameters. Always 0-1, and we scale/alter them elsewhere.
|
||||||
|
};
|
||||||
|
}
|
||||||
313
filter/ynotch.h
Normal file
313
filter/ynotch.h
Normal file
@@ -0,0 +1,313 @@
|
|||||||
|
#pragma once
|
||||||
|
#define _USE_MATH_DEFINES
|
||||||
|
#include <math.h>
|
||||||
|
#include <array>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
namespace trnr::lib::filter {
|
||||||
|
// Notch filter based on YNotch by Chris Johnson
|
||||||
|
class ynotch {
|
||||||
|
public:
|
||||||
|
ynotch(double _samplerate)
|
||||||
|
: samplerate { _samplerate }
|
||||||
|
, A { 0.1f }
|
||||||
|
, B { 1.0f }
|
||||||
|
, C { 0.0f }
|
||||||
|
, D { 0.1f }
|
||||||
|
, E { 0.9f }
|
||||||
|
, F { 1.0f }
|
||||||
|
, fpdL { 0 }
|
||||||
|
, fpdR { 0 }
|
||||||
|
, biquad { 0 }
|
||||||
|
{
|
||||||
|
for (int x = 0; x < biq_total; x++) {
|
||||||
|
biquad[x] = 0.0;
|
||||||
|
}
|
||||||
|
powFactorA = 1.0;
|
||||||
|
powFactorB = 1.0;
|
||||||
|
inTrimA = 0.1;
|
||||||
|
inTrimB = 0.1;
|
||||||
|
outTrimA = 1.0;
|
||||||
|
outTrimB = 1.0;
|
||||||
|
for (int x = 0; x < fix_total; x++) {
|
||||||
|
fixA[x] = 0.0;
|
||||||
|
fixB[x] = 0.0;
|
||||||
|
}
|
||||||
|
|
||||||
|
fpdL = 1.0;
|
||||||
|
while (fpdL < 16386)
|
||||||
|
fpdL = rand() * UINT32_MAX;
|
||||||
|
fpdR = 1.0;
|
||||||
|
while (fpdR < 16386)
|
||||||
|
fpdR = rand() * UINT32_MAX;
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_samplerate(double _samplerate) {
|
||||||
|
samplerate = _samplerate;
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_drive(float value)
|
||||||
|
{
|
||||||
|
A = value * 0.9 + 0.1;
|
||||||
|
}
|
||||||
|
void set_frequency(float value)
|
||||||
|
{
|
||||||
|
B = value;
|
||||||
|
}
|
||||||
|
void set_resonance(float value)
|
||||||
|
{
|
||||||
|
C = value;
|
||||||
|
}
|
||||||
|
void set_edge(float value)
|
||||||
|
{
|
||||||
|
D = value;
|
||||||
|
}
|
||||||
|
void set_output(float value)
|
||||||
|
{
|
||||||
|
E = value;
|
||||||
|
}
|
||||||
|
void set_mix(float value)
|
||||||
|
{
|
||||||
|
F = value;
|
||||||
|
}
|
||||||
|
void processblock(double** inputs, double** outputs, int blockSize)
|
||||||
|
{
|
||||||
|
double* in1 = inputs[0];
|
||||||
|
double* in2 = inputs[1];
|
||||||
|
double* out1 = outputs[0];
|
||||||
|
double* out2 = outputs[1];
|
||||||
|
|
||||||
|
int inFramesToProcess = blockSize;
|
||||||
|
double overallscale = 1.0;
|
||||||
|
overallscale /= 44100.0;
|
||||||
|
overallscale *= samplerate;
|
||||||
|
|
||||||
|
inTrimA = inTrimB;
|
||||||
|
inTrimB = A * 10.0;
|
||||||
|
|
||||||
|
biquad[biq_freq] = pow(B, 3) * 20000.0;
|
||||||
|
if (biquad[biq_freq] < 15.0)
|
||||||
|
biquad[biq_freq] = 15.0;
|
||||||
|
biquad[biq_freq] /= samplerate;
|
||||||
|
biquad[biq_reso] = (pow(C, 2) * 15.0) + 0.0001;
|
||||||
|
biquad[biq_aA0] = biquad[biq_aB0];
|
||||||
|
biquad[biq_aA1] = biquad[biq_aB1];
|
||||||
|
biquad[biq_aA2] = biquad[biq_aB2];
|
||||||
|
biquad[biq_bA1] = biquad[biq_bB1];
|
||||||
|
biquad[biq_bA2] = biquad[biq_bB2];
|
||||||
|
// previous run through the buffer is still in the filter, so we move it
|
||||||
|
// to the A section and now it's the new starting point.
|
||||||
|
double K = tan(M_PI * biquad[biq_freq]);
|
||||||
|
double norm = 1.0 / (1.0 + K / biquad[biq_reso] + K * K);
|
||||||
|
biquad[biq_aB0] = (1.0 + K * K) * norm;
|
||||||
|
biquad[biq_aB1] = 2.0 * (K * K - 1) * norm;
|
||||||
|
biquad[biq_aB2] = biquad[biq_aB0];
|
||||||
|
biquad[biq_bB1] = biquad[biq_aB1];
|
||||||
|
biquad[biq_bB2] = (1.0 - K / biquad[biq_reso] + K * K) * norm;
|
||||||
|
// for the coefficient-interpolated biquad filter
|
||||||
|
|
||||||
|
powFactorA = powFactorB;
|
||||||
|
powFactorB = pow(D + 0.9, 4);
|
||||||
|
|
||||||
|
// 1.0 == target neutral
|
||||||
|
|
||||||
|
outTrimA = outTrimB;
|
||||||
|
outTrimB = E;
|
||||||
|
|
||||||
|
double wet = F;
|
||||||
|
|
||||||
|
fixA[fix_freq] = fixB[fix_freq] = 20000.0 / samplerate;
|
||||||
|
fixA[fix_reso] = fixB[fix_reso] = 0.7071; // butterworth Q
|
||||||
|
|
||||||
|
K = tan(M_PI * fixA[fix_freq]);
|
||||||
|
norm = 1.0 / (1.0 + K / fixA[fix_reso] + K * K);
|
||||||
|
fixA[fix_a0] = fixB[fix_a0] = K * K * norm;
|
||||||
|
fixA[fix_a1] = fixB[fix_a1] = 2.0 * fixA[fix_a0];
|
||||||
|
fixA[fix_a2] = fixB[fix_a2] = fixA[fix_a0];
|
||||||
|
fixA[fix_b1] = fixB[fix_b1] = 2.0 * (K * K - 1.0) * norm;
|
||||||
|
fixA[fix_b2] = fixB[fix_b2] = (1.0 - K / fixA[fix_reso] + K * K) * norm;
|
||||||
|
// for the fixed-position biquad filter
|
||||||
|
|
||||||
|
for (int s = 0; s < blockSize; s++) {
|
||||||
|
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 drySampleL = inputSampleL;
|
||||||
|
double drySampleR = inputSampleR;
|
||||||
|
|
||||||
|
double temp = (double)s / inFramesToProcess;
|
||||||
|
biquad[biq_a0] = (biquad[biq_aA0] * temp) + (biquad[biq_aB0] * (1.0 - temp));
|
||||||
|
biquad[biq_a1] = (biquad[biq_aA1] * temp) + (biquad[biq_aB1] * (1.0 - temp));
|
||||||
|
biquad[biq_a2] = (biquad[biq_aA2] * temp) + (biquad[biq_aB2] * (1.0 - temp));
|
||||||
|
biquad[biq_b1] = (biquad[biq_bA1] * temp) + (biquad[biq_bB1] * (1.0 - temp));
|
||||||
|
biquad[biq_b2] = (biquad[biq_bA2] * temp) + (biquad[biq_bB2] * (1.0 - temp));
|
||||||
|
// this is the interpolation code for the biquad
|
||||||
|
double powFactor = (powFactorA * temp) + (powFactorB * (1.0 - temp));
|
||||||
|
double inTrim = (inTrimA * temp) + (inTrimB * (1.0 - temp));
|
||||||
|
double outTrim = (outTrimA * temp) + (outTrimB * (1.0 - temp));
|
||||||
|
|
||||||
|
inputSampleL *= inTrim;
|
||||||
|
inputSampleR *= inTrim;
|
||||||
|
|
||||||
|
temp = (inputSampleL * fixA[fix_a0]) + fixA[fix_sL1];
|
||||||
|
fixA[fix_sL1] = (inputSampleL * fixA[fix_a1]) - (temp * fixA[fix_b1]) + fixA[fix_sL2];
|
||||||
|
fixA[fix_sL2] = (inputSampleL * fixA[fix_a2]) - (temp * fixA[fix_b2]);
|
||||||
|
inputSampleL = temp; // fixed biquad filtering ultrasonics
|
||||||
|
temp = (inputSampleR * fixA[fix_a0]) + fixA[fix_sR1];
|
||||||
|
fixA[fix_sR1] = (inputSampleR * fixA[fix_a1]) - (temp * fixA[fix_b1]) + fixA[fix_sR2];
|
||||||
|
fixA[fix_sR2] = (inputSampleR * fixA[fix_a2]) - (temp * fixA[fix_b2]);
|
||||||
|
inputSampleR = temp; // fixed biquad filtering ultrasonics
|
||||||
|
|
||||||
|
// encode/decode courtesy of torridgristle under the MIT license
|
||||||
|
if (inputSampleL > 1.0)
|
||||||
|
inputSampleL = 1.0;
|
||||||
|
else if (inputSampleL > 0.0)
|
||||||
|
inputSampleL = 1.0 - pow(1.0 - inputSampleL, powFactor);
|
||||||
|
if (inputSampleL < -1.0)
|
||||||
|
inputSampleL = -1.0;
|
||||||
|
else if (inputSampleL < 0.0)
|
||||||
|
inputSampleL = -1.0 + pow(1.0 + inputSampleL, powFactor);
|
||||||
|
if (inputSampleR > 1.0)
|
||||||
|
inputSampleR = 1.0;
|
||||||
|
else if (inputSampleR > 0.0)
|
||||||
|
inputSampleR = 1.0 - pow(1.0 - inputSampleR, powFactor);
|
||||||
|
if (inputSampleR < -1.0)
|
||||||
|
inputSampleR = -1.0;
|
||||||
|
else if (inputSampleR < 0.0)
|
||||||
|
inputSampleR = -1.0 + pow(1.0 + inputSampleR, powFactor);
|
||||||
|
|
||||||
|
temp = (inputSampleL * biquad[biq_a0]) + biquad[biq_sL1];
|
||||||
|
biquad[biq_sL1] = (inputSampleL * biquad[biq_a1]) - (temp * biquad[biq_b1]) + biquad[biq_sL2];
|
||||||
|
biquad[biq_sL2] = (inputSampleL * biquad[biq_a2]) - (temp * biquad[biq_b2]);
|
||||||
|
inputSampleL = temp; // coefficient interpolating biquad filter
|
||||||
|
temp = (inputSampleR * biquad[biq_a0]) + biquad[biq_sR1];
|
||||||
|
biquad[biq_sR1] = (inputSampleR * biquad[biq_a1]) - (temp * biquad[biq_b1]) + biquad[biq_sR2];
|
||||||
|
biquad[biq_sR2] = (inputSampleR * biquad[biq_a2]) - (temp * biquad[biq_b2]);
|
||||||
|
inputSampleR = temp; // coefficient interpolating biquad filter
|
||||||
|
|
||||||
|
// encode/decode courtesy of torridgristle under the MIT license
|
||||||
|
if (inputSampleL > 1.0)
|
||||||
|
inputSampleL = 1.0;
|
||||||
|
else if (inputSampleL > 0.0)
|
||||||
|
inputSampleL = 1.0 - pow(1.0 - inputSampleL, (1.0 / powFactor));
|
||||||
|
if (inputSampleL < -1.0)
|
||||||
|
inputSampleL = -1.0;
|
||||||
|
else if (inputSampleL < 0.0)
|
||||||
|
inputSampleL = -1.0 + pow(1.0 + inputSampleL, (1.0 / powFactor));
|
||||||
|
if (inputSampleR > 1.0)
|
||||||
|
inputSampleR = 1.0;
|
||||||
|
else if (inputSampleR > 0.0)
|
||||||
|
inputSampleR = 1.0 - pow(1.0 - inputSampleR, (1.0 / powFactor));
|
||||||
|
if (inputSampleR < -1.0)
|
||||||
|
inputSampleR = -1.0;
|
||||||
|
else if (inputSampleR < 0.0)
|
||||||
|
inputSampleR = -1.0 + pow(1.0 + inputSampleR, (1.0 / powFactor));
|
||||||
|
|
||||||
|
inputSampleL *= outTrim;
|
||||||
|
inputSampleR *= outTrim;
|
||||||
|
|
||||||
|
temp = (inputSampleL * fixB[fix_a0]) + fixB[fix_sL1];
|
||||||
|
fixB[fix_sL1] = (inputSampleL * fixB[fix_a1]) - (temp * fixB[fix_b1]) + fixB[fix_sL2];
|
||||||
|
fixB[fix_sL2] = (inputSampleL * fixB[fix_a2]) - (temp * fixB[fix_b2]);
|
||||||
|
inputSampleL = temp; // fixed biquad filtering ultrasonics
|
||||||
|
temp = (inputSampleR * fixB[fix_a0]) + fixB[fix_sR1];
|
||||||
|
fixB[fix_sR1] = (inputSampleR * fixB[fix_a1]) - (temp * fixB[fix_b1]) + fixB[fix_sR2];
|
||||||
|
fixB[fix_sR2] = (inputSampleR * fixB[fix_a2]) - (temp * fixB[fix_b2]);
|
||||||
|
inputSampleR = temp; // fixed biquad filtering ultrasonics
|
||||||
|
|
||||||
|
if (wet < 1.0) {
|
||||||
|
inputSampleL = (inputSampleL * wet) + (drySampleL * (1.0 - wet));
|
||||||
|
inputSampleR = (inputSampleR * wet) + (drySampleR * (1.0 - wet));
|
||||||
|
}
|
||||||
|
|
||||||
|
// begin 32 bit stereo floating point dither
|
||||||
|
int expon;
|
||||||
|
frexpf((float)inputSampleL, &expon);
|
||||||
|
fpdL ^= fpdL << 13;
|
||||||
|
fpdL ^= fpdL >> 17;
|
||||||
|
fpdL ^= fpdL << 5;
|
||||||
|
inputSampleL += ((double(fpdL) - uint32_t(0x7fffffff)) * 5.5e-36l * pow(2, expon + 62));
|
||||||
|
frexpf((float)inputSampleR, &expon);
|
||||||
|
fpdR ^= fpdR << 13;
|
||||||
|
fpdR ^= fpdR >> 17;
|
||||||
|
fpdR ^= fpdR << 5;
|
||||||
|
inputSampleR += ((double(fpdR) - uint32_t(0x7fffffff)) * 5.5e-36l * pow(2, expon + 62));
|
||||||
|
// end 32 bit stereo floating point dither
|
||||||
|
|
||||||
|
*out1 = inputSampleL;
|
||||||
|
*out2 = inputSampleR;
|
||||||
|
|
||||||
|
in1++;
|
||||||
|
in2++;
|
||||||
|
out1++;
|
||||||
|
out2++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
double samplerate;
|
||||||
|
enum {
|
||||||
|
biq_freq,
|
||||||
|
biq_reso,
|
||||||
|
biq_a0,
|
||||||
|
biq_a1,
|
||||||
|
biq_a2,
|
||||||
|
biq_b1,
|
||||||
|
biq_b2,
|
||||||
|
biq_aA0,
|
||||||
|
biq_aA1,
|
||||||
|
biq_aA2,
|
||||||
|
biq_bA1,
|
||||||
|
biq_bA2,
|
||||||
|
biq_aB0,
|
||||||
|
biq_aB1,
|
||||||
|
biq_aB2,
|
||||||
|
biq_bB1,
|
||||||
|
biq_bB2,
|
||||||
|
biq_sL1,
|
||||||
|
biq_sL2,
|
||||||
|
biq_sR1,
|
||||||
|
biq_sR2,
|
||||||
|
biq_total
|
||||||
|
}; // coefficient interpolating biquad filter, stereo
|
||||||
|
std::array<double, biq_total> biquad;
|
||||||
|
|
||||||
|
double powFactorA;
|
||||||
|
double powFactorB;
|
||||||
|
double inTrimA;
|
||||||
|
double inTrimB;
|
||||||
|
double outTrimA;
|
||||||
|
double outTrimB;
|
||||||
|
|
||||||
|
enum {
|
||||||
|
fix_freq,
|
||||||
|
fix_reso,
|
||||||
|
fix_a0,
|
||||||
|
fix_a1,
|
||||||
|
fix_a2,
|
||||||
|
fix_b1,
|
||||||
|
fix_b2,
|
||||||
|
fix_sL1,
|
||||||
|
fix_sL2,
|
||||||
|
fix_sR1,
|
||||||
|
fix_sR2,
|
||||||
|
fix_total
|
||||||
|
}; // fixed frequency biquad filter for ultrasonics, stereo
|
||||||
|
std::array<double, fix_total> fixA;
|
||||||
|
std::array<double, fix_total> fixB;
|
||||||
|
|
||||||
|
uint32_t fpdL;
|
||||||
|
uint32_t fpdR;
|
||||||
|
// default stuff
|
||||||
|
|
||||||
|
float A;
|
||||||
|
float B;
|
||||||
|
float C;
|
||||||
|
float D;
|
||||||
|
float E;
|
||||||
|
float F; // parameters. Always 0-1, and we scale/alter them elsewhere.
|
||||||
|
};
|
||||||
|
}
|
||||||
112
filter/ysvf.h
Normal file
112
filter/ysvf.h
Normal file
@@ -0,0 +1,112 @@
|
|||||||
|
#pragma once
|
||||||
|
#include "ylowpass.h"
|
||||||
|
#include "yhighpass.h"
|
||||||
|
#include "ybandpass.h"
|
||||||
|
#include "ynotch.h"
|
||||||
|
|
||||||
|
namespace trnr::lib::filter {
|
||||||
|
|
||||||
|
enum filter_types {
|
||||||
|
lowpass = 0,
|
||||||
|
highpass,
|
||||||
|
bandpass,
|
||||||
|
notch
|
||||||
|
};
|
||||||
|
|
||||||
|
class ysvf {
|
||||||
|
public:
|
||||||
|
ysvf(double _samplerate)
|
||||||
|
: lowpass { _samplerate }
|
||||||
|
, highpass { _samplerate }
|
||||||
|
, bandpass { _samplerate }
|
||||||
|
, notch { _samplerate }
|
||||||
|
{}
|
||||||
|
|
||||||
|
void set_samplerate(double _samplerate) {
|
||||||
|
lowpass.set_samplerate(_samplerate);
|
||||||
|
highpass.set_samplerate(_samplerate);
|
||||||
|
bandpass.set_samplerate(_samplerate);
|
||||||
|
notch.set_samplerate(_samplerate);
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_filter_type(filter_types type) {
|
||||||
|
filter_type = type;
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_drive(float value) {
|
||||||
|
lowpass.set_drive(value);
|
||||||
|
highpass.set_drive(value);
|
||||||
|
bandpass.set_drive(value);
|
||||||
|
notch.set_drive(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_frequency(float value) {
|
||||||
|
lowpass.set_frequency(value);
|
||||||
|
highpass.set_frequency(value);
|
||||||
|
bandpass.set_frequency(value);
|
||||||
|
notch.set_frequency(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_resonance(float value) {
|
||||||
|
lowpass.set_resonance(value);
|
||||||
|
highpass.set_resonance(value);
|
||||||
|
bandpass.set_resonance(value);
|
||||||
|
notch.set_resonance(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_edge(float value) {
|
||||||
|
lowpass.set_edge(value);
|
||||||
|
highpass.set_edge(value);
|
||||||
|
bandpass.set_edge(value);
|
||||||
|
notch.set_edge(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_output(float value) {
|
||||||
|
lowpass.set_output(value);
|
||||||
|
highpass.set_output(value);
|
||||||
|
bandpass.set_output(value);
|
||||||
|
notch.set_output(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_mix(float value) {
|
||||||
|
lowpass.set_mix(value);
|
||||||
|
highpass.set_mix(value);
|
||||||
|
bandpass.set_mix(value);
|
||||||
|
notch.set_mix(value);
|
||||||
|
}
|
||||||
|
|
||||||
|
void process_block(double** inputs, double** outputs, int block_size) {
|
||||||
|
|
||||||
|
switch (filter_type) {
|
||||||
|
case filter_types::lowpass:
|
||||||
|
lowpass.processblock(inputs, outputs, block_size);
|
||||||
|
break;
|
||||||
|
case filter_types::highpass:
|
||||||
|
highpass.processblock(inputs, outputs, block_size);
|
||||||
|
break;
|
||||||
|
case filter_types::bandpass:
|
||||||
|
bandpass.processblock(inputs, outputs, block_size);
|
||||||
|
break;
|
||||||
|
case filter_types::notch:
|
||||||
|
notch.processblock(inputs, outputs, block_size);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
filter_types filter_type;
|
||||||
|
ylowpass lowpass;
|
||||||
|
yhighpass highpass;
|
||||||
|
ybandpass bandpass;
|
||||||
|
ynotch notch;
|
||||||
|
|
||||||
|
double clamp(double& value, double min, double max) {
|
||||||
|
if (value < min) {
|
||||||
|
value = min;
|
||||||
|
} else if (value > max) {
|
||||||
|
value = max;
|
||||||
|
}
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
280
synth/tx_envelope.h
Normal file
280
synth/tx_envelope.h
Normal file
@@ -0,0 +1,280 @@
|
|||||||
|
#pragma once
|
||||||
|
#include <array>
|
||||||
|
|
||||||
|
namespace trnr::lib::synth {
|
||||||
|
|
||||||
|
enum env_state {
|
||||||
|
idle = 0,
|
||||||
|
attack1,
|
||||||
|
attack2,
|
||||||
|
hold,
|
||||||
|
decay1,
|
||||||
|
decay2,
|
||||||
|
sustain,
|
||||||
|
release1,
|
||||||
|
release2
|
||||||
|
};
|
||||||
|
|
||||||
|
class tx_envelope {
|
||||||
|
public:
|
||||||
|
float attack1_rate;
|
||||||
|
float attack1_level;
|
||||||
|
float attack2_rate;
|
||||||
|
float hold_rate;
|
||||||
|
float decay1_rate;
|
||||||
|
float decay1_level;
|
||||||
|
float decay2_rate;
|
||||||
|
float sustain_level;
|
||||||
|
float release1_rate;
|
||||||
|
float release1_level;
|
||||||
|
float release2_rate;
|
||||||
|
|
||||||
|
tx_envelope(double _samplerate)
|
||||||
|
: samplerate { _samplerate }
|
||||||
|
, attack1_rate { 0 }
|
||||||
|
, attack1_level { 0 }
|
||||||
|
, attack2_rate { 0 }
|
||||||
|
, hold_rate { 0 }
|
||||||
|
, decay1_rate { 0 }
|
||||||
|
, decay1_level { 0 }
|
||||||
|
, decay2_rate { 0 }
|
||||||
|
, sustain_level { 0 }
|
||||||
|
, release1_rate { 0 }
|
||||||
|
, release1_level { 0 }
|
||||||
|
, release2_rate { 0 }
|
||||||
|
, level { 0.f }
|
||||||
|
, phase { 0 }
|
||||||
|
, state { idle }
|
||||||
|
, start_level { 0.f }
|
||||||
|
, h1 { 0. }
|
||||||
|
, h2 { 0. }
|
||||||
|
, h3 { 0. }
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
float process_sample(bool gate, bool trigger) {
|
||||||
|
|
||||||
|
int attack_mid_x1 = ms_to_samples(attack1_rate);
|
||||||
|
int attack_mid_x2 = ms_to_samples(attack2_rate);
|
||||||
|
int hold_samp = ms_to_samples(hold_rate);
|
||||||
|
int decay_mid_x1 = ms_to_samples(decay1_rate);
|
||||||
|
int decay_mid_x2 = ms_to_samples(decay2_rate);
|
||||||
|
int release_mid_x1 = ms_to_samples(release1_rate);
|
||||||
|
int release_mid_x2 = ms_to_samples(release2_rate);
|
||||||
|
|
||||||
|
// if note on is triggered, transition to attack phase
|
||||||
|
if (trigger) {
|
||||||
|
start_level = level;
|
||||||
|
phase = 0;
|
||||||
|
state = attack1;
|
||||||
|
}
|
||||||
|
// attack 1st half
|
||||||
|
if (state == attack1) {
|
||||||
|
// while in attack phase
|
||||||
|
if (phase < attack_mid_x1) {
|
||||||
|
level = lerp(0, start_level, attack_mid_x1, attack1_level, phase);
|
||||||
|
phase += 1;
|
||||||
|
}
|
||||||
|
// reset phase if parameter was changed
|
||||||
|
if (phase > attack_mid_x1) {
|
||||||
|
phase = attack_mid_x1;
|
||||||
|
}
|
||||||
|
// if attack phase is done, transition to decay phase
|
||||||
|
if (phase == attack_mid_x1) {
|
||||||
|
state = attack2;
|
||||||
|
phase = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// attack 2nd half
|
||||||
|
if (state == attack2) {
|
||||||
|
// while in attack phase
|
||||||
|
if (phase < attack_mid_x2) {
|
||||||
|
level = lerp(0, attack1_level, attack_mid_x2, 1, phase);
|
||||||
|
phase += 1;
|
||||||
|
}
|
||||||
|
// reset phase if parameter was changed
|
||||||
|
if (phase > attack_mid_x2) {
|
||||||
|
phase = attack_mid_x2;
|
||||||
|
}
|
||||||
|
// if attack phase is done, transition to decay phase
|
||||||
|
if (phase == attack_mid_x2) {
|
||||||
|
state = hold;
|
||||||
|
phase = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// hold
|
||||||
|
if (state == hold) {
|
||||||
|
if (phase < hold_samp) {
|
||||||
|
level = 1.0;
|
||||||
|
phase += 1;
|
||||||
|
}
|
||||||
|
if (phase > hold_samp) {
|
||||||
|
phase = hold_samp;
|
||||||
|
}
|
||||||
|
if (phase == hold_samp) {
|
||||||
|
state = decay1;
|
||||||
|
phase = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// decay 1st half
|
||||||
|
if (state == decay1) {
|
||||||
|
// while in decay phase
|
||||||
|
if (phase < decay_mid_x1) {
|
||||||
|
level = lerp(0, 1, decay_mid_x1, decay1_level, phase);
|
||||||
|
phase += 1;
|
||||||
|
}
|
||||||
|
// reset phase if parameter was changed
|
||||||
|
if (phase > decay_mid_x1) {
|
||||||
|
phase = decay_mid_x1;
|
||||||
|
}
|
||||||
|
// if decay phase is done, transition to sustain phase
|
||||||
|
if (phase == decay_mid_x1) {
|
||||||
|
state = decay2;
|
||||||
|
phase = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// decay 2nd half
|
||||||
|
if (state == decay2) {
|
||||||
|
// while in decay phase
|
||||||
|
if (phase < decay_mid_x2) {
|
||||||
|
level = lerp(0, decay1_level, decay_mid_x2, sustain_level, phase);
|
||||||
|
phase += 1;
|
||||||
|
}
|
||||||
|
// reset phase if parameter was changed
|
||||||
|
if (phase > decay_mid_x2) {
|
||||||
|
phase = decay_mid_x2;
|
||||||
|
}
|
||||||
|
// if decay phase is done, transition to sustain phase
|
||||||
|
if (phase == decay_mid_x2) {
|
||||||
|
state = sustain;
|
||||||
|
phase = 0;
|
||||||
|
level = sustain_level;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// while sustain phase: if note off is triggered, transition to release phase
|
||||||
|
if (state == sustain && !gate) {
|
||||||
|
state = release1;
|
||||||
|
level = sustain_level;
|
||||||
|
}
|
||||||
|
// release 1st half
|
||||||
|
if (state == release1) {
|
||||||
|
// while in release phase
|
||||||
|
if (phase < release_mid_x1) {
|
||||||
|
level = lerp(0, sustain_level, release_mid_x1, release1_level, phase);
|
||||||
|
phase += 1;
|
||||||
|
}
|
||||||
|
// reset phase if parameter was changed
|
||||||
|
if (phase > release_mid_x1) {
|
||||||
|
phase = release_mid_x1;
|
||||||
|
}
|
||||||
|
// transition to 2nd release half
|
||||||
|
if (phase == release_mid_x1) {
|
||||||
|
phase = 0;
|
||||||
|
state = release2;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// release 2nd half
|
||||||
|
if (state == release2) {
|
||||||
|
// while in release phase
|
||||||
|
if (phase < release_mid_x2) {
|
||||||
|
level = lerp(0, release1_level, release_mid_x2, 0, phase);
|
||||||
|
phase += 1;
|
||||||
|
}
|
||||||
|
// reset phase if parameter was changed
|
||||||
|
if (phase > release_mid_x2) {
|
||||||
|
phase = release_mid_x2;
|
||||||
|
}
|
||||||
|
// reset
|
||||||
|
if (phase == release_mid_x2) {
|
||||||
|
phase = 0;
|
||||||
|
state = idle;
|
||||||
|
level = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return smooth(level);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool is_busy() { return state != 0; }
|
||||||
|
|
||||||
|
void set_samplerate(double sampleRate) {
|
||||||
|
this->samplerate = sampleRate;
|
||||||
|
}
|
||||||
|
|
||||||
|
// returns the x/y coordinates of the envelope points as a list for graphical representation.
|
||||||
|
std::array<float, 18> calc_coordinates() {
|
||||||
|
|
||||||
|
float a_x = 0;
|
||||||
|
float a_y = 0;
|
||||||
|
|
||||||
|
float b_x = attack1_rate;
|
||||||
|
float b_y = attack1_level;
|
||||||
|
|
||||||
|
float c_x = b_x + attack2_rate;
|
||||||
|
float c_y = 1;
|
||||||
|
|
||||||
|
float d_x = c_x + hold_rate;
|
||||||
|
float d_y = 1;
|
||||||
|
|
||||||
|
float e_x = d_x + decay1_rate;
|
||||||
|
float e_y = decay1_level;
|
||||||
|
|
||||||
|
float f_x = e_x + decay2_rate;
|
||||||
|
float f_y = sustain_level;
|
||||||
|
|
||||||
|
float g_x = f_x + 125;
|
||||||
|
float g_y = sustain_level;
|
||||||
|
|
||||||
|
float h_x = g_x + release1_rate;
|
||||||
|
float h_y = release1_level;
|
||||||
|
|
||||||
|
float i_x = h_x + release2_rate;
|
||||||
|
float i_y = 0;
|
||||||
|
|
||||||
|
float total = i_x;
|
||||||
|
|
||||||
|
return {
|
||||||
|
a_x,
|
||||||
|
a_y,
|
||||||
|
b_x / total,
|
||||||
|
b_y,
|
||||||
|
c_x / total,
|
||||||
|
c_y,
|
||||||
|
d_x / total,
|
||||||
|
d_y,
|
||||||
|
e_x / total,
|
||||||
|
e_y,
|
||||||
|
f_x / total,
|
||||||
|
f_y,
|
||||||
|
g_x / total,
|
||||||
|
g_y,
|
||||||
|
h_x / total,
|
||||||
|
h_y,
|
||||||
|
i_x / total,
|
||||||
|
i_y
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
double samplerate;
|
||||||
|
int phase;
|
||||||
|
float level;
|
||||||
|
env_state state;
|
||||||
|
float start_level;
|
||||||
|
float h1;
|
||||||
|
float h2;
|
||||||
|
float h3;
|
||||||
|
|
||||||
|
float lerp(float x1, float y1, float x2, float y2, float x) { return y1 + (((x - x1) * (y2 - y1)) / (x2 - x1)); }
|
||||||
|
|
||||||
|
float smooth(float sample) {
|
||||||
|
h3 = h2;
|
||||||
|
h2 = h1;
|
||||||
|
h1 = sample;
|
||||||
|
|
||||||
|
return (h1 + h2 + h3) / 3.f;
|
||||||
|
}
|
||||||
|
|
||||||
|
float ms_to_samples(float ms) { return ms * samplerate / 1000.f; }
|
||||||
|
};
|
||||||
|
}
|
||||||
39
synth/tx_operator.h
Normal file
39
synth/tx_operator.h
Normal file
@@ -0,0 +1,39 @@
|
|||||||
|
#pragma once
|
||||||
|
#include "tx_sineosc.h"
|
||||||
|
#include "tx_envelope.h"
|
||||||
|
|
||||||
|
namespace trnr::lib::synth {
|
||||||
|
class tx_operator {
|
||||||
|
public:
|
||||||
|
tx_operator(double samplerate)
|
||||||
|
: ratio { 1 }
|
||||||
|
, amplitude { 1.0f }
|
||||||
|
, envelope(samplerate)
|
||||||
|
, oscillator(samplerate)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
tx_envelope envelope;
|
||||||
|
tx_sineosc oscillator;
|
||||||
|
float ratio;
|
||||||
|
float amplitude;
|
||||||
|
|
||||||
|
float process_sample(const bool& gate, const bool& trigger, const float& frequency, const float& velocity, const float& pm = 0) {
|
||||||
|
|
||||||
|
float env = envelope.process_sample(gate, trigger);
|
||||||
|
|
||||||
|
// drifts and sounds better!
|
||||||
|
if (envelope.is_busy()) {
|
||||||
|
double osc = oscillator.process_sample(trigger, frequency, pm);
|
||||||
|
return osc * env * velocity;
|
||||||
|
} else {
|
||||||
|
return 0.;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_samplerate(double samplerate) {
|
||||||
|
this->envelope.set_samplerate(samplerate);
|
||||||
|
this->oscillator.set_samplerate(samplerate);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
95
synth/tx_sineosc.h
Normal file
95
synth/tx_sineosc.h
Normal file
@@ -0,0 +1,95 @@
|
|||||||
|
#pragma once
|
||||||
|
#include <cmath>
|
||||||
|
|
||||||
|
namespace trnr::lib::synth {
|
||||||
|
|
||||||
|
class tx_sineosc {
|
||||||
|
public:
|
||||||
|
bool phase_reset;
|
||||||
|
|
||||||
|
tx_sineosc(double _samplerate)
|
||||||
|
: samplerate { _samplerate }
|
||||||
|
, phase_resolution { 16.f }
|
||||||
|
, phase { 0. }
|
||||||
|
, history { 0. }
|
||||||
|
, phase_reset { false }
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_phase_resolution(float res) {
|
||||||
|
phase_resolution = powf(2, res);
|
||||||
|
}
|
||||||
|
|
||||||
|
float process_sample(bool trigger, float frequency, float phase_modulation = 0.f) {
|
||||||
|
if (trigger && phase_reset) {
|
||||||
|
phase = 0.0;
|
||||||
|
}
|
||||||
|
|
||||||
|
float lookup_phase = phase + phase_modulation;
|
||||||
|
wrap(lookup_phase);
|
||||||
|
phase += frequency / samplerate;
|
||||||
|
wrap(phase);
|
||||||
|
|
||||||
|
redux(lookup_phase);
|
||||||
|
|
||||||
|
float output = sine(lookup_phase * 4096.);
|
||||||
|
|
||||||
|
filter(output);
|
||||||
|
return output;
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_samplerate(double _samplerate) {
|
||||||
|
this->samplerate = _samplerate;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
double samplerate;
|
||||||
|
float phase_resolution;
|
||||||
|
float phase;
|
||||||
|
float history;
|
||||||
|
|
||||||
|
float sine(float x) {
|
||||||
|
// x is scaled 0<=x<4096
|
||||||
|
const float a = -0.40319426317E-08;
|
||||||
|
const float b = 0.21683205691E+03;
|
||||||
|
const float c = 0.28463350538E-04;
|
||||||
|
const float d = -0.30774648337E-02;
|
||||||
|
float y;
|
||||||
|
|
||||||
|
bool negate = false;
|
||||||
|
if (x > 2048) {
|
||||||
|
negate = true;
|
||||||
|
x -= 2048;
|
||||||
|
}
|
||||||
|
if (x > 1024)
|
||||||
|
x = 2048 - x;
|
||||||
|
y = (a + x) / (b + c * x * x) + d * x;
|
||||||
|
if (negate)
|
||||||
|
return (float)(-y);
|
||||||
|
else
|
||||||
|
return (float)y;
|
||||||
|
}
|
||||||
|
|
||||||
|
float wrap(float& phase) {
|
||||||
|
while (phase < 0.)
|
||||||
|
phase += 1.;
|
||||||
|
|
||||||
|
while (phase >= 1.)
|
||||||
|
phase -= 1.;
|
||||||
|
|
||||||
|
return phase;
|
||||||
|
}
|
||||||
|
|
||||||
|
float filter(float& value) {
|
||||||
|
value = 0.5 * (value + history);
|
||||||
|
history = value;
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
float redux(float& value)
|
||||||
|
{
|
||||||
|
value = static_cast<int>(value * phase_resolution) / phase_resolution;
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
166
synth/tx_voice.h
Normal file
166
synth/tx_voice.h
Normal file
@@ -0,0 +1,166 @@
|
|||||||
|
#pragma once
|
||||||
|
#include "tx_sineosc.h"
|
||||||
|
#include "tx_envelope.h"
|
||||||
|
#include "tx_operator.h"
|
||||||
|
|
||||||
|
namespace trnr::lib::synth {
|
||||||
|
|
||||||
|
class tx_voice {
|
||||||
|
public:
|
||||||
|
tx_voice(double samplerate)
|
||||||
|
: algorithm { 0 }
|
||||||
|
, pitch_env_amt { 0.f }
|
||||||
|
, feedback_amt { 0.f }
|
||||||
|
, pitch_env(samplerate)
|
||||||
|
, feedback_osc(samplerate)
|
||||||
|
, op1(samplerate)
|
||||||
|
, op2(samplerate)
|
||||||
|
, op3(samplerate)
|
||||||
|
, bit_resolution(12.f)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
bool gate = false;
|
||||||
|
bool trigger = false;
|
||||||
|
float frequency = 100.f;
|
||||||
|
float velocity = 1.f;
|
||||||
|
|
||||||
|
int algorithm;
|
||||||
|
float pitch_env_amt;
|
||||||
|
float feedback_amt;
|
||||||
|
float bit_resolution;
|
||||||
|
tx_sineosc feedback_osc;
|
||||||
|
tx_envelope pitch_env;
|
||||||
|
tx_operator op1;
|
||||||
|
tx_operator op2;
|
||||||
|
tx_operator op3;
|
||||||
|
|
||||||
|
float process_sample() {
|
||||||
|
float pitch_env_signal = pitch_env.process_sample(gate, trigger) * pitch_env_amt;
|
||||||
|
float pitched_freq = frequency + pitch_env_signal;
|
||||||
|
|
||||||
|
float output = 0.f;
|
||||||
|
|
||||||
|
// mix operator signals according to selected algorithm
|
||||||
|
switch (algorithm) {
|
||||||
|
case 0:
|
||||||
|
output = calc_algo1(pitched_freq);
|
||||||
|
break;
|
||||||
|
case 1:
|
||||||
|
output = calc_algo2(pitched_freq);
|
||||||
|
break;
|
||||||
|
case 2:
|
||||||
|
output = calc_algo3(pitched_freq);
|
||||||
|
break;
|
||||||
|
case 3:
|
||||||
|
output = calc_algo4(pitched_freq);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
output = calc_algo1(pitched_freq);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
// reset trigger
|
||||||
|
trigger = false;
|
||||||
|
|
||||||
|
return redux(output, bit_resolution);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool is_busy() { return gate || op1.envelope.is_busy() || op2.envelope.is_busy() || op3.envelope.is_busy(); }
|
||||||
|
|
||||||
|
void set_samplerate(double samplerate) {
|
||||||
|
pitch_env.set_samplerate(samplerate);
|
||||||
|
feedback_osc.set_samplerate(samplerate);
|
||||||
|
op1.set_samplerate(samplerate);
|
||||||
|
op2.set_samplerate(samplerate);
|
||||||
|
op3.set_samplerate(samplerate);
|
||||||
|
}
|
||||||
|
|
||||||
|
void set_phase_reset(bool phase_reset) {
|
||||||
|
op1.oscillator.phase_reset = phase_reset;
|
||||||
|
op2.oscillator.phase_reset = phase_reset;
|
||||||
|
op3.oscillator.phase_reset = phase_reset;
|
||||||
|
feedback_osc.phase_reset = phase_reset;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
const float MOD_INDEX_COEFF = 4.f;
|
||||||
|
|
||||||
|
float calc_algo1(const float frequency) {
|
||||||
|
float fb_freq = frequency * op3.ratio;
|
||||||
|
float fb_mod_index = (feedback_amt * MOD_INDEX_COEFF);
|
||||||
|
float fb_signal = feedback_osc.process_sample(trigger, fb_freq) * fb_mod_index;
|
||||||
|
|
||||||
|
float op3_Freq = frequency * op3.ratio;
|
||||||
|
float op3_mod_index = (op3.amplitude * MOD_INDEX_COEFF);
|
||||||
|
float op3_signal = op3.process_sample(gate, trigger, op3_Freq, velocity, fb_signal) * op3_mod_index;
|
||||||
|
|
||||||
|
float op2_freq = frequency * op2.ratio;
|
||||||
|
float op2_mod_index = (op2.amplitude * MOD_INDEX_COEFF);
|
||||||
|
float op2_signal = op2.process_sample(gate, trigger, op2_freq, velocity, op3_signal) * op2_mod_index;
|
||||||
|
|
||||||
|
float op1_freq = frequency * op1.ratio;
|
||||||
|
return op1.process_sample(gate, trigger, op1_freq, velocity, op2_signal) * op1.amplitude;
|
||||||
|
}
|
||||||
|
|
||||||
|
float calc_algo2(const float frequency) {
|
||||||
|
float fb_freq = frequency * op3.ratio;
|
||||||
|
float fb_mod_index = (feedback_amt * MOD_INDEX_COEFF);
|
||||||
|
float fb_signal = feedback_osc.process_sample(trigger, fb_freq) * fb_mod_index;
|
||||||
|
|
||||||
|
float op3_freq = frequency * op3.ratio;
|
||||||
|
float op3_signal = op3.process_sample(gate, trigger, op3_freq, velocity, fb_signal) * op3.amplitude;
|
||||||
|
|
||||||
|
float op2_freq = frequency * op2.ratio;
|
||||||
|
float op2_mod_index = (op2.amplitude * MOD_INDEX_COEFF);
|
||||||
|
float op2_signal = op2.process_sample(gate, trigger, op2_freq, velocity) * op2_mod_index;
|
||||||
|
|
||||||
|
float op1_freq = frequency * op1.ratio;
|
||||||
|
float op1_signal = op1.process_sample(gate, trigger, op1_freq, velocity, op2_signal) * op1.amplitude;
|
||||||
|
|
||||||
|
return op1_signal + op3_signal;
|
||||||
|
}
|
||||||
|
|
||||||
|
float calc_algo3(const float frequency) {
|
||||||
|
float fb_freq = frequency * op3.ratio;
|
||||||
|
float fb_mod_index = (feedback_amt * MOD_INDEX_COEFF);
|
||||||
|
float fb_signal = feedback_osc.process_sample(trigger, fb_freq) * fb_mod_index;
|
||||||
|
|
||||||
|
float op3_freq = frequency * op3.ratio;
|
||||||
|
float op3_signal = op3.process_sample(gate, trigger, op3_freq, velocity, fb_signal) * op3.amplitude;
|
||||||
|
|
||||||
|
float op2_freq = frequency * op2.ratio;
|
||||||
|
float op2_signal = op2.process_sample(gate, trigger, op2_freq, velocity) * op2.amplitude;
|
||||||
|
|
||||||
|
float op1_freq = frequency * op1.ratio;
|
||||||
|
float op1_signal = op1.process_sample(gate, trigger, op1_freq, velocity) * op1.amplitude;
|
||||||
|
|
||||||
|
return op1_signal + op2_signal + op3_signal;
|
||||||
|
}
|
||||||
|
|
||||||
|
float calc_algo4(const float frequency) {
|
||||||
|
float fb_freq = frequency * op3.ratio;
|
||||||
|
float fb_mod_index = (feedback_amt * MOD_INDEX_COEFF);
|
||||||
|
float fb_signal = feedback_osc.process_sample(trigger, fb_freq) * fb_mod_index;
|
||||||
|
|
||||||
|
float op3_freq = frequency * op3.ratio;
|
||||||
|
float op3_mod_index = (op3.amplitude * MOD_INDEX_COEFF);
|
||||||
|
float op3_signal = op3.process_sample(gate, trigger, op3_freq, velocity, fb_signal) * op3_mod_index;
|
||||||
|
|
||||||
|
float op2_freq = frequency * op2.ratio;
|
||||||
|
float op2_mod_index = (op2.amplitude * MOD_INDEX_COEFF);
|
||||||
|
float op2_signal = op2.process_sample(gate, trigger, op2_freq, velocity) * op2_mod_index;
|
||||||
|
|
||||||
|
float op1_freq = frequency * op1.ratio;
|
||||||
|
return op1.process_sample(gate, trigger, op1_freq, velocity, op2_signal + op3_signal) * op1.amplitude;
|
||||||
|
}
|
||||||
|
|
||||||
|
float redux(float& value, float resolution)
|
||||||
|
{
|
||||||
|
float res = powf(2, resolution);
|
||||||
|
value = roundf(value * res) / res;
|
||||||
|
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
11
util/audio_math.h
Normal file
11
util/audio_math.h
Normal file
@@ -0,0 +1,11 @@
|
|||||||
|
#include <math.h>
|
||||||
|
|
||||||
|
namespace trnr::lib::util {
|
||||||
|
static inline double lin_2_db(double lin) {
|
||||||
|
return 20 * log(lin);
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline double db_2_lin(double db) {
|
||||||
|
return pow(10, db/20);
|
||||||
|
}
|
||||||
|
}
|
||||||
Reference in New Issue
Block a user