/* ========================================
* Pafnuty - Pafnuty.h
* Copyright (c) 2016 airwindows, All rights reserved
* ======================================== */
#ifndef __Pafnuty_H
#include "Pafnuty.h"
#endif
void Pafnuty::processReplacing(float **inputs, float **outputs, VstInt32 sampleFrames)
{
float* in1 = inputs[0];
float* in2 = inputs[1];
float* out1 = outputs[0];
float* out2 = outputs[1];
long double chebyshev;
long double effxct; //this highlighted when spelled 'effect', might be a reserved word for VST
long double inP2;
long double inP3;
long double inP4;
long double inP5;
long double inP6;
long double inP7;
long double inP8;
long double inP9;
long double inP10;
long double inP11;
long double inP12;
long double inP13;
long double second = (((A*2.0)-1.0)*1.0);
second = second * fabs(second);
long double third = -(((B*2.0)-1.0)*0.60);
third = third * fabs(third);
long double fourth = -(((C*2.0)-1.0)*0.60);
fourth = fourth * fabs(fourth);
long double fifth = (((D*2.0)-1.0)*0.45);
fifth = fifth * fabs(fifth);
long double sixth = (((E*2.0)-1.0)*0.45);
sixth = sixth * fabs(sixth);
long double seventh = -(((F*2.0)-1.0)*0.38);
seventh = seventh * fabs(seventh);
long double eighth = -(((G*2.0)-1.0)*0.38);
eighth = eighth * fabs(eighth);
long double ninth = (((H*2.0)-1.0)*0.35);
ninth = ninth * fabs(ninth);
long double tenth = (((I*2.0)-1.0)*0.35);
tenth = tenth * fabs(tenth);
long double eleventh = -(((J*2.0)-1.0)*0.32);
eleventh = eleventh * fabs(eleventh);
long double twelvth = -(((K*2.0)-1.0)*0.32);
twelvth = twelvth * fabs(twelvth);
long double thirteenth = (((L*2.0)-1.0)*0.30);
thirteenth = thirteenth * fabs(thirteenth);
long double amount = (M*2.0)-1.0;
amount = amount * fabs(amount);
//setting up
while (--sampleFrames >= 0)
{
long double inputSampleL = *in1;
long double inputSampleR = *in2;
static int noisesourceL = 0;
static int noisesourceR = 850010;
int residue;
double applyresidue;
noisesourceL = noisesourceL % 1700021; noisesourceL++;
residue = noisesourceL * noisesourceL;
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;
inputSampleL += applyresidue;
if (inputSampleL<1.2e-38 && -inputSampleL<1.2e-38) {
inputSampleL -= applyresidue;
}
noisesourceR = noisesourceR % 1700021; noisesourceR++;
residue = noisesourceR * noisesourceR;
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;
inputSampleR += applyresidue;
if (inputSampleR<1.2e-38 && -inputSampleR<1.2e-38) {
inputSampleR -= applyresidue;
}
//for live air, we always apply the dither noise. Then, if our result is
//effectively digital black, we'll subtract it again. We want a 'air' hiss
//left channel
effxct = 0.0;
inP2 = inputSampleL * inputSampleL;
inP3 = inP2 * inputSampleL;
inP4 = inP3 * inputSampleL;
inP5 = inP4 * inputSampleL;
inP6 = inP5 * inputSampleL;
inP7 = inP6 * inputSampleL;
inP8 = inP7 * inputSampleL;
inP9 = inP8 * inputSampleL;
inP10 = inP9 * inputSampleL;
inP11 = inP10 * inputSampleL;
inP12 = inP11 * inputSampleL;
inP13 = inP12 * inputSampleL;
//let's do the powers ahead of time and see how we do.
if (second != 0.0)
{
chebyshev = (2 * inP2);
effxct += (chebyshev * second);
}
if (third != 0.0)
{
chebyshev = (4 * inP3) - (3*inputSampleL);
effxct += (chebyshev * third);
}
if (fourth != 0.0)
{
chebyshev = (8 * inP4) - (8 * inP2);
effxct += (chebyshev * fourth);
}
if (fifth != 0.0)
{
chebyshev = (16 * inP5) - (20 * inP3) + (5*inputSampleL);
effxct += (chebyshev * fifth);
}
if (sixth != 0.0)
{
chebyshev = (32 * inP6) - (48 * inP4) + (18 * inP2);
effxct += (chebyshev * sixth);
}
if (seventh != 0.0)
{
chebyshev = (64 * inP7) - (112 * inP5) + (56 * inP3) - (7*inputSampleL);
effxct += (chebyshev * seventh);
}
if (eighth != 0.0)
{
chebyshev = (128 * inP8) - (256 * inP6) + (160 * inP4) - (32 * inP2);
effxct += (chebyshev * eighth);
}
if (ninth != 0.0)
{
chebyshev = (256 * inP9) - (576 * inP7) + (432 * inP5) - (120 * inP3) + (9*inputSampleL);
effxct += (chebyshev * ninth);
}
if (tenth != 0.0)
{
chebyshev = (512 * inP10) - (1280 * inP8) + (1120 * inP6) - (400 * inP4) + (50 * inP2);
effxct += (chebyshev * tenth);
}
if (eleventh != 0.0)
{
chebyshev = (1024 * inP11) - (2816 * inP9) + (2816 * inP7) - (1232 * inP5) + (220 * inP3) - (11*inputSampleL);
effxct += (chebyshev * eleventh);
}
if (twelvth != 0.0)
{
chebyshev = (2048 * inP12) - (6144 * inP10) + (6912 * inP8) - (3584 * inP6) + (840 * inP4) - (72 * inP2);
effxct += (chebyshev * twelvth);
}
if (thirteenth != 0.0)
{
chebyshev = (4096 * inP13) - (13312 * inP11) + (16640 * inP9) - (9984 * inP7) + (2912 * inP5) - (364 * inP3) + (13*inputSampleL);
effxct += (chebyshev * thirteenth);
}
//Yowza! Aren't we glad we're testing to see if we can skip these little bastards?
inputSampleL += (effxct * amount);
//You too can make a horrible graunch and then SUBTRACT it leaving only the refreshing smell of pine...
//end left channel
//right channel
effxct = 0.0;
inP2 = inputSampleR * inputSampleR;
inP3 = inP2 * inputSampleR;
inP4 = inP3 * inputSampleR;
inP5 = inP4 * inputSampleR;
inP6 = inP5 * inputSampleR;
inP7 = inP6 * inputSampleR;
inP8 = inP7 * inputSampleR;
inP9 = inP8 * inputSampleR;
inP10 = inP9 * inputSampleR;
inP11 = inP10 * inputSampleR;
inP12 = inP11 * inputSampleR;
inP13 = inP12 * inputSampleR;
//let's do the powers ahead of time and see how we do.
if (second != 0.0)
{
chebyshev = (2 * inP2);
effxct += (chebyshev * second);
}
if (third != 0.0)
{
chebyshev = (4 * inP3) - (3*inputSampleR);
effxct += (chebyshev * third);
}
if (fourth != 0.0)
{
chebyshev = (8 * inP4) - (8 * inP2);
effxct += (chebyshev * fourth);
}
if (fifth != 0.0)
{
chebyshev = (16 * inP5) - (20 * inP3) + (5*inputSampleR);
effxct += (chebyshev * fifth);
}
if (sixth != 0.0)
{
chebyshev = (32 * inP6) - (48 * inP4) + (18 * inP2);
effxct += (chebyshev * sixth);
}
if (seventh != 0.0)
{
chebyshev = (64 * inP7) - (112 * inP5) + (56 * inP3) - (7*inputSampleR);
effxct += (chebyshev * seventh);
}
if (eighth != 0.0)
{
chebyshev = (128 * inP8) - (256 * inP6) + (160 * inP4) - (32 * inP2);
effxct += (chebyshev * eighth);
}
if (ninth != 0.0)
{
chebyshev = (256 * inP9) - (576 * inP7) + (432 * inP5) - (120 * inP3) + (9*inputSampleR);
effxct += (chebyshev * ninth);
}
if (tenth != 0.0)
{
chebyshev = (512 * inP10) - (1280 * inP8) + (1120 * inP6) - (400 * inP4) + (50 * inP2);
effxct += (chebyshev * tenth);
}
if (eleventh != 0.0)
{
chebyshev = (1024 * inP11) - (2816 * inP9) + (2816 * inP7) - (1232 * inP5) + (220 * inP3) - (11*inputSampleR);
effxct += (chebyshev * eleventh);
}
if (twelvth != 0.0)
{
chebyshev = (2048 * inP12) - (6144 * inP10) + (6912 * inP8) - (3584 * inP6) + (840 * inP4) - (72 * inP2);
effxct += (chebyshev * twelvth);
}
if (thirteenth != 0.0)
{
chebyshev = (4096 * inP13) - (13312 * inP11) + (16640 * inP9) - (9984 * inP7) + (2912 * inP5) - (364 * inP3) + (13*inputSampleR);
effxct += (chebyshev * thirteenth);
}
//Yowza! Aren't we glad we're testing to see if we can skip these little bastards?
inputSampleR += (effxct * amount);
//You too can make a horrible graunch and then SUBTRACT it leaving only the refreshing smell of pine...
//end right channel
//stereo 32 bit dither, made small and tidy.
int expon; frexpf((float)inputSampleL, &expon);
long double dither = (rand()/(RAND_MAX*7.737125245533627e+25))*pow(2,expon+62);
inputSampleL += (dither-fpNShapeL); fpNShapeL = dither;
frexpf((float)inputSampleR, &expon);
dither = (rand()/(RAND_MAX*7.737125245533627e+25))*pow(2,expon+62);
inputSampleR += (dither-fpNShapeR); fpNShapeR = dither;
//end 32 bit dither
*out1 = inputSampleL;
*out2 = inputSampleR;
*in1++;
*in2++;
*out1++;
*out2++;
}
}
void Pafnuty::processDoubleReplacing(double **inputs, double **outputs, VstInt32 sampleFrames)
{
double* in1 = inputs[0];
double* in2 = inputs[1];
double* out1 = outputs[0];
double* out2 = outputs[1];
long double chebyshev;
long double effxct; //this highlighted when spelled 'effect', might be a reserved word for VST
long double inP2;
long double inP3;
long double inP4;
long double inP5;
long double inP6;
long double inP7;
long double inP8;
long double inP9;
long double inP10;
long double inP11;
long double inP12;
long double inP13;
long double second = (((A*2.0)-1.0)*1.0);
second = second * fabs(second);
long double third = -(((B*2.0)-1.0)*0.60);
third = third * fabs(third);
long double fourth = -(((C*2.0)-1.0)*0.60);
fourth = fourth * fabs(fourth);
long double fifth = (((D*2.0)-1.0)*0.45);
fifth = fifth * fabs(fifth);
long double sixth = (((E*2.0)-1.0)*0.45);
sixth = sixth * fabs(sixth);
long double seventh = -(((F*2.0)-1.0)*0.38);
seventh = seventh * fabs(seventh);
long double eighth = -(((G*2.0)-1.0)*0.38);
eighth = eighth * fabs(eighth);
long double ninth = (((H*2.0)-1.0)*0.35);
ninth = ninth * fabs(ninth);
long double tenth = (((I*2.0)-1.0)*0.35);
tenth = tenth * fabs(tenth);
long double eleventh = -(((J*2.0)-1.0)*0.32);
eleventh = eleventh * fabs(eleventh);
long double twelvth = -(((K*2.0)-1.0)*0.32);
twelvth = twelvth * fabs(twelvth);
long double thirteenth = (((L*2.0)-1.0)*0.30);
thirteenth = thirteenth * fabs(thirteenth);
long double amount = (M*2.0)-1.0;
amount = amount * fabs(amount);
//setting up
while (--sampleFrames >= 0)
{
long double inputSampleL = *in1;
long double inputSampleR = *in2;
static int noisesourceL = 0;
static int noisesourceR = 850010;
int residue;
double applyresidue;
noisesourceL = noisesourceL % 1700021; noisesourceL++;
residue = noisesourceL * noisesourceL;
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;
inputSampleL += applyresidue;
if (inputSampleL<1.2e-38 && -inputSampleL<1.2e-38) {
inputSampleL -= applyresidue;
}
noisesourceR = noisesourceR % 1700021; noisesourceR++;
residue = noisesourceR * noisesourceR;
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;
inputSampleR += applyresidue;
if (inputSampleR<1.2e-38 && -inputSampleR<1.2e-38) {
inputSampleR -= applyresidue;
}
//for live air, we always apply the dither noise. Then, if our result is
//effectively digital black, we'll subtract it again. We want a 'air' hiss
//left channel
effxct = 0.0;
inP2 = inputSampleL * inputSampleL;
inP3 = inP2 * inputSampleL;
inP4 = inP3 * inputSampleL;
inP5 = inP4 * inputSampleL;
inP6 = inP5 * inputSampleL;
inP7 = inP6 * inputSampleL;
inP8 = inP7 * inputSampleL;
inP9 = inP8 * inputSampleL;
inP10 = inP9 * inputSampleL;
inP11 = inP10 * inputSampleL;
inP12 = inP11 * inputSampleL;
inP13 = inP12 * inputSampleL;
//let's do the powers ahead of time and see how we do.
if (second != 0.0)
{
chebyshev = (2 * inP2);
effxct += (chebyshev * second);
}
if (third != 0.0)
{
chebyshev = (4 * inP3) - (3*inputSampleL);
effxct += (chebyshev * third);
}
if (fourth != 0.0)
{
chebyshev = (8 * inP4) - (8 * inP2);
effxct += (chebyshev * fourth);
}
if (fifth != 0.0)
{
chebyshev = (16 * inP5) - (20 * inP3) + (5*inputSampleL);
effxct += (chebyshev * fifth);
}
if (sixth != 0.0)
{
chebyshev = (32 * inP6) - (48 * inP4) + (18 * inP2);
effxct += (chebyshev * sixth);
}
if (seventh != 0.0)
{
chebyshev = (64 * inP7) - (112 * inP5) + (56 * inP3) - (7*inputSampleL);
effxct += (chebyshev * seventh);
}
if (eighth != 0.0)
{
chebyshev = (128 * inP8) - (256 * inP6) + (160 * inP4) - (32 * inP2);
effxct += (chebyshev * eighth);
}
if (ninth != 0.0)
{
chebyshev = (256 * inP9) - (576 * inP7) + (432 * inP5) - (120 * inP3) + (9*inputSampleL);
effxct += (chebyshev * ninth);
}
if (tenth != 0.0)
{
chebyshev = (512 * inP10) - (1280 * inP8) + (1120 * inP6) - (400 * inP4) + (50 * inP2);
effxct += (chebyshev * tenth);
}
if (eleventh != 0.0)
{
chebyshev = (1024 * inP11) - (2816 * inP9) + (2816 * inP7) - (1232 * inP5) + (220 * inP3) - (11*inputSampleL);
effxct += (chebyshev * eleventh);
}
if (twelvth != 0.0)
{
chebyshev = (2048 * inP12) - (6144 * inP10) + (6912 * inP8) - (3584 * inP6) + (840 * inP4) - (72 * inP2);
effxct += (chebyshev * twelvth);
}
if (thirteenth != 0.0)
{
chebyshev = (4096 * inP13) - (13312 * inP11) + (16640 * inP9) - (9984 * inP7) + (2912 * inP5) - (364 * inP3) + (13*inputSampleL);
effxct += (chebyshev * thirteenth);
}
//Yowza! Aren't we glad we're testing to see if we can skip these little bastards?
inputSampleL += (effxct * amount);
//You too can make a horrible graunch and then SUBTRACT it leaving only the refreshing smell of pine...
//end left channel
//right channel
effxct = 0.0;
inP2 = inputSampleR * inputSampleR;
inP3 = inP2 * inputSampleR;
inP4 = inP3 * inputSampleR;
inP5 = inP4 * inputSampleR;
inP6 = inP5 * inputSampleR;
inP7 = inP6 * inputSampleR;
inP8 = inP7 * inputSampleR;
inP9 = inP8 * inputSampleR;
inP10 = inP9 * inputSampleR;
inP11 = inP10 * inputSampleR;
inP12 = inP11 * inputSampleR;
inP13 = inP12 * inputSampleR;
//let's do the powers ahead of time and see how we do.
if (second != 0.0)
{
chebyshev = (2 * inP2);
effxct += (chebyshev * second);
}
if (third != 0.0)
{
chebyshev = (4 * inP3) - (3*inputSampleR);
effxct += (chebyshev * third);
}
if (fourth != 0.0)
{
chebyshev = (8 * inP4) - (8 * inP2);
effxct += (chebyshev * fourth);
}
if (fifth != 0.0)
{
chebyshev = (16 * inP5) - (20 * inP3) + (5*inputSampleR);
effxct += (chebyshev * fifth);
}
if (sixth != 0.0)
{
chebyshev = (32 * inP6) - (48 * inP4) + (18 * inP2);
effxct += (chebyshev * sixth);
}
if (seventh != 0.0)
{
chebyshev = (64 * inP7) - (112 * inP5) + (56 * inP3) - (7*inputSampleR);
effxct += (chebyshev * seventh);
}
if (eighth != 0.0)
{
chebyshev = (128 * inP8) - (256 * inP6) + (160 * inP4) - (32 * inP2);
effxct += (chebyshev * eighth);
}
if (ninth != 0.0)
{
chebyshev = (256 * inP9) - (576 * inP7) + (432 * inP5) - (120 * inP3) + (9*inputSampleR);
effxct += (chebyshev * ninth);
}
if (tenth != 0.0)
{
chebyshev = (512 * inP10) - (1280 * inP8) + (1120 * inP6) - (400 * inP4) + (50 * inP2);
effxct += (chebyshev * tenth);
}
if (eleventh != 0.0)
{
chebyshev = (1024 * inP11) - (2816 * inP9) + (2816 * inP7) - (1232 * inP5) + (220 * inP3) - (11*inputSampleR);
effxct += (chebyshev * eleventh);
}
if (twelvth != 0.0)
{
chebyshev = (2048 * inP12) - (6144 * inP10) + (6912 * inP8) - (3584 * inP6) + (840 * inP4) - (72 * inP2);
effxct += (chebyshev * twelvth);
}
if (thirteenth != 0.0)
{
chebyshev = (4096 * inP13) - (13312 * inP11) + (16640 * inP9) - (9984 * inP7) + (2912 * inP5) - (364 * inP3) + (13*inputSampleR);
effxct += (chebyshev * thirteenth);
}
//Yowza! Aren't we glad we're testing to see if we can skip these little bastards?
inputSampleR += (effxct * amount);
//You too can make a horrible graunch and then SUBTRACT it leaving only the refreshing smell of pine...
//end right channel
//stereo 64 bit dither, made small and tidy.
int expon; frexp((double)inputSampleL, &expon);
long double dither = (rand()/(RAND_MAX*7.737125245533627e+25))*pow(2,expon+62);
dither /= 536870912.0; //needs this to scale to 64 bit zone
inputSampleL += (dither-fpNShapeL); fpNShapeL = dither;
frexp((double)inputSampleR, &expon);
dither = (rand()/(RAND_MAX*7.737125245533627e+25))*pow(2,expon+62);
dither /= 536870912.0; //needs this to scale to 64 bit zone
inputSampleR += (dither-fpNShapeR); fpNShapeR = dither;
//end 64 bit dither
*out1 = inputSampleL;
*out2 = inputSampleR;
*in1++;
*in2++;
*out1++;
*out2++;
}
}