airwindows-nc-17.jsfx

desc:Airwindows NC-17 (Mark Heath)

// https://github.com/airwindows/airwindows/blob/master/plugins/WinVST/NC-17/NCSeventeenProc.cpp
// original code Copyright (c) 2016 airwindows, All rights reserved
// license: MIT
// version history:
// 0.1 29 Apr 2022 - initial port from GitHub commit 558b93e
// 0.2 6 May 2022 - improved bit shifting for random number

//tags: loudness
//author: Mark Heath

// https://www.airwindows.com/nc-17/

// default<min, max, increment>
slider1:0<0,1,0.01>LOUDER
slider2:1<0,1,0.01>Output

in_pin:left input
in_pin:right input
out_pin:left output
out_pin:right output

@init
A = 0.0;
B = 1.0;

lastSampleL = 0.0;
iirSampleAL = 0.0;
iirSampleBL = 0.0;
basslevL = 0.0;
treblevL = 0.0;
cheblevL = 0.0;

lastSampleR = 0.0;
iirSampleAR = 0.0;
iirSampleBR = 0.0;
basslevR = 0.0;
treblevR = 0.0;
cheblevR = 0.0;

flip = 0;


overallscale = 1.0;
overallscale /= 44100.0;
overallscale *= srate;

const1 = 1.18*10^-23; // 1.18e-23;
const2 = 1.18*10^-17; // 1.18e-17
M_PI = 3.1415926535897932384626433;
UINT32_MAX = 4294967295;

// fpdL and fpdR are uint32_t
fpdL = 1.0; while (fpdL = rand()*UINT32_MAX; fpdL < 16386; );
fpdR = 1.0; while (fpdR = rand()*UINT32_MAX; fpdR < 16386; );
fpdL |= 0;
fpdR |= 0;
//this is reset: values being initialized only once. Startup values, whatever they are.

@slider
A = slider1;
B = slider2;

// argument list

@block
inP2 = 0;
chebyshev = 0;
  
IIRscaleback = 0.0004716;
bassScaleback = 0.0002364;
trebleScaleback = 0.0005484;
addBassBuss = 0.000243;
addTrebBuss = 0.000407;
addShortBuss = 0.000326;
IIRscaleback /= overallscale;
bassScaleback /= overallscale;
trebleScaleback /= overallscale;
addBassBuss /= overallscale;
addTrebBuss /= overallscale;
addShortBuss /= overallscale;
limitingBass = 0.39;
limitingTreb = 0.6;
limiting = 0.36;
maxfeedBass = 0.972;
maxfeedTreb = 0.972;
maxfeed = 0.975;
bridgerectifier = 0;
inputSampleL = 0;
lowSampleL = 0.0;
highSampleL = 0;
distSampleL = 0;
minusSampleL = 0;
plusSampleL = 0;
inputSampleR =0;
lowSampleR = 0.0;
highSampleR = 0;
distSampleR =0;
minusSampleR =0;
plusSampleR = 0;
gain = pow(10.0,(A*24.0)/20);
outlevel = B;

@sample

inputSampleL = spl0;
inputSampleR = spl1;
(abs(inputSampleL)<const1) ? inputSampleL = fpdL * const2;
(abs(inputSampleR)<const1) ? inputSampleR = fpdR * const2;
    inputSampleL *= gain;
    inputSampleR *= gain;
    
    (flip) ? (
    
      iirSampleAL = (iirSampleAL * 0.9) + (inputSampleL * 0.1);
      lowSampleL = iirSampleAL;
      iirSampleAR = (iirSampleAR * 0.9) + (inputSampleR * 0.1);
      lowSampleR = iirSampleAR;
    ) : (
      iirSampleBL = (iirSampleBL * 0.9) + (inputSampleL * 0.1);
      lowSampleL = iirSampleBL;
      iirSampleBR = (iirSampleBR * 0.9) + (inputSampleR * 0.1);
      lowSampleR = iirSampleBR;
    );
    highSampleL = inputSampleL - lowSampleL;
    highSampleR = inputSampleR - lowSampleR;
    flip = !flip;
    //we now have two bands and the original source
    
    inP2 = lowSampleL * lowSampleL;
    (inP2 > 1.0) ? inP2 = 1.0; (inP2 < -1.0) ? inP2 = -1.0;
    chebyshev = (2 * inP2);
    chebyshev *= basslevL;
    //second harmonic max +1
    (basslevL > 0) ? basslevL -= bassScaleback;
    (basslevL < 0) ? basslevL += bassScaleback;
    //this is ShortBuss, IIRscaleback is the decay speed. *2 for second harmonic, and so on
    bridgerectifier = abs(lowSampleL);
    (bridgerectifier > 1.57079633) ? bridgerectifier = 1.57079633;
    //max value for sine function
    bridgerectifier = sin(bridgerectifier);
    (lowSampleL > 0.0) ? distSampleL = bridgerectifier
      : distSampleL = -bridgerectifier;
    minusSampleL = lowSampleL - distSampleL;
    plusSampleL = lowSampleL + distSampleL;
    (minusSampleL > maxfeedBass) ? minusSampleL = maxfeedBass;
    (plusSampleL > maxfeedBass) ? plusSampleL = maxfeedBass;
    (plusSampleL < -maxfeedBass) ? plusSampleL = -maxfeedBass;
    (minusSampleL < -maxfeedBass) ? minusSampleL = -maxfeedBass;
    (lowSampleL > distSampleL) ? basslevL += (minusSampleL*addBassBuss);
    (lowSampleL < -distSampleL) ? basslevL -= (plusSampleL*addBassBuss);
    (basslevL > 1.0) ? basslevL = 1.0;
    (basslevL < -1.0) ? basslevL = -1.0;
    bridgerectifier = abs(lowSampleL);
    (bridgerectifier > 1.57079633) ? bridgerectifier = 1.57079633;
    //max value for sine function
    bridgerectifier = sin(bridgerectifier);
    (lowSampleL > 0.0) ? lowSampleL = bridgerectifier 
      : lowSampleL = -bridgerectifier;
    //apply the distortion transform for reals
    lowSampleL /= (1.0+abs(basslevL*limitingBass));
    lowSampleL += chebyshev;
    //apply the correction measuresL
    
    inP2 = lowSampleR * lowSampleR;
    (inP2 > 1.0) ? inP2 = 1.0; (inP2 < -1.0) ? inP2 = -1.0;
    chebyshev = (2 * inP2);
    chebyshev *= basslevR;
    //second harmonic max +1
    (basslevR > 0) ? basslevR -= bassScaleback;
    (basslevR < 0) ? basslevR += bassScaleback;
    //this is ShortBuss, IIRscaleback is the decay speed. *2 for second harmonic, and so on
    bridgerectifier = abs(lowSampleR);
    (bridgerectifier > 1.57079633) ? bridgerectifier = 1.57079633;
    //max value for sine function
    bridgerectifier = sin(bridgerectifier);
    (lowSampleR > 0.0) ? distSampleR = bridgerectifier
      : distSampleR = -bridgerectifier;
    minusSampleR = lowSampleR - distSampleR;
    plusSampleR = lowSampleR + distSampleR;
    (minusSampleR > maxfeedBass) ? minusSampleR = maxfeedBass;
    (plusSampleR > maxfeedBass) ? plusSampleR = maxfeedBass;
    (plusSampleR < -maxfeedBass) ? plusSampleR = -maxfeedBass;
    (minusSampleR < -maxfeedBass) ? minusSampleR = -maxfeedBass;
    (lowSampleR > distSampleR) ? basslevR += (minusSampleR*addBassBuss);
    (lowSampleR < -distSampleR) ? basslevR -= (plusSampleR*addBassBuss);
    (basslevR > 1.0) ? basslevR = 1.0;
    (basslevR < -1.0) ? basslevR = -1.0;
    bridgerectifier = abs(lowSampleR);
    (bridgerectifier > 1.57079633) ? bridgerectifier = 1.57079633;
    //max value for sine function
    bridgerectifier = sin(bridgerectifier);
    (lowSampleR > 0.0) ? lowSampleR = bridgerectifier
      : lowSampleR = -bridgerectifier;
    //apply the distortion transform for reals
    lowSampleR /= (1.0+abs(basslevR*limitingBass));
    lowSampleR += chebyshev;
    //apply the correction measuresR
    
    inP2 = highSampleL * highSampleL;
    (inP2 > 1.0) ? inP2 = 1.0; (inP2 < -1.0) ? inP2 = -1.0;
    chebyshev = (2 * inP2);
    chebyshev *= treblevL;
    //second harmonic max +1
    (treblevL > 0) ? treblevL -= trebleScaleback;
    (treblevL < 0) ? treblevL += trebleScaleback;
    //this is ShortBuss, IIRscaleback is the decay speed. *2 for second harmonic, and so on
    bridgerectifier = abs(highSampleL);
    (bridgerectifier > 1.57079633) ? bridgerectifier = 1.57079633;
    //max value for sine function
    bridgerectifier = sin(bridgerectifier);
    (highSampleL > 0.0) ? distSampleL = bridgerectifier
      : distSampleL = -bridgerectifier;
    minusSampleL = highSampleL - distSampleL;
    plusSampleL = highSampleL + distSampleL;
    (minusSampleL > maxfeedTreb) ? minusSampleL = maxfeedTreb;
    (plusSampleL > maxfeedTreb) ? plusSampleL = maxfeedTreb;
    (plusSampleL < -maxfeedTreb) ? plusSampleL = -maxfeedTreb;
    (minusSampleL < -maxfeedTreb) ? minusSampleL = -maxfeedTreb;
    (highSampleL > distSampleL) ? treblevL += (minusSampleL*addTrebBuss);
    (highSampleL < -distSampleL) ? treblevL -= (plusSampleL*addTrebBuss);
    (treblevL > 1.0) ? treblevL = 1.0;
    (treblevL < -1.0) ? treblevL = -1.0;
    bridgerectifier = abs(highSampleL);
    (bridgerectifier > 1.57079633) ? bridgerectifier = 1.57079633;
    //max value for sine function
    bridgerectifier = sin(bridgerectifier);
    (highSampleL > 0.0) ? highSampleL = bridgerectifier
     : highSampleL = -bridgerectifier;
    //apply the distortion transform for reals
    highSampleL /= (1.0+abs(treblevL*limitingTreb));
    highSampleL += chebyshev;
    //apply the correction measuresL
    
    inP2 = highSampleR * highSampleR;
    (inP2 > 1.0) ? inP2 = 1.0; (inP2 < -1.0) ? inP2 = -1.0;
    chebyshev = (2 * inP2);
    chebyshev *= treblevR;
    //second harmonic max +1
    (treblevR > 0) ? treblevR -= trebleScaleback;
    (treblevR < 0) ? treblevR += trebleScaleback;
    //this is ShortBuss, IIRscaleback is the decay speed. *2 for second harmonic, and so on
    bridgerectifier = abs(highSampleR);
    (bridgerectifier > 1.57079633) ? bridgerectifier = 1.57079633;
    //max value for sine function
    bridgerectifier = sin(bridgerectifier);
    (highSampleR > 0.0) ? distSampleR = bridgerectifier
      : distSampleR = -bridgerectifier;
    minusSampleR = highSampleR - distSampleR;
    plusSampleR = highSampleR + distSampleR;
    (minusSampleR > maxfeedTreb) ? minusSampleR = maxfeedTreb;
    (plusSampleR > maxfeedTreb) ? plusSampleR = maxfeedTreb;
    (plusSampleR < -maxfeedTreb) ? plusSampleR = -maxfeedTreb;
    (minusSampleR < -maxfeedTreb) ? minusSampleR = -maxfeedTreb;
    (highSampleR > distSampleR) ? treblevR += (minusSampleR*addTrebBuss);
    (highSampleR < -distSampleR) ? treblevR -= (plusSampleR*addTrebBuss);
    (treblevR > 1.0) ? treblevR = 1.0;
    (treblevR < -1.0) ? treblevR = -1.0;
    bridgerectifier = abs(highSampleR);
    (bridgerectifier > 1.57079633) ? bridgerectifier = 1.57079633;
    //max value for sine function
    bridgerectifier = sin(bridgerectifier);
    (highSampleR > 0.0) ? highSampleR = bridgerectifier
    : highSampleR = -bridgerectifier;
    //apply the distortion transform for reals
    highSampleR /= (1.0+abs(treblevR*limitingTreb));
    highSampleR += chebyshev;
    //apply the correction measuresR
    
    inputSampleL = lowSampleL + highSampleL;
    inputSampleR = lowSampleR + highSampleR;
    
    inP2 = inputSampleL * inputSampleL;
    (inP2 > 1.0) ? inP2 = 1.0; (inP2 < -1.0) ? inP2 = -1.0;
    chebyshev = (2 * inP2);
    chebyshev *= cheblevL;
    //third harmonic max -1
    (cheblevL > 0) ? cheblevL -= (IIRscaleback);
    (cheblevL < 0) ? cheblevL += (IIRscaleback);
    //this is ShortBuss, IIRscaleback is the decay speed. *2 for second harmonic, and so on
    bridgerectifier = abs(inputSampleL);
    (bridgerectifier > 1.57079633) ? bridgerectifier = 1.57079633;
    //max value for sine function
    bridgerectifier = sin(bridgerectifier);
    (inputSampleL > 0.0) ? distSampleL = bridgerectifier
      : distSampleL = -bridgerectifier;
    minusSampleL = inputSampleL - distSampleL;
    plusSampleL = inputSampleL + distSampleL;
    (minusSampleL > maxfeed) ? minusSampleL = maxfeed;
    (plusSampleL > maxfeed) ? plusSampleL = maxfeed;
    (plusSampleL < -maxfeed) ? plusSampleL = -maxfeed;
    (minusSampleL < -maxfeed) ? minusSampleL = -maxfeed;
    (inputSampleL > distSampleL) ? cheblevL += (minusSampleL*addShortBuss);
    (inputSampleL < -distSampleL) ? cheblevL -= (plusSampleL*addShortBuss);
    (cheblevL > 1.0) ? cheblevL = 1.0;
    (cheblevL < -1.0) ? cheblevL = -1.0;
    bridgerectifier = abs(inputSampleL);
    (bridgerectifier > 1.57079633) ? bridgerectifier = 1.57079633;
    //max value for sine function
    bridgerectifier = sin(bridgerectifier);
    (inputSampleL > 0.0) ? inputSampleL = bridgerectifier
      : inputSampleL = -bridgerectifier;
    //apply the distortion transform for reals
    inputSampleL /= (1.0+abs(cheblevL*limiting));
    inputSampleL += chebyshev;
    //apply the correction measuresL
    
    inP2 = inputSampleR * inputSampleR;
    (inP2 > 1.0) ? inP2 = 1.0; (inP2 < -1.0) ? inP2 = -1.0;
    chebyshev = (2 * inP2);
    chebyshev *= cheblevR;
    //third harmonic max -1
    (cheblevR > 0) ? cheblevR -= IIRscaleback;
    (cheblevR < 0) ? cheblevR += IIRscaleback;
    //this is ShortBuss, IIRscaleback is the decay speed. *2 for second harmonic, and so on
    bridgerectifier = abs(inputSampleR);
    (bridgerectifier > 1.57079633) ? bridgerectifier = 1.57079633;
    //max value for sine function
    bridgerectifier = sin(bridgerectifier);
    (inputSampleR > 0.0) ? distSampleR = bridgerectifier
      : distSampleR = -bridgerectifier;
    minusSampleR = inputSampleR - distSampleR;
    plusSampleR = inputSampleR + distSampleR;
    (minusSampleR > maxfeed) ? minusSampleR = maxfeed;
    (plusSampleR > maxfeed) ? plusSampleR = maxfeed;
    (plusSampleR < -maxfeed) ? plusSampleR = -maxfeed;
    (minusSampleR < -maxfeed) ? minusSampleR = -maxfeed;
    (inputSampleR > distSampleR) ? cheblevR += (minusSampleR*addShortBuss);
    (inputSampleR < -distSampleR) ? cheblevR -= (plusSampleR*addShortBuss);
    (cheblevR > 1.0) ? cheblevR = 1.0;
    (cheblevR < -1.0) ? cheblevR = -1.0;
    bridgerectifier = abs(inputSampleR);
    (bridgerectifier > 1.57079633) ? bridgerectifier = 1.57079633;
    //max value for sine function
    bridgerectifier = sin(bridgerectifier);
    (inputSampleR > 0.0) ? inputSampleR = bridgerectifier
      : inputSampleR = -bridgerectifier;
    //apply the distortion transform for reals
    inputSampleR /= (1.0+abs(cheblevR*limiting));
    inputSampleR += chebyshev;
    //apply the correction measuresR
    
    (outlevel < 1.0) ? (
      inputSampleL *= outlevel;
      inputSampleR *= outlevel;
    );
    
    (inputSampleL > 0.95) ? inputSampleL = 0.95;
    (inputSampleL < -0.95) ? inputSampleL = -0.95;
    (inputSampleR > 0.95) ? inputSampleR = 0.95;
    (inputSampleR < -0.95) ? inputSampleR = -0.95;
    //iron bar

//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
(fpdL < 0) ? fpdL = 0x80000000 + (fpdL & 0x7FFFFFFF);
(fpdR < 0) ? fpdR = 0x80000000 + (fpdR & 0x7FFFFFFF);

spl0 = inputSampleL;
spl1 = inputSampleR;