/* ========================================
* Energy - Energy.h
* Copyright (c) 2016 airwindows, All rights reserved
* ======================================== */
#ifndef __Energy_H
#include "Energy.h"
#endif
void Energy::processReplacing(float **inputs, float **outputs, VstInt32 sampleFrames)
{
float* in1 = inputs[0];
float* in2 = inputs[1];
float* out1 = outputs[0];
float* out2 = outputs[1];
double duoIntensity = -pow((A*2.0)-1.0,3);
double tripletIntensity = -pow((B*2.0)-1.0,3);
double quadIntensity = -pow((C*2.0)-1.0,3);
double quintIntensity = -pow((D*2.0)-1.0,3);
double sextIntensity = -pow((E*2.0)-1.0,3);
double septIntensity = -pow((F*2.0)-1.0,3);
double octIntensity = -pow((G*2.0)-1.0,3);
double nintIntensity = -pow((H*2.0)-1.0,3);
double mix = (I*2.0)-1.0;
//all types of air band are running in parallel, not series
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
long double correctionL = 0.0;
long double correctionR = 0.0;
duoFactorL = PrevAL - inputSampleL;
duoFactorR = PrevAR - inputSampleR;
if (flip)
{
duoEvenL += duoFactorL;
duoOddL -= duoFactorL;
duoFactorL = duoEvenL * duoIntensity;
duoEvenR += duoFactorR;
duoOddR -= duoFactorR;
duoFactorR = duoEvenR * duoIntensity;
}
else
{
duoOddL += duoFactorL;
duoEvenL -= duoFactorL;
duoFactorL = duoOddL * duoIntensity;
duoOddR += duoFactorR;
duoEvenR -= duoFactorR;
duoFactorR = duoOddR * duoIntensity;
}
duoOddL = (duoOddL - ((duoOddL - duoEvenL)/256.0)) / 2.0;
duoEvenL = (duoEvenL - ((duoEvenL - duoOddL)/256.0)) / 2.0;
correctionL = correctionL + duoFactorL;
duoOddR = (duoOddR - ((duoOddR - duoEvenR)/256.0)) / 2.0;
duoEvenR = (duoEvenR - ((duoEvenR - duoOddR)/256.0)) / 2.0;
correctionR = correctionR + duoFactorR;
flip = !flip;
//finished duo section
if (countA < 1 || countA > 3) countA = 1;
switch (countA)
{
case 1:
tripletFactorL = PrevBL - inputSampleL;
tripletAL += tripletFactorL;
tripletCL -= tripletFactorL;
tripletFactorL = tripletAL * tripletIntensity;
tripletFactorR = PrevBR - inputSampleR;
tripletAR += tripletFactorR;
tripletCR -= tripletFactorR;
tripletFactorR = tripletAR * tripletIntensity;
break;
case 2:
tripletFactorL = PrevBL - inputSampleL;
tripletBL += tripletFactorL;
tripletAL -= tripletFactorL;
tripletFactorL = tripletBL * tripletIntensity;
tripletFactorR = PrevBR - inputSampleR;
tripletBR += tripletFactorR;
tripletAR -= tripletFactorR;
tripletFactorR = tripletBR * tripletIntensity;
break;
case 3:
tripletFactorL = PrevBL - inputSampleL;
tripletCL += tripletFactorL;
tripletBL -= tripletFactorL;
tripletFactorL = tripletCL * tripletIntensity;
tripletFactorR = PrevBR - inputSampleR;
tripletCR += tripletFactorR;
tripletBR -= tripletFactorR;
tripletFactorR = tripletCR * tripletIntensity;
break;
}
tripletAL /= 2.0;
tripletBL /= 2.0;
tripletCL /= 2.0;
correctionL = correctionL + tripletFactorL;
tripletAR /= 2.0;
tripletBR /= 2.0;
tripletCR /= 2.0;
correctionR = correctionR + tripletFactorR;
countA++;
//finished triplet section- 15K
if (countB < 1 || countB > 4) countB = 1;
switch (countB)
{
case 1:
quadFactorL = PrevCL - inputSampleL;
quadAL += quadFactorL;
quadDL -= quadFactorL;
quadFactorL = quadAL * quadIntensity;
quadFactorR = PrevCR - inputSampleR;
quadAR += quadFactorR;
quadDR -= quadFactorR;
quadFactorR = quadAR * quadIntensity;
break;
case 2:
quadFactorL = PrevCL - inputSampleL;
quadBL += quadFactorL;
quadAL -= quadFactorL;
quadFactorL = quadBL * quadIntensity;
quadFactorR = PrevCR - inputSampleR;
quadBR += quadFactorR;
quadAR -= quadFactorR;
quadFactorR = quadBR * quadIntensity;
break;
case 3:
quadFactorL = PrevCL - inputSampleL;
quadCL += quadFactorL;
quadBL -= quadFactorL;
quadFactorL = quadCL * quadIntensity;
quadFactorR = PrevCR - inputSampleR;
quadCR += quadFactorR;
quadBR -= quadFactorR;
quadFactorR = quadCR * quadIntensity;
break;
case 4:
quadFactorL = PrevCL - inputSampleL;
quadDL += quadFactorL;
quadCL -= quadFactorL;
quadFactorL = quadDL * quadIntensity;
quadFactorR = PrevCR - inputSampleR;
quadDR += quadFactorR;
quadCR -= quadFactorR;
quadFactorR = quadDR * quadIntensity;
break;
}
quadAL /= 2.0;
quadBL /= 2.0;
quadCL /= 2.0;
quadDL /= 2.0;
correctionL = correctionL + quadFactorL;
quadAR /= 2.0;
quadBR /= 2.0;
quadCR /= 2.0;
quadDR /= 2.0;
correctionR = correctionR + quadFactorR;
countB++;
//finished quad section- 10K
if (countC < 1 || countC > 5) countC = 1;
switch (countC)
{
case 1:
quintFactorL = PrevDL - inputSampleL;
quintAL += quintFactorL;
quintEL -= quintFactorL;
quintFactorL = quintAL * quintIntensity;
quintFactorR = PrevDR - inputSampleR;
quintAR += quintFactorR;
quintER -= quintFactorR;
quintFactorR = quintAR * quintIntensity;
break;
case 2:
quintFactorL = PrevDL - inputSampleL;
quintBL += quintFactorL;
quintAL -= quintFactorL;
quintFactorL = quintBL * quintIntensity;
quintFactorR = PrevDR - inputSampleR;
quintBR += quintFactorR;
quintAR -= quintFactorR;
quintFactorR = quintBR * quintIntensity;
break;
case 3:
quintFactorL = PrevDL - inputSampleL;
quintCL += quintFactorL;
quintBL -= quintFactorL;
quintFactorL = quintCL * quintIntensity;
quintFactorR = PrevDR - inputSampleR;
quintCR += quintFactorR;
quintBR -= quintFactorR;
quintFactorR = quintCR * quintIntensity;
break;
case 4:
quintFactorL = PrevDL - inputSampleL;
quintDL += quintFactorL;
quintCL -= quintFactorL;
quintFactorL = quintDL * quintIntensity;
quintFactorR = PrevDR - inputSampleR;
quintDR += quintFactorR;
quintCR -= quintFactorR;
quintFactorR = quintDR * quintIntensity;
break;
case 5:
quintFactorL = PrevDL - inputSampleL;
quintEL += quintFactorL;
quintDL -= quintFactorL;
quintFactorL = quintEL * quintIntensity;
quintFactorR = PrevDR - inputSampleR;
quintER += quintFactorR;
quintDR -= quintFactorR;
quintFactorR = quintER * quintIntensity;
break;
}
quintAL /= 2.0;
quintBL /= 2.0;
quintCL /= 2.0;
quintDL /= 2.0;
quintEL /= 2.0;
correctionL = correctionL + quintFactorL;
quintAR /= 2.0;
quintBR /= 2.0;
quintCR /= 2.0;
quintDR /= 2.0;
quintER /= 2.0;
correctionR = correctionR + quintFactorR;
countC++;
//finished quint section- 8K
if (countD < 1 || countD > 6) countD = 1;
switch (countD)
{
case 1:
sextFactorL = PrevEL - inputSampleL;
sextAL += sextFactorL;
sextFL -= sextFactorL;
sextFactorL = sextAL * sextIntensity;
sextFactorR = PrevER - inputSampleR;
sextAR += sextFactorR;
sextFR -= sextFactorR;
sextFactorR = sextAR * sextIntensity;
break;
case 2:
sextFactorL = PrevEL - inputSampleL;
sextBL += sextFactorL;
sextAL -= sextFactorL;
sextFactorL = sextBL * sextIntensity;
sextFactorR = PrevER - inputSampleR;
sextBR += sextFactorR;
sextAR -= sextFactorR;
sextFactorR = sextBR * sextIntensity;
break;
case 3:
sextFactorL = PrevEL - inputSampleL;
sextCL += sextFactorL;
sextBL -= sextFactorL;
sextFactorL = sextCL * sextIntensity;
sextFactorR = PrevER - inputSampleR;
sextCR += sextFactorR;
sextBR -= sextFactorR;
sextFactorR = sextCR * sextIntensity;
break;
case 4:
sextFactorL = PrevEL - inputSampleL;
sextDL += sextFactorL;
sextCL -= sextFactorL;
sextFactorL = sextDL * sextIntensity;
sextFactorR = PrevER - inputSampleR;
sextDR += sextFactorR;
sextCR -= sextFactorR;
sextFactorR = sextDR * sextIntensity;
break;
case 5:
sextFactorL = PrevEL - inputSampleL;
sextEL += sextFactorL;
sextDL -= sextFactorL;
sextFactorL = sextEL * sextIntensity;
sextFactorR = PrevER - inputSampleR;
sextER += sextFactorR;
sextDR -= sextFactorR;
sextFactorR = sextER * sextIntensity;
break;
case 6:
sextFactorL = PrevEL - inputSampleL;
sextFL += sextFactorL;
sextEL -= sextFactorL;
sextFactorL = sextFL * sextIntensity;
sextFactorR = PrevER - inputSampleR;
sextFR += sextFactorR;
sextER -= sextFactorR;
sextFactorR = sextFR * sextIntensity;
break;
}
sextAL /= 2.0;
sextBL /= 2.0;
sextCL /= 2.0;
sextDL /= 2.0;
sextEL /= 2.0;
sextFL /= 2.0;
correctionL = correctionL + sextFactorL;
sextAR /= 2.0;
sextBR /= 2.0;
sextCR /= 2.0;
sextDR /= 2.0;
sextER /= 2.0;
sextFR /= 2.0;
correctionR = correctionR + sextFactorR;
countD++;
//finished sext section- 6K
if (countE < 1 || countE > 7) countE = 1;
switch (countE)
{
case 1:
septFactorL = PrevFL - inputSampleL;
septAL += septFactorL;
septGL -= septFactorL;
septFactorL = septAL * septIntensity;
septFactorR = PrevFR - inputSampleR;
septAR += septFactorR;
septGR -= septFactorR;
septFactorR = septAR * septIntensity;
break;
case 2:
septFactorL = PrevFL - inputSampleL;
septBL += septFactorL;
septAL -= septFactorL;
septFactorL = septBL * septIntensity;
septFactorR = PrevFR - inputSampleR;
septBR += septFactorR;
septAR -= septFactorR;
septFactorR = septBR * septIntensity;
break;
case 3:
septFactorL = PrevFL - inputSampleL;
septCL += septFactorL;
septBL -= septFactorL;
septFactorL = septCL * septIntensity;
septFactorR = PrevFR - inputSampleR;
septCR += septFactorR;
septBR -= septFactorR;
septFactorR = septCR * septIntensity;
break;
case 4:
septFactorL = PrevFL - inputSampleL;
septDL += septFactorL;
septCL -= septFactorL;
septFactorL = septDL * septIntensity;
septFactorR = PrevFR - inputSampleR;
septDR += septFactorR;
septCR -= septFactorR;
septFactorR = septDR * septIntensity;
break;
case 5:
septFactorL = PrevFL - inputSampleL;
septEL += septFactorL;
septDL -= septFactorL;
septFactorL = septEL * septIntensity;
septFactorR = PrevFR - inputSampleR;
septER += septFactorR;
septDR -= septFactorR;
septFactorR = septER * septIntensity;
break;
case 6:
septFactorL = PrevFL - inputSampleL;
septFL += septFactorL;
septEL -= septFactorL;
septFactorL = septFL * septIntensity;
septFactorR = PrevFR - inputSampleR;
septFR += septFactorR;
septER -= septFactorR;
septFactorR = septFR * septIntensity;
break;
case 7:
septFactorL = PrevFL - inputSampleL;
septGL += septFactorL;
septFL -= septFactorL;
septFactorL = septGL * septIntensity;
septFactorR = PrevFR - inputSampleR;
septGR += septFactorR;
septFR -= septFactorR;
septFactorR = septGR * septIntensity;
break;
}
septAL /= 2.0;
septBL /= 2.0;
septCL /= 2.0;
septDL /= 2.0;
septEL /= 2.0;
septFL /= 2.0;
septGL /= 2.0;
correctionL = correctionL + septFactorL;
septAR /= 2.0;
septBR /= 2.0;
septCR /= 2.0;
septDR /= 2.0;
septER /= 2.0;
septFR /= 2.0;
septGR /= 2.0;
correctionR = correctionR + septFactorR;
countE++;
//finished sept section- 5K
if (countF < 1 || countF > 8) countF = 1;
switch (countF)
{
case 1:
octFactorL = PrevGL - inputSampleL;
octAL += octFactorL;
octHL -= octFactorL;
octFactorL = octAL * octIntensity;
octFactorR = PrevGR - inputSampleR;
octAR += octFactorR;
octHR -= octFactorR;
octFactorR = octAR * octIntensity;
break;
case 2:
octFactorL = PrevGL - inputSampleL;
octBL += octFactorL;
octAL -= octFactorL;
octFactorL = octBL * octIntensity;
octFactorR = PrevGR - inputSampleR;
octBR += octFactorR;
octAR -= octFactorR;
octFactorR = octBR * octIntensity;
break;
case 3:
octFactorL = PrevGL - inputSampleL;
octCL += octFactorL;
octBL -= octFactorL;
octFactorL = octCL * octIntensity;
octFactorR = PrevGR - inputSampleR;
octCR += octFactorR;
octBR -= octFactorR;
octFactorR = octCR * octIntensity;
break;
case 4:
octFactorL = PrevGL - inputSampleL;
octDL += octFactorL;
octCL -= octFactorL;
octFactorL = octDL * octIntensity;
octFactorR = PrevGR - inputSampleR;
octDR += octFactorR;
octCR -= octFactorR;
octFactorR = octDR * octIntensity;
break;
case 5:
octFactorL = PrevGL - inputSampleL;
octEL += octFactorL;
octDL -= octFactorL;
octFactorL = octEL * octIntensity;
octFactorR = PrevGR - inputSampleR;
octER += octFactorR;
octDR -= octFactorR;
octFactorR = octER * octIntensity;
break;
case 6:
octFactorL = PrevGL - inputSampleL;
octFL += octFactorL;
octEL -= octFactorL;
octFactorL = octFL * octIntensity;
octFactorR = PrevGR - inputSampleR;
octFR += octFactorR;
octER -= octFactorR;
octFactorR = octFR * octIntensity;
break;
case 7:
octFactorL = PrevGL - inputSampleL;
octGL += octFactorL;
octFL -= octFactorL;
octFactorL = octGL * octIntensity;
octFactorR = PrevGR - inputSampleR;
octGR += octFactorR;
octFR -= octFactorR;
octFactorR = octGR * octIntensity;
break;
case 8:
octFactorL = PrevGL - inputSampleL;
octHL += octFactorL;
octGL -= octFactorL;
octFactorL = octHL * octIntensity;
octFactorR = PrevGR - inputSampleR;
octHR += octFactorR;
octGR -= octFactorR;
octFactorR = octHR * octIntensity;
break;
}
octAL /= 2.0;
octBL /= 2.0;
octCL /= 2.0;
octDL /= 2.0;
octEL /= 2.0;
octFL /= 2.0;
octGL /= 2.0;
octHL /= 2.0;
correctionL = correctionL + octFactorL;
octAR /= 2.0;
octBR /= 2.0;
octCR /= 2.0;
octDR /= 2.0;
octER /= 2.0;
octFR /= 2.0;
octGR /= 2.0;
octHR /= 2.0;
correctionR = correctionR + octFactorR;
countF++;
//finished oct section- 4K
if (countG < 1 || countG > 9) countG = 1;
switch (countG)
{
case 1:
nintFactorL = PrevHL - inputSampleL;
nintAL += nintFactorL;
nintIL -= nintFactorL;
nintFactorL = nintAL * nintIntensity;
nintFactorR = PrevHR - inputSampleR;
nintAR += nintFactorR;
nintIR -= nintFactorR;
nintFactorR = nintAR * nintIntensity;
break;
case 2:
nintFactorL = PrevHL - inputSampleL;
nintBL += nintFactorL;
nintAL -= nintFactorL;
nintFactorL = nintBL * nintIntensity;
nintFactorR = PrevHR - inputSampleR;
nintBR += nintFactorR;
nintAR -= nintFactorR;
nintFactorR = nintBR * nintIntensity;
break;
case 3:
nintFactorL = PrevHL - inputSampleL;
nintCL += nintFactorL;
nintBL -= nintFactorL;
nintFactorL = nintCL * nintIntensity;
nintFactorR = PrevHR - inputSampleR;
nintCR += nintFactorR;
nintBR -= nintFactorR;
nintFactorR = nintCR * nintIntensity;
break;
case 4:
nintFactorL = PrevHL - inputSampleL;
nintDL += nintFactorL;
nintCL -= nintFactorL;
nintFactorL = nintDL * nintIntensity;
nintFactorR = PrevHR - inputSampleR;
nintDR += nintFactorR;
nintCR -= nintFactorR;
nintFactorR = nintDR * nintIntensity;
break;
case 5:
nintFactorL = PrevHL - inputSampleL;
nintEL += nintFactorL;
nintDL -= nintFactorL;
nintFactorL = nintEL * nintIntensity;
nintFactorR = PrevHR - inputSampleR;
nintER += nintFactorR;
nintDR -= nintFactorR;
nintFactorR = nintER * nintIntensity;
break;
case 6:
nintFactorL = PrevHL - inputSampleL;
nintFL += nintFactorL;
nintEL -= nintFactorL;
nintFactorL = nintFL * nintIntensity;
nintFactorR = PrevHR - inputSampleR;
nintFR += nintFactorR;
nintER -= nintFactorR;
nintFactorR = nintFR * nintIntensity;
break;
case 7:
nintFactorL = PrevHL - inputSampleL;
nintGL += nintFactorL;
nintFL -= nintFactorL;
nintFactorL = nintGL * nintIntensity;
nintFactorR = PrevHR - inputSampleR;
nintGR += nintFactorR;
nintFR -= nintFactorR;
nintFactorR = nintGR * nintIntensity;
break;
case 8:
nintFactorL = PrevHL - inputSampleL;
nintHL += nintFactorL;
nintGL -= nintFactorL;
nintFactorL = nintHL * nintIntensity;
nintFactorR = PrevHR - inputSampleR;
nintHR += nintFactorR;
nintGR -= nintFactorR;
nintFactorR = nintHR * nintIntensity;
break;
case 9:
nintFactorL = PrevHL - inputSampleL;
nintIL += nintFactorL;
nintHL -= nintFactorL;
nintFactorL = nintIL * nintIntensity;
nintFactorR = PrevHR - inputSampleR;
nintIR += nintFactorR;
nintHR -= nintFactorR;
nintFactorR = nintIR * nintIntensity;
break;
}
nintAL /= 2.0;
nintBL /= 2.0;
nintCL /= 2.0;
nintDL /= 2.0;
nintEL /= 2.0;
nintFL /= 2.0;
nintGL /= 2.0;
nintHL /= 2.0;
nintIL /= 2.0;
correctionL = correctionL + nintFactorL;
nintAR /= 2.0;
nintBR /= 2.0;
nintCR /= 2.0;
nintDR /= 2.0;
nintER /= 2.0;
nintFR /= 2.0;
nintGR /= 2.0;
nintHR /= 2.0;
nintIR /= 2.0;
correctionR = correctionR + nintFactorR;
countG++;
//finished nint section- 3K
PrevHL = PrevGL;
PrevGL = PrevFL;
PrevFL = PrevEL;
PrevEL = PrevDL;
PrevDL = PrevCL;
PrevCL = PrevBL;
PrevBL = PrevAL;
PrevAL = inputSampleL;
PrevHR = PrevGR;
PrevGR = PrevFR;
PrevFR = PrevER;
PrevER = PrevDR;
PrevDR = PrevCR;
PrevCR = PrevBR;
PrevBR = PrevAR;
PrevAR = inputSampleR;
inputSampleL += (correctionL * mix);
inputSampleR += (correctionR * mix);
//we don't need a drySample because we never touched inputSample
//so, this provides the inv/dry/wet control all by itself
//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 Energy::processDoubleReplacing(double **inputs, double **outputs, VstInt32 sampleFrames)
{
double* in1 = inputs[0];
double* in2 = inputs[1];
double* out1 = outputs[0];
double* out2 = outputs[1];
double duoIntensity = -pow((A*2.0)-1.0,3);
double tripletIntensity = -pow((B*2.0)-1.0,3);
double quadIntensity = -pow((C*2.0)-1.0,3);
double quintIntensity = -pow((D*2.0)-1.0,3);
double sextIntensity = -pow((E*2.0)-1.0,3);
double septIntensity = -pow((F*2.0)-1.0,3);
double octIntensity = -pow((G*2.0)-1.0,3);
double nintIntensity = -pow((H*2.0)-1.0,3);
double mix = (I*2.0)-1.0;
//all types of air band are running in parallel, not series
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
long double correctionL = 0.0;
long double correctionR = 0.0;
duoFactorL = PrevAL - inputSampleL;
duoFactorR = PrevAR - inputSampleR;
if (flip)
{
duoEvenL += duoFactorL;
duoOddL -= duoFactorL;
duoFactorL = duoEvenL * duoIntensity;
duoEvenR += duoFactorR;
duoOddR -= duoFactorR;
duoFactorR = duoEvenR * duoIntensity;
}
else
{
duoOddL += duoFactorL;
duoEvenL -= duoFactorL;
duoFactorL = duoOddL * duoIntensity;
duoOddR += duoFactorR;
duoEvenR -= duoFactorR;
duoFactorR = duoOddR * duoIntensity;
}
duoOddL = (duoOddL - ((duoOddL - duoEvenL)/256.0)) / 2.0;
duoEvenL = (duoEvenL - ((duoEvenL - duoOddL)/256.0)) / 2.0;
correctionL = correctionL + duoFactorL;
duoOddR = (duoOddR - ((duoOddR - duoEvenR)/256.0)) / 2.0;
duoEvenR = (duoEvenR - ((duoEvenR - duoOddR)/256.0)) / 2.0;
correctionR = correctionR + duoFactorR;
flip = !flip;
//finished duo section
if (countA < 1 || countA > 3) countA = 1;
switch (countA)
{
case 1:
tripletFactorL = PrevBL - inputSampleL;
tripletAL += tripletFactorL;
tripletCL -= tripletFactorL;
tripletFactorL = tripletAL * tripletIntensity;
tripletFactorR = PrevBR - inputSampleR;
tripletAR += tripletFactorR;
tripletCR -= tripletFactorR;
tripletFactorR = tripletAR * tripletIntensity;
break;
case 2:
tripletFactorL = PrevBL - inputSampleL;
tripletBL += tripletFactorL;
tripletAL -= tripletFactorL;
tripletFactorL = tripletBL * tripletIntensity;
tripletFactorR = PrevBR - inputSampleR;
tripletBR += tripletFactorR;
tripletAR -= tripletFactorR;
tripletFactorR = tripletBR * tripletIntensity;
break;
case 3:
tripletFactorL = PrevBL - inputSampleL;
tripletCL += tripletFactorL;
tripletBL -= tripletFactorL;
tripletFactorL = tripletCL * tripletIntensity;
tripletFactorR = PrevBR - inputSampleR;
tripletCR += tripletFactorR;
tripletBR -= tripletFactorR;
tripletFactorR = tripletCR * tripletIntensity;
break;
}
tripletAL /= 2.0;
tripletBL /= 2.0;
tripletCL /= 2.0;
correctionL = correctionL + tripletFactorL;
tripletAR /= 2.0;
tripletBR /= 2.0;
tripletCR /= 2.0;
correctionR = correctionR + tripletFactorR;
countA++;
//finished triplet section- 15K
if (countB < 1 || countB > 4) countB = 1;
switch (countB)
{
case 1:
quadFactorL = PrevCL - inputSampleL;
quadAL += quadFactorL;
quadDL -= quadFactorL;
quadFactorL = quadAL * quadIntensity;
quadFactorR = PrevCR - inputSampleR;
quadAR += quadFactorR;
quadDR -= quadFactorR;
quadFactorR = quadAR * quadIntensity;
break;
case 2:
quadFactorL = PrevCL - inputSampleL;
quadBL += quadFactorL;
quadAL -= quadFactorL;
quadFactorL = quadBL * quadIntensity;
quadFactorR = PrevCR - inputSampleR;
quadBR += quadFactorR;
quadAR -= quadFactorR;
quadFactorR = quadBR * quadIntensity;
break;
case 3:
quadFactorL = PrevCL - inputSampleL;
quadCL += quadFactorL;
quadBL -= quadFactorL;
quadFactorL = quadCL * quadIntensity;
quadFactorR = PrevCR - inputSampleR;
quadCR += quadFactorR;
quadBR -= quadFactorR;
quadFactorR = quadCR * quadIntensity;
break;
case 4:
quadFactorL = PrevCL - inputSampleL;
quadDL += quadFactorL;
quadCL -= quadFactorL;
quadFactorL = quadDL * quadIntensity;
quadFactorR = PrevCR - inputSampleR;
quadDR += quadFactorR;
quadCR -= quadFactorR;
quadFactorR = quadDR * quadIntensity;
break;
}
quadAL /= 2.0;
quadBL /= 2.0;
quadCL /= 2.0;
quadDL /= 2.0;
correctionL = correctionL + quadFactorL;
quadAR /= 2.0;
quadBR /= 2.0;
quadCR /= 2.0;
quadDR /= 2.0;
correctionR = correctionR + quadFactorR;
countB++;
//finished quad section- 10K
if (countC < 1 || countC > 5) countC = 1;
switch (countC)
{
case 1:
quintFactorL = PrevDL - inputSampleL;
quintAL += quintFactorL;
quintEL -= quintFactorL;
quintFactorL = quintAL * quintIntensity;
quintFactorR = PrevDR - inputSampleR;
quintAR += quintFactorR;
quintER -= quintFactorR;
quintFactorR = quintAR * quintIntensity;
break;
case 2:
quintFactorL = PrevDL - inputSampleL;
quintBL += quintFactorL;
quintAL -= quintFactorL;
quintFactorL = quintBL * quintIntensity;
quintFactorR = PrevDR - inputSampleR;
quintBR += quintFactorR;
quintAR -= quintFactorR;
quintFactorR = quintBR * quintIntensity;
break;
case 3:
quintFactorL = PrevDL - inputSampleL;
quintCL += quintFactorL;
quintBL -= quintFactorL;
quintFactorL = quintCL * quintIntensity;
quintFactorR = PrevDR - inputSampleR;
quintCR += quintFactorR;
quintBR -= quintFactorR;
quintFactorR = quintCR * quintIntensity;
break;
case 4:
quintFactorL = PrevDL - inputSampleL;
quintDL += quintFactorL;
quintCL -= quintFactorL;
quintFactorL = quintDL * quintIntensity;
quintFactorR = PrevDR - inputSampleR;
quintDR += quintFactorR;
quintCR -= quintFactorR;
quintFactorR = quintDR * quintIntensity;
break;
case 5:
quintFactorL = PrevDL - inputSampleL;
quintEL += quintFactorL;
quintDL -= quintFactorL;
quintFactorL = quintEL * quintIntensity;
quintFactorR = PrevDR - inputSampleR;
quintER += quintFactorR;
quintDR -= quintFactorR;
quintFactorR = quintER * quintIntensity;
break;
}
quintAL /= 2.0;
quintBL /= 2.0;
quintCL /= 2.0;
quintDL /= 2.0;
quintEL /= 2.0;
correctionL = correctionL + quintFactorL;
quintAR /= 2.0;
quintBR /= 2.0;
quintCR /= 2.0;
quintDR /= 2.0;
quintER /= 2.0;
correctionR = correctionR + quintFactorR;
countC++;
//finished quint section- 8K
if (countD < 1 || countD > 6) countD = 1;
switch (countD)
{
case 1:
sextFactorL = PrevEL - inputSampleL;
sextAL += sextFactorL;
sextFL -= sextFactorL;
sextFactorL = sextAL * sextIntensity;
sextFactorR = PrevER - inputSampleR;
sextAR += sextFactorR;
sextFR -= sextFactorR;
sextFactorR = sextAR * sextIntensity;
break;
case 2:
sextFactorL = PrevEL - inputSampleL;
sextBL += sextFactorL;
sextAL -= sextFactorL;
sextFactorL = sextBL * sextIntensity;
sextFactorR = PrevER - inputSampleR;
sextBR += sextFactorR;
sextAR -= sextFactorR;
sextFactorR = sextBR * sextIntensity;
break;
case 3:
sextFactorL = PrevEL - inputSampleL;
sextCL += sextFactorL;
sextBL -= sextFactorL;
sextFactorL = sextCL * sextIntensity;
sextFactorR = PrevER - inputSampleR;
sextCR += sextFactorR;
sextBR -= sextFactorR;
sextFactorR = sextCR * sextIntensity;
break;
case 4:
sextFactorL = PrevEL - inputSampleL;
sextDL += sextFactorL;
sextCL -= sextFactorL;
sextFactorL = sextDL * sextIntensity;
sextFactorR = PrevER - inputSampleR;
sextDR += sextFactorR;
sextCR -= sextFactorR;
sextFactorR = sextDR * sextIntensity;
break;
case 5:
sextFactorL = PrevEL - inputSampleL;
sextEL += sextFactorL;
sextDL -= sextFactorL;
sextFactorL = sextEL * sextIntensity;
sextFactorR = PrevER - inputSampleR;
sextER += sextFactorR;
sextDR -= sextFactorR;
sextFactorR = sextER * sextIntensity;
break;
case 6:
sextFactorL = PrevEL - inputSampleL;
sextFL += sextFactorL;
sextEL -= sextFactorL;
sextFactorL = sextFL * sextIntensity;
sextFactorR = PrevER - inputSampleR;
sextFR += sextFactorR;
sextER -= sextFactorR;
sextFactorR = sextFR * sextIntensity;
break;
}
sextAL /= 2.0;
sextBL /= 2.0;
sextCL /= 2.0;
sextDL /= 2.0;
sextEL /= 2.0;
sextFL /= 2.0;
correctionL = correctionL + sextFactorL;
sextAR /= 2.0;
sextBR /= 2.0;
sextCR /= 2.0;
sextDR /= 2.0;
sextER /= 2.0;
sextFR /= 2.0;
correctionR = correctionR + sextFactorR;
countD++;
//finished sext section- 6K
if (countE < 1 || countE > 7) countE = 1;
switch (countE)
{
case 1:
septFactorL = PrevFL - inputSampleL;
septAL += septFactorL;
septGL -= septFactorL;
septFactorL = septAL * septIntensity;
septFactorR = PrevFR - inputSampleR;
septAR += septFactorR;
septGR -= septFactorR;
septFactorR = septAR * septIntensity;
break;
case 2:
septFactorL = PrevFL - inputSampleL;
septBL += septFactorL;
septAL -= septFactorL;
septFactorL = septBL * septIntensity;
septFactorR = PrevFR - inputSampleR;
septBR += septFactorR;
septAR -= septFactorR;
septFactorR = septBR * septIntensity;
break;
case 3:
septFactorL = PrevFL - inputSampleL;
septCL += septFactorL;
septBL -= septFactorL;
septFactorL = septCL * septIntensity;
septFactorR = PrevFR - inputSampleR;
septCR += septFactorR;
septBR -= septFactorR;
septFactorR = septCR * septIntensity;
break;
case 4:
septFactorL = PrevFL - inputSampleL;
septDL += septFactorL;
septCL -= septFactorL;
septFactorL = septDL * septIntensity;
septFactorR = PrevFR - inputSampleR;
septDR += septFactorR;
septCR -= septFactorR;
septFactorR = septDR * septIntensity;
break;
case 5:
septFactorL = PrevFL - inputSampleL;
septEL += septFactorL;
septDL -= septFactorL;
septFactorL = septEL * septIntensity;
septFactorR = PrevFR - inputSampleR;
septER += septFactorR;
septDR -= septFactorR;
septFactorR = septER * septIntensity;
break;
case 6:
septFactorL = PrevFL - inputSampleL;
septFL += septFactorL;
septEL -= septFactorL;
septFactorL = septFL * septIntensity;
septFactorR = PrevFR - inputSampleR;
septFR += septFactorR;
septER -= septFactorR;
septFactorR = septFR * septIntensity;
break;
case 7:
septFactorL = PrevFL - inputSampleL;
septGL += septFactorL;
septFL -= septFactorL;
septFactorL = septGL * septIntensity;
septFactorR = PrevFR - inputSampleR;
septGR += septFactorR;
septFR -= septFactorR;
septFactorR = septGR * septIntensity;
break;
}
septAL /= 2.0;
septBL /= 2.0;
septCL /= 2.0;
septDL /= 2.0;
septEL /= 2.0;
septFL /= 2.0;
septGL /= 2.0;
correctionL = correctionL + septFactorL;
septAR /= 2.0;
septBR /= 2.0;
septCR /= 2.0;
septDR /= 2.0;
septER /= 2.0;
septFR /= 2.0;
septGR /= 2.0;
correctionR = correctionR + septFactorR;
countE++;
//finished sept section- 5K
if (countF < 1 || countF > 8) countF = 1;
switch (countF)
{
case 1:
octFactorL = PrevGL - inputSampleL;
octAL += octFactorL;
octHL -= octFactorL;
octFactorL = octAL * octIntensity;
octFactorR = PrevGR - inputSampleR;
octAR += octFactorR;
octHR -= octFactorR;
octFactorR = octAR * octIntensity;
break;
case 2:
octFactorL = PrevGL - inputSampleL;
octBL += octFactorL;
octAL -= octFactorL;
octFactorL = octBL * octIntensity;
octFactorR = PrevGR - inputSampleR;
octBR += octFactorR;
octAR -= octFactorR;
octFactorR = octBR * octIntensity;
break;
case 3:
octFactorL = PrevGL - inputSampleL;
octCL += octFactorL;
octBL -= octFactorL;
octFactorL = octCL * octIntensity;
octFactorR = PrevGR - inputSampleR;
octCR += octFactorR;
octBR -= octFactorR;
octFactorR = octCR * octIntensity;
break;
case 4:
octFactorL = PrevGL - inputSampleL;
octDL += octFactorL;
octCL -= octFactorL;
octFactorL = octDL * octIntensity;
octFactorR = PrevGR - inputSampleR;
octDR += octFactorR;
octCR -= octFactorR;
octFactorR = octDR * octIntensity;
break;
case 5:
octFactorL = PrevGL - inputSampleL;
octEL += octFactorL;
octDL -= octFactorL;
octFactorL = octEL * octIntensity;
octFactorR = PrevGR - inputSampleR;
octER += octFactorR;
octDR -= octFactorR;
octFactorR = octER * octIntensity;
break;
case 6:
octFactorL = PrevGL - inputSampleL;
octFL += octFactorL;
octEL -= octFactorL;
octFactorL = octFL * octIntensity;
octFactorR = PrevGR - inputSampleR;
octFR += octFactorR;
octER -= octFactorR;
octFactorR = octFR * octIntensity;
break;
case 7:
octFactorL = PrevGL - inputSampleL;
octGL += octFactorL;
octFL -= octFactorL;
octFactorL = octGL * octIntensity;
octFactorR = PrevGR - inputSampleR;
octGR += octFactorR;
octFR -= octFactorR;
octFactorR = octGR * octIntensity;
break;
case 8:
octFactorL = PrevGL - inputSampleL;
octHL += octFactorL;
octGL -= octFactorL;
octFactorL = octHL * octIntensity;
octFactorR = PrevGR - inputSampleR;
octHR += octFactorR;
octGR -= octFactorR;
octFactorR = octHR * octIntensity;
break;
}
octAL /= 2.0;
octBL /= 2.0;
octCL /= 2.0;
octDL /= 2.0;
octEL /= 2.0;
octFL /= 2.0;
octGL /= 2.0;
octHL /= 2.0;
correctionL = correctionL + octFactorL;
octAR /= 2.0;
octBR /= 2.0;
octCR /= 2.0;
octDR /= 2.0;
octER /= 2.0;
octFR /= 2.0;
octGR /= 2.0;
octHR /= 2.0;
correctionR = correctionR + octFactorR;
countF++;
//finished oct section- 4K
if (countG < 1 || countG > 9) countG = 1;
switch (countG)
{
case 1:
nintFactorL = PrevHL - inputSampleL;
nintAL += nintFactorL;
nintIL -= nintFactorL;
nintFactorL = nintAL * nintIntensity;
nintFactorR = PrevHR - inputSampleR;
nintAR += nintFactorR;
nintIR -= nintFactorR;
nintFactorR = nintAR * nintIntensity;
break;
case 2:
nintFactorL = PrevHL - inputSampleL;
nintBL += nintFactorL;
nintAL -= nintFactorL;
nintFactorL = nintBL * nintIntensity;
nintFactorR = PrevHR - inputSampleR;
nintBR += nintFactorR;
nintAR -= nintFactorR;
nintFactorR = nintBR * nintIntensity;
break;
case 3:
nintFactorL = PrevHL - inputSampleL;
nintCL += nintFactorL;
nintBL -= nintFactorL;
nintFactorL = nintCL * nintIntensity;
nintFactorR = PrevHR - inputSampleR;
nintCR += nintFactorR;
nintBR -= nintFactorR;
nintFactorR = nintCR * nintIntensity;
break;
case 4:
nintFactorL = PrevHL - inputSampleL;
nintDL += nintFactorL;
nintCL -= nintFactorL;
nintFactorL = nintDL * nintIntensity;
nintFactorR = PrevHR - inputSampleR;
nintDR += nintFactorR;
nintCR -= nintFactorR;
nintFactorR = nintDR * nintIntensity;
break;
case 5:
nintFactorL = PrevHL - inputSampleL;
nintEL += nintFactorL;
nintDL -= nintFactorL;
nintFactorL = nintEL * nintIntensity;
nintFactorR = PrevHR - inputSampleR;
nintER += nintFactorR;
nintDR -= nintFactorR;
nintFactorR = nintER * nintIntensity;
break;
case 6:
nintFactorL = PrevHL - inputSampleL;
nintFL += nintFactorL;
nintEL -= nintFactorL;
nintFactorL = nintFL * nintIntensity;
nintFactorR = PrevHR - inputSampleR;
nintFR += nintFactorR;
nintER -= nintFactorR;
nintFactorR = nintFR * nintIntensity;
break;
case 7:
nintFactorL = PrevHL - inputSampleL;
nintGL += nintFactorL;
nintFL -= nintFactorL;
nintFactorL = nintGL * nintIntensity;
nintFactorR = PrevHR - inputSampleR;
nintGR += nintFactorR;
nintFR -= nintFactorR;
nintFactorR = nintGR * nintIntensity;
break;
case 8:
nintFactorL = PrevHL - inputSampleL;
nintHL += nintFactorL;
nintGL -= nintFactorL;
nintFactorL = nintHL * nintIntensity;
nintFactorR = PrevHR - inputSampleR;
nintHR += nintFactorR;
nintGR -= nintFactorR;
nintFactorR = nintHR * nintIntensity;
break;
case 9:
nintFactorL = PrevHL - inputSampleL;
nintIL += nintFactorL;
nintHL -= nintFactorL;
nintFactorL = nintIL * nintIntensity;
nintFactorR = PrevHR - inputSampleR;
nintIR += nintFactorR;
nintHR -= nintFactorR;
nintFactorR = nintIR * nintIntensity;
break;
}
nintAL /= 2.0;
nintBL /= 2.0;
nintCL /= 2.0;
nintDL /= 2.0;
nintEL /= 2.0;
nintFL /= 2.0;
nintGL /= 2.0;
nintHL /= 2.0;
nintIL /= 2.0;
correctionL = correctionL + nintFactorL;
nintAR /= 2.0;
nintBR /= 2.0;
nintCR /= 2.0;
nintDR /= 2.0;
nintER /= 2.0;
nintFR /= 2.0;
nintGR /= 2.0;
nintHR /= 2.0;
nintIR /= 2.0;
correctionR = correctionR + nintFactorR;
countG++;
//finished nint section- 3K
PrevHL = PrevGL;
PrevGL = PrevFL;
PrevFL = PrevEL;
PrevEL = PrevDL;
PrevDL = PrevCL;
PrevCL = PrevBL;
PrevBL = PrevAL;
PrevAL = inputSampleL;
PrevHR = PrevGR;
PrevGR = PrevFR;
PrevFR = PrevER;
PrevER = PrevDR;
PrevDR = PrevCR;
PrevCR = PrevBR;
PrevBR = PrevAR;
PrevAR = inputSampleR;
inputSampleL += (correctionL * mix);
inputSampleR += (correctionR * mix);
//we don't need a drySample because we never touched inputSample
//so, this provides the inv/dry/wet control all by itself
//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++;
}
}