Effects

/**
   Auto-panner

   Frequency: same as `apan_freq`
   Phase offset: same as `apan_phase`

   Other:
     - `apan_waveform`: LFO wave number (cf. `lfoN_wave`)
     - `apan_depth`:
          0 to disable, >0 to enable (reference)
          jpc: in this implementation, depth is allowed 0-100% granularity
               to make it more meaningful

   Note:
     Reference uses a linear pan function.
     Below, logarithmic is provided but it's commented.
 */

import("stdfaust.lib");

f = hslider("[1] Frequency [unit:Hz]", 5.0, 0.01, 5.0, 0.01);
o = hslider("[2] Phase offset [unit:deg]", 180.0, 0.0, 360.0, 1.0) : *(1.0/360.0);
d = hslider("[3] Depth [unit:%]", 50, 0, 100, 1) : *(0.01);

autopan = *(panL(lfo01)), *(panR(lfo01))
with {
  // any chosen waveform with output in domain [0:1]
  calcLfo = triangle;

  // output of the overall LFO, which modulates left and right exactly opposite
  // it's the difference of 2 sub-LFO with a phase offset between them
  lfoDD = d*(calcLfo(phase1)-calcLfo(phase2)); // outputs [-d:+d]
  lfo01 = 0.5*(lfoDD+1.0); // outputs [0:1]

  // running phase of 2 synced LFO with fixed offset
  phase1 = os.lf_sawpos(f);
  phase2 = wrap(phase1+o);

  // ordinary stereo pan function (+3dB)
  //panL(x) = cos(x*(ma.PI/2.0))*sqrt(2.0);
  //panR(x) = sin(x*(ma.PI/2.0))*sqrt(2.0);

  // linear stereo pan function
  panL(x) = 2.*(1.-x);
  panR(x) = 2.*(x);

  triangle(p) = 1.-abs(2.*p-1.);
  wrap(x) = x-int(x);
};

/* Test */
process = autopan;
// process = os.osci(110.0) : *(g) <: (_, _) : autopan with {
//   g = hslider("[4] Gain adjust", 0.4, 0.1, 1.0, 0.01);
// };

import("stdfaust.lib");

amount = hslider("Amount", 90, 0, 100, 1);
oversampling = 1;//fconstant(int gOversampling, <math.h>);

bitred = *(steps) : roundToInt : /(steps) : hpf1p(20.0/oversampling) with {
  roundToInt(x) = ba.if(x<0, ma.neg(a), a) with { a = int(abs(x)); };
  steps = 5.+(1.-amount*0.01)*512;
};

hpf1p(f) = fi.iir((0.5*(1.+p),-0.5*(1+p)),(0.-p)) with {
  p = exp(-2.*ma.PI*f/ma.SR);
};

/* Test */
process = os.osci(110.0/oversampling) : *(0.15) : bitred <: (_, _);

import("stdfaust.lib");

amount = hslider("Amount", 99, 0, 100, 1);

decim(x) = y : hpf1p(20.0) letrec {
  'y = ba.if(p+(f/ma.SR)>1.0, x, y);
  'p = wrap(p+(f/ma.SR)); // the position 0-1
}
with {
  // exponential curve fit
  a=5.729950e+04; b=-6.776081e-02; c=180;
  f=a*exp(amount*b)+c;
};

hpf1p(f) = fi.iir((0.5*(1.+p),-0.5*(1+p)),(0.-p)) with {
  p = exp(-2.*ma.PI*f/ma.SR);
};

wrap(x) = x-int(x);

/* Test */
process = os.osci(110.0) : *(0.15) : decim <: (_, _);

/*
Dual-notch Phaser, with linear cutoff control by LFO

Note:
  `phaser_stages`: number of stages. Cascade this function as many times as
                   needed to produce the effect.
  `phaser_waveform`: wave number (same as LFO)
  `phaser_freq`: frequency of LFO which modulates the notches
  `phaser_depth`: manipulates the 2 ranges of cutoff for the notches
  `phaser_feedback`: TODO, implemented in model below but not measured
  `phaser_phase[_oncc]`: TODO, assumed to be the phase 0-1 of LFO?
*/

import("stdfaust.lib");

phaser = (+:notch1:notch2) ~ *(feedback) with {
  depth = hslider("[1] Depth [unit:%]", 50, 0, 100, 1);
  lfoFreq = hslider("[2] LFO frequency [unit:Hz]", 1.0, 0.0, 10.0, 0.01);

  feedback = 0.0; // TODO determine `phaser_feedback` in the domain 0-100

  lfo = os.lf_triangle(lfoFreq); // set any LFO waveform `phaser_waveform`

  cutoffDepth1 = 31*depth;
  cutoffMax1 = 3100.0;
  cutoffCenter1 = 1600.0;

  cutoffDepth2 = 155*depth;
  cutoffMax2 = 13400.0;
  cutoffCenter2 = 8300.0;

  //widthAdjust = hslider("[3] Width adjust", 0.5, 0.1, 10.0, 0.01);
  widthAdjust = 0.5; // arbitrary pick, not checked

  notchWidth1 = widthAdjust*cutoffDepth1;
  notchWidth2 = widthAdjust*cutoffDepth2;

  notchFreq1 = max(0,min(cutoffMax1,cutoffCenter1+lfo*cutoffDepth1));
  notchFreq2 = max(0,min(cutoffMax2,cutoffCenter2+lfo*cutoffDepth2));

  // filter pick arbitrary, could use also 1-pole allpass
  notch1 = fi.notchw(notchWidth1, notchFreq1);
  notch2 = fi.notchw(notchWidth2, notchFreq2);
};

/* Test */
process = no.noise : *(0.15) : phaser;
// process = phaser, phaser;