airwindows-totape6.jsfx

desc:Airwindows ToTape6 (Mark Heath)

// https://github.com/airwindows/airwindows/blob/master/plugins/WinVST/ToTape6/ToTape6Proc.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 29 Apr 2022 - clamped fpdR and fpdL into uint32 range to improve flutter
// 0.3 6 May 2022 - improved bit shifting for random number

//tags: tape
//author: Mark Heath

// https://github.com/airwindows/airwindows/blob/master/plugins/WinVST/ToTape6/ToTape6.cpp
// https://www.airwindows.com/totape6/

// default<min, max, increment>
slider1:0.5<0,1,0.01>Input
slider2:0.5<0,1,0.01>Soften
slider3:0.5<0,1,0.01>Head B
slider4:0.5<0,1,0.01>Flutter
slider5:0.5<0,1,0.01>Output
slider6:1<0,1,0.01>Dry/Wet

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

@init
A = 0.5;
B = 0.5;
C = 0.5;
D = 0.5;
E = 0.5;
F = 1.0;
iirMidRollerAL = 0.0;
iirMidRollerBL = 0.0;
iirHeadBumpAL = 0.0;
iirHeadBumpBL = 0.0;

iirMidRollerAR = 0.0;
iirMidRollerBR = 0.0;
iirHeadBumpAR = 0.0;
iirHeadBumpBR = 0.0;

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

freemem = 0;
dL = freemem; freemem+=502;
dR = freemem; freemem+=502;
biquadAL = freemem; freemem+=9;
biquadBL = freemem; freemem+=9;
biquadCL = freemem; freemem+=9;
biquadDL = freemem; freemem+=9;

biquadAR = freemem; freemem+=9;
biquadBR = freemem; freemem+=9;
biquadCR = freemem; freemem+=9;
biquadDR = freemem; freemem+=9;

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

x = 0;
loop(9,
  biquadAL[x] = 0.0;biquadBL[x] = 0.0;biquadCL[x] = 0.0;biquadDL[x] = 0.0;
  biquadAR[x] = 0.0;biquadBR[x] = 0.0;biquadCR[x] = 0.0;biquadDR[x] = 0.0;
  x+=1;
);
flip = false;
temp = 0;
loop(501,
  dL[temp] = 0.0;
  dR[temp] = 0.0;
  temp+=1;
);

gcount = 0;  
rateof = 0.5;
sweep = M_PI;
nextmax = 0.5;
lastSampleL = 0.0;
lastSampleR = 0.0;
flip = 0;

// 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;
C = slider3;
D = slider4;
E = slider5;
F = slider6;
// argument list

@block

  
inputgain = pow(10.0,((A-0.5)*24.0)/20.0);
SoftenControl = pow(B,2);
RollAmount = (1.0-(SoftenControl * 0.45))/overallscale;
HeadBumpControl = C * 0.25 * inputgain;
HeadBumpFreq = 0.12/overallscale;

//[0] is frequency: 0.000001 to 0.499999 is near-zero to near-Nyquist
//[1] is resonance, 0.7071 is Butterworth. Also can't be zero
biquadAL[0] = biquadBL[0] = biquadAR[0] = biquadBR[0] = 0.007/overallscale;
biquadAL[1] = biquadBL[1] = biquadAR[1] = biquadBR[1] = 0.0009;
K = tan(M_PI * biquadBR[0]);
norm = 1.0 / (1.0 + K / biquadBR[1] + K * K);
biquadAL[2] = biquadBL[2] = biquadAR[2] = biquadBR[2] = K / biquadBR[1] * norm;
biquadAL[4] = biquadBL[4] = biquadAR[4] = biquadBR[4] = -biquadBR[2];
biquadAL[5] = biquadBL[5] = biquadAR[5] = biquadBR[5] = 2.0 * (K * K - 1.0) * norm;
biquadAL[6] = biquadBL[6] = biquadAR[6] = biquadBR[6] = (1.0 - K / biquadBR[1] + K * K) * norm;
  
biquadCL[0] = biquadDL[0] = biquadCR[0] = biquadDR[0] = 0.032/overallscale;
biquadCL[1] = biquadDL[1] = biquadCR[1] = biquadDR[1] = 0.0007;
K = tan(M_PI * biquadDR[0]);
norm = 1.0 / (1.0 + K / biquadDR[1] + K * K);
biquadCL[2] = biquadDL[2] = biquadCR[2] = biquadDR[2] = K / biquadDR[1] * norm;
biquadCL[4] = biquadDL[4] = biquadCR[4] = biquadDR[4] = -biquadDR[2];
biquadCL[5] = biquadDL[5] = biquadCR[5] = biquadDR[5] = 2.0 * (K * K - 1.0) * norm;
biquadCL[6] = biquadDL[6] = biquadCR[6] = biquadDR[6] = (1.0 - K / biquadDR[1] + K * K) * norm;
  
depth = pow(D,2)*overallscale*70;
fluttertrim = (0.0024*pow(D,2))/overallscale;
outputgain = pow(10.0,((E-0.5)*24.0)/20.0);
  
refclip = 0.99;
softness = 0.618033988749894848204586;
  
wet = F;

@sample

inputSampleL = spl0;
inputSampleR = spl1;
(abs(inputSampleL)<const1) ? inputSampleL = fpdL * const2;
(abs(inputSampleR)<const1) ? inputSampleR = fpdR * const2;
drySampleL = inputSampleL;
drySampleR = inputSampleR;
    
(inputgain < 1.0) ? (
  inputSampleL *= inputgain;
  inputSampleR *= inputgain;
); //gain cut before plugin
    
flutterrandy = fpdL/UINT32_MAX;
//now we've got a random flutter, so we're messing with the pitch before tape effects go on
(gcount < 0 || gcount > 499) ? ( gcount = 499; );
dL[gcount] = inputSampleL;
dR[gcount] = inputSampleR;
count = gcount;
(depth != 0.0) ? (
  
  offset = depth + (depth * pow(rateof,2) * sin(sweep));
  
  count += floor(offset);
  inputSampleL = (dL[count-((count > 499)?500:0)] * (1-(offset-floor(offset))) );
  inputSampleR = (dR[count-((count > 499)?500:0)] * (1-(offset-floor(offset))) );
  inputSampleL += (dL[count+1-((count+1 > 499)?500:0)] * (offset-floor(offset)) );
  inputSampleR += (dR[count+1-((count+1 > 499)?500:0)] * (offset-floor(offset)) );
  
  rateof = (rateof * (1.0-fluttertrim)) + (nextmax * fluttertrim);
  sweep += rateof * fluttertrim;
  
  (sweep >= (M_PI*2.0)) ? (
    sweep -= M_PI;
    nextmax = 0.24 + (flutterrandy * 0.74);
  );
  //apply to input signal only when flutter is present, interpolate samples
);
gcount-=1;

vibDrySampleL = inputSampleL;
vibDrySampleR = inputSampleR;
HighsSampleL = 0.0;
HighsSampleR = 0.0;
NonHighsSampleL = 0.0;
NonHighsSampleR = 0.0;
tempSample;

(flip) ?
(
  iirMidRollerAL = (iirMidRollerAL * (1.0 - RollAmount)) + (inputSampleL * RollAmount);
  iirMidRollerAR = (iirMidRollerAR * (1.0 - RollAmount)) + (inputSampleR * RollAmount);
  HighsSampleL = inputSampleL - iirMidRollerAL;
  HighsSampleR = inputSampleR - iirMidRollerAR;
  NonHighsSampleL = iirMidRollerAL;
  NonHighsSampleR = iirMidRollerAR;
  
  iirHeadBumpAL += (inputSampleL * 0.05);
  iirHeadBumpAR += (inputSampleR * 0.05);
  iirHeadBumpAL -= (iirHeadBumpAL * iirHeadBumpAL * iirHeadBumpAL * HeadBumpFreq);
  iirHeadBumpAR -= (iirHeadBumpAR * iirHeadBumpAR * iirHeadBumpAR * HeadBumpFreq);
  iirHeadBumpAL = sin(iirHeadBumpAL);
  iirHeadBumpAR = sin(iirHeadBumpAR);
  
  tempSample = (iirHeadBumpAL * biquadAL[2]) + biquadAL[7];
  biquadAL[7] = (iirHeadBumpAL * biquadAL[3]) - (tempSample * biquadAL[5]) + biquadAL[8];
  biquadAL[8] = (iirHeadBumpAL * biquadAL[4]) - (tempSample * biquadAL[6]);
  iirHeadBumpAL = tempSample; //interleaved biquad
  (iirHeadBumpAL > 1.0) ? iirHeadBumpAL = 1.0;
  (iirHeadBumpAL < -1.0) ? iirHeadBumpAL = -1.0;
  iirHeadBumpAL = asin(iirHeadBumpAL);
  
  tempSample = (iirHeadBumpAR * biquadAR[2]) + biquadAR[7];
  biquadAR[7] = (iirHeadBumpAR * biquadAR[3]) - (tempSample * biquadAR[5]) + biquadAR[8];
  biquadAR[8] = (iirHeadBumpAR * biquadAR[4]) - (tempSample * biquadAR[6]);
  iirHeadBumpAR = tempSample; //interleaved biquad
  (iirHeadBumpAR > 1.0) ? iirHeadBumpAR = 1.0;
  (iirHeadBumpAR < -1.0) ? iirHeadBumpAR = -1.0;
  iirHeadBumpAR = asin(iirHeadBumpAR);
  
  inputSampleL = sin(inputSampleL);
  tempSample = (inputSampleL * biquadCL[2]) + biquadCL[7];
  biquadCL[7] = (inputSampleL * biquadCL[3]) - (tempSample * biquadCL[5]) + biquadCL[8];
  biquadCL[8] = (inputSampleL * biquadCL[4]) - (tempSample * biquadCL[6]);
  inputSampleL = tempSample; //interleaved biquad
  (inputSampleL > 1.0) ? inputSampleL = 1.0;
  (inputSampleL < -1.0) ? inputSampleL = -1.0;
  inputSampleL = asin(inputSampleL);
  
  inputSampleR = sin(inputSampleR);
  tempSample = (inputSampleR * biquadCR[2]) + biquadCR[7];
  biquadCR[7] = (inputSampleR * biquadCR[3]) - (tempSample * biquadCR[5]) + biquadCR[8];
  biquadCR[8] = (inputSampleR * biquadCR[4]) - (tempSample * biquadCR[6]);
  inputSampleR = tempSample; //interleaved biquad
  (inputSampleR > 1.0) ? inputSampleR = 1.0;
  (inputSampleR < -1.0) ? inputSampleR = -1.0;
  inputSampleR = asin(inputSampleR);
) : (
  iirMidRollerBL = (iirMidRollerBL * (1.0 - RollAmount)) + (inputSampleL * RollAmount);
  iirMidRollerBR = (iirMidRollerBR * (1.0 - RollAmount)) + (inputSampleR * RollAmount);
  HighsSampleL = inputSampleL - iirMidRollerBL;
  HighsSampleR = inputSampleR - iirMidRollerBR;
  NonHighsSampleL = iirMidRollerBL;
  NonHighsSampleR = iirMidRollerBR;
  
  iirHeadBumpBL += (inputSampleL * 0.05);
  iirHeadBumpBR += (inputSampleR * 0.05);
  iirHeadBumpBL -= (iirHeadBumpBL * iirHeadBumpBL * iirHeadBumpBL * HeadBumpFreq);
  iirHeadBumpBR -= (iirHeadBumpBR * iirHeadBumpBR * iirHeadBumpBR * HeadBumpFreq);
  iirHeadBumpBL = sin(iirHeadBumpBL);
  iirHeadBumpBR = sin(iirHeadBumpBR);
  
  tempSample = (iirHeadBumpBL * biquadBL[2]) + biquadBL[7];
  biquadBL[7] = (iirHeadBumpBL * biquadBL[3]) - (tempSample * biquadBL[5]) + biquadBL[8];
  biquadBL[8] = (iirHeadBumpBL * biquadBL[4]) - (tempSample * biquadBL[6]);
  iirHeadBumpBL = tempSample; //interleaved biquad
  (iirHeadBumpBL > 1.0) ? iirHeadBumpBL = 1.0;
  (iirHeadBumpBL < -1.0) ? iirHeadBumpBL = -1.0;
  iirHeadBumpBL = asin(iirHeadBumpBL);
  
  tempSample = (iirHeadBumpBR * biquadBR[2]) + biquadBR[7];
  biquadBR[7] = (iirHeadBumpBR * biquadBR[3]) - (tempSample * biquadBR[5]) + biquadBR[8];
  biquadBR[8] = (iirHeadBumpBR * biquadBR[4]) - (tempSample * biquadBR[6]);
  iirHeadBumpBR = tempSample; //interleaved biquad
  (iirHeadBumpBR > 1.0) ? iirHeadBumpBR = 1.0;
  (iirHeadBumpBR < -1.0) ? iirHeadBumpBR = -1.0;
  iirHeadBumpBR = asin(iirHeadBumpBR);
  
  inputSampleL = sin(inputSampleL);
  tempSample = (inputSampleL * biquadDL[2]) + biquadDL[7];
  biquadDL[7] = (inputSampleL * biquadDL[3]) - (tempSample * biquadDL[5]) + biquadDL[8];
  biquadDL[8] = (inputSampleL * biquadDL[4]) - (tempSample * biquadDL[6]);
  inputSampleL = tempSample; //interleaved biquad
  (inputSampleL > 1.0) ? inputSampleL = 1.0;
  (inputSampleL < -1.0) ? inputSampleL = -1.0;
  inputSampleL = asin(inputSampleL);
  
  inputSampleR = sin(inputSampleR);
  tempSample = (inputSampleR * biquadDR[2]) + biquadDR[7];
  biquadDR[7] = (inputSampleR * biquadDR[3]) - (tempSample * biquadDR[5]) + biquadDR[8];
  biquadDR[8] = (inputSampleR * biquadDR[4]) - (tempSample * biquadDR[6]);
  inputSampleR = tempSample; //interleaved biquad
  (inputSampleR > 1.0) ? inputSampleR = 1.0;
  (inputSampleR < -1.0) ? inputSampleR = -1.0;
  inputSampleR = asin(inputSampleR);
);
flip = !flip;

groundSampleL = vibDrySampleL - inputSampleL; //set up UnBox on fluttered audio
groundSampleR = vibDrySampleR - inputSampleR; //set up UnBox on fluttered audio

(inputgain > 1.0) ? (
  inputSampleL *= inputgain;
  inputSampleR *= inputgain;
);

applySoften = abs(HighsSampleL)*1.57079633;
(applySoften > 1.57079633) ? applySoften = 1.57079633;
applySoften = 1-cos(applySoften);
(HighsSampleL > 0) ? inputSampleL -= applySoften;
(HighsSampleL < 0) ? inputSampleL += applySoften;
//apply Soften depending on polarity
applySoften = abs(HighsSampleR)*1.57079633;
(applySoften > 1.57079633) ? applySoften = 1.57079633;
applySoften = 1-cos(applySoften);
(HighsSampleR > 0) ? inputSampleR -= applySoften;
(HighsSampleR < 0) ? inputSampleR += applySoften;
//apply Soften depending on polarity

suppress = (1.0-abs(inputSampleL)) * 0.00013;
(iirHeadBumpAL > suppress) ? iirHeadBumpAL -= suppress;
(iirHeadBumpAL < -suppress) ? iirHeadBumpAL += suppress;
(iirHeadBumpBL > suppress) ? iirHeadBumpBL -= suppress;
(iirHeadBumpBL < -suppress) ? iirHeadBumpBL += suppress;
//restrain resonant quality of head bump algorithm
suppress = (1.0-abs(inputSampleR)) * 0.00013;
(iirHeadBumpAR > suppress) ? iirHeadBumpAR -= suppress;
(iirHeadBumpAR < -suppress) ? iirHeadBumpAR += suppress;
(iirHeadBumpBR > suppress) ? iirHeadBumpBR -= suppress;
(iirHeadBumpBR < -suppress) ? iirHeadBumpBR += suppress;
//restrain resonant quality of head bump algorithm

inputSampleL += ((iirHeadBumpAL + iirHeadBumpBL) * HeadBumpControl);
inputSampleR += ((iirHeadBumpAR + iirHeadBumpBR) * HeadBumpControl);
//apply Fatten.

(inputSampleL > 1.0) ? inputSampleL = 1.0;
(inputSampleL < -1.0) ? inputSampleL = -1.0;
mojo = pow(abs(inputSampleL),0.25);
(mojo > 0.0) ? inputSampleL = (sin(inputSampleL * mojo * M_PI * 0.5) / mojo);
//mojo is the one that flattens WAAAAY out very softly before wavefolding    

(inputSampleR > 1.0) ? inputSampleR = 1.0;
(inputSampleR < -1.0) ? inputSampleR = -1.0;
mojo = pow(abs(inputSampleR),0.25);
(mojo > 0.0) ? inputSampleR = (sin(inputSampleR * mojo * M_PI * 0.5) / mojo);
//mojo is the one that flattens WAAAAY out very softly before wavefolding    

inputSampleL += groundSampleL; //apply UnBox processing
inputSampleR += groundSampleR; //apply UnBox processing

(outputgain != 1.0) ? (
  inputSampleL *= outputgain;
  inputSampleR *= outputgain;
);

(lastSampleL >= refclip) ?
(
  (inputSampleL < refclip) ? 
    lastSampleL = ((refclip*softness) + (inputSampleL * (1.0-softness)))
    :
    lastSampleL = refclip;
);

(lastSampleL <= -refclip) ?
(
  (inputSampleL > -refclip) ?
    lastSampleL = ((-refclip*softness) + (inputSampleL * (1.0-softness)))
    : 
    lastSampleL = -refclip;
);

(inputSampleL > refclip) ?
(
  (lastSampleL < refclip) ?
   inputSampleL = ((refclip*softness) + (lastSampleL * (1.0-softness)))
  :
  inputSampleL = refclip;
);

(inputSampleL < -refclip) ?
(
  (lastSampleL > -refclip) ?
    inputSampleL = ((-refclip*softness) + (lastSampleL * (1.0-softness)))
    :
    inputSampleL = -refclip;
);
lastSampleL = inputSampleL; //end ADClip L

(lastSampleR >= refclip) ?
(
  (inputSampleR < refclip) ?
    lastSampleR = ((refclip*softness) + (inputSampleR * (1.0-softness)))
    :
    lastSampleR = refclip;
);

(lastSampleR <= -refclip) ?
(
  (inputSampleR > -refclip) ?
    lastSampleR = ((-refclip*softness) + (inputSampleR * (1.0-softness)))
    :
    lastSampleR = -refclip;
);

(inputSampleR > refclip) ?
(
  (lastSampleR < refclip) ?
    inputSampleR = ((refclip*softness) + (lastSampleR * (1.0-softness)))
    :
    inputSampleR = refclip;
);

(inputSampleR < -refclip) ?
(
  (lastSampleR > -refclip) ?
    inputSampleR = ((-refclip*softness) + (lastSampleR * (1.0-softness)))
    : inputSampleR = -refclip;
);
lastSampleR = inputSampleR; //end ADClip R    

(inputSampleL > refclip) ? inputSampleL = refclip;
(inputSampleL < -refclip) ? inputSampleL = -refclip;
//final iron bar
(inputSampleR > refclip) ? inputSampleR = refclip;
(inputSampleR < -refclip) ? inputSampleR = -refclip;
//final iron bar

(wet !=1.0) ? (
  inputSampleL = (inputSampleL * wet) + (drySampleL * (1.0-wet));
  inputSampleR = (inputSampleR * wet) + (drySampleR * (1.0-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
(fpdL < 0) ? fpdL = 0x80000000 + (fpdL & 0x7FFFFFFF);
(fpdR < 0) ? fpdR = 0x80000000 + (fpdR & 0x7FFFFFFF);

spl0 = inputSampleL;
spl1 = inputSampleR;