--- /dev/null
+# Soundpipe
+
+compiler generated documentation
+
+```gwion
+#!+ Soundpipe
+const late UGen @soundpipe;
+class ftbl extends Object {
+ var @internal @ftbl;
+ #!- a string of space-separated parameters, in groups of four:
+ #!-
+ #!- arg 1 is the partial number. must be positive, but it doesn't need to be a whole number.
+ #!-
+ #!- arg 2 is the strength.
+ #!-
+ #!- arg 3 is the initial phase (expressed in degrees)
+ #!-
+ #!- arg 4 is the dc offset. A dc offset of 2 will put a 2-strength sinusoid in the range
+ #!- from (-2,2) to (0, 4)
+ fun void _gen_composite(int Sizestring _argstring);
+ #!- filename
+ fun void _gen_file(int Sizestring _filename);
+ #!- The scale of the distribution, in the range of -/+scale
+ #!- Random seed.
+ fun void _gen_gauss(int Sizefloat _scaleint _seed);
+ #!- A list of ordered xy pairs. X expects whole number integers, as they correlate to index positions in the ftable.
+ fun void _gen_line(int Sizestring _argstring);
+ #!- ftable of amplitudes to use
+ #!- Base frequency.
+ #!- Bandwidth.
+ fun void _gen_padsynth(int Sizeftbl _ampsfloat _ffloat _bw);
+ #!- A string of value pairs. The first value is the value, then the probability.
+ fun void _gen_rand(int Sizestring _argstring);
+ #!- destination ftable
+ fun void _gen_scrambler(int Sizeftbl _dest);
+ fun void _gen_sine(int Size);
+ #!- A list of amplitudes, in the range 0-1, separated by spaces.Each position coordinates to their partial number. Position 1 is the fundamental amplitude (1 * freq). Position 2 is the first overtone (2 * freq), 3 is the second (3 * freq), etc...
+ fun void _gen_sinesum(int Sizestring _argstring);
+ fun void _gen_triangle(int Size);
+ #!- A list of ordered xy pairs. X expects whole number integers, as they correlate to index positions in the ftable.
+ fun void _gen_xline(int Sizestring _argstring);
+}
+#!- ADSR generator
+#!- This is an ADSR generator whose curves are created using a one-pole low pass filter.
+class Adsr extends UGen {
+ fun float atk();
+ #!- Attack time (in seconds)
+ fun float atk(float _atk);
+ fun float dec();
+ #!- Decay time (in seconds)
+ fun float dec(float _dec);
+ fun float sus();
+ #!- Sustain (in range 0-1)
+ fun float sus(float _sus);
+ fun float rel();
+ #!- Release time (in seconds)
+ fun float rel(float _rel);
+}
+#!- Allpass filter
+#!-
+#!- Often used for the creation of reverb modules.
+class Allpass extends UGen {
+ #!- The loop time of the filter, in seconds. This can also be thought of as the delay time.
+ fun void init(float _looptime);
+ fun float revtime();
+ #!- The reverberation time, in seconds (RT-60).
+ fun float revtime(float _revtime);
+}
+#!- First-order recursive highpass filter
+#!-
+#!- This is the complement to the tone module.
+class Atone extends UGen {
+ fun float hp();
+ #!- The response curve's half power point (cutoff frequency).
+ fun float hp(float _hp);
+}
+#!- Automatic wah pedal
+#!- An automatic wah effect, ported from Guitarix via Faust.
+class Autowah extends UGen {
+ fun float level();
+ #!- Overall level (between 0 and 1)
+ fun float level(float _level);
+ fun float wah();
+ #!- wah amount
+ fun float wah(float _wah);
+ fun float mix();
+ #!- Wet/dry amount (100 = wet, 0 = dry)
+ fun float mix(float _mix);
+}
+#!- Balance the gain of one signal based on another signal
+#!-
+#!- This is often used to restore gain lost in the output of a filter.
+#!-
+#!- In the source code, the value `ihp` is set to a static 10hz. This is the default value in Csound, and should not often need to be changed.
+class Bal extends UGen {
+}
+#!- Physical model approximating the sound of a struck metal bar
+class Bar extends UGen {
+ #!- Dimensionless stiffness parameter
+ #!- High-frequency loss parameter. Keep this small
+ fun void init(float _iKfloat _ib);
+ fun float bcL();
+ #!- Boundary condition at left end of bar. 1 = clamped, 2 = pivoting, 3 = free
+ fun float bcL(float _bcL);
+ fun float bcR();
+ #!- Boundary condition at right end of bar. 1 = clamped, 2 = pivoting, 3 = free
+ fun float bcR(float _bcR);
+ fun float T30();
+ #!- 30db decay time (in seconds).
+ fun float T30(float _T30);
+ fun float scan();
+ #!- Speed of scanning the output location.
+ fun float scan(float _scan);
+ fun float pos();
+ #!- Position along bar that strike occurs.
+ fun float pos(float _pos);
+ fun float vel();
+ #!- Normalized strike velocity
+ fun float vel(float _vel);
+ fun float wid();
+ #!- Spatial width of strike.
+ fun float wid(float _wid);
+}
+#!- A sweepable biquadratic general purpose filter
+#!-
+#!-
+class Biquad extends UGen {
+ fun float b0();
+ #!- biquad coefficient.
+ fun float b0(float _b0);
+ fun float b1();
+ #!- biquad coefficient.
+ fun float b1(float _b1);
+ fun float b2();
+ #!- biquad coefficient.
+ fun float b2(float _b2);
+ fun float a0();
+ #!- biquad coefficient.
+ fun float a0(float _a0);
+ fun float a1();
+ #!- biquad coefficient.
+ fun float a1(float _a1);
+ fun float a2();
+ #!- biquad coefficient.
+ fun float a2(float _a2);
+}
+#!- Bipolar Scale
+#!-
+#!- This module scales from bipolar [-1, 1] to another range defined by min and max.
+class Biscale extends UGen {
+ fun float min();
+ #!- Minimum value to scale to.
+ fun float min(float _min);
+ fun float max();
+ #!- Maximum value to scale to.
+ fun float max(float _max);
+}
+#!- Digital signal degradation
+#!-
+#!- Bitcrusher will digitally degrade a signal by altering the bitdepth and sampling-rate.
+class Bitcrush extends UGen {
+ fun float bitdepth();
+ #!- Bit depth. Expects an integer in the range of 1-16. Fractional values will be truncated.
+ fun float bitdepth(float _bitdepth);
+ fun float srate();
+ #!- Sampling rate.
+ fun float srate(float _srate);
+}
+#!- Bandlimited sawtooth oscillator
+#!- This is a bandlimited sawtooth oscillator ported from the `sawtooth` function from the Faust
+#!- programming language.
+class Blsaw extends UGen {
+ fun float freq();
+ #!- Frequency, (range 0-20000)
+ fun float freq(float _freq);
+ fun float amp();
+ #!- Amplitude (range 0-1).
+ fun float amp(float _amp);
+}
+#!- Bandlimited square oscillator
+#!- This is a bandlimited square oscillator ported from the `squaretooth` function from the Faust
+#!- programming language.
+class Blsquare extends UGen {
+ fun float freq();
+ #!- Frequency, (range 0-20000)
+ fun float freq(float _freq);
+ fun float amp();
+ #!- Amplitude (range 0-1).
+ fun float amp(float _amp);
+ fun float width();
+ #!- Duty cycle width (range 0-1).
+ fun float width(float _width);
+}
+#!- Bandlimited triangle oscillator
+#!- This is a bandlimited triangle oscillator ported from the `triangletooth` function from the Faust
+#!- programming language.
+class Bltriangle extends UGen {
+ fun float freq();
+ #!- Frequency, (range 0-20000)
+ fun float freq(float _freq);
+ fun float amp();
+ #!- Amplitude (range 0-1).
+ fun float amp(float _amp);
+}
+#!- Brownian noise generator.
+class Brown extends UGen {
+}
+#!- Bandpass Butterworth filter
+class Butbp extends UGen {
+ fun float freq();
+ #!- Center Frequency. (in Hertz)
+ fun float freq(float _freq);
+ fun float bw();
+ #!- Bandwidth. (in Hertz)
+ fun float bw(float _bw);
+}
+#!- Band-reject Butterworth filter
+class Butbr extends UGen {
+ fun float freq();
+ #!- Center Frequency. (in Hertz)
+ fun float freq(float _freq);
+ fun float bw();
+ #!- Bandwidth. (in Hertz)
+ fun float bw(float _bw);
+}
+#!- Highpass Butterworth filter
+class Buthp extends UGen {
+ fun float freq();
+ #!- Cutoff Frequency.
+ fun float freq(float _freq);
+}
+#!- Lowpass Butterworth filter
+class Butlp extends UGen {
+ fun float freq();
+ #!- Cutoff Frequency.
+ fun float freq(float _freq);
+}
+#!- Applies clip-limiting to a signal
+class Clip extends UGen {
+ fun float lim();
+ #!- threshold / limiting value.
+ fun float lim(float _lim);
+}
+#!- Resettable clock with subdivisions
+class Clock extends UGen {
+ fun float bpm();
+ #!- Clock tempo, in beats per minute.
+ fun float bpm(float _bpm);
+ fun float subdiv();
+ #!- Clock subdivision. 2 = eighths, 4 = 16ths, etc.
+ fun float subdiv(float _subdiv);
+}
+#!- Comb filter
+class Comb extends UGen {
+ #!- The loop time of the filter, in seconds. This can also be thought of as the delay time.
+ fun void init(float _looptime);
+ fun float revtime();
+ #!- Reverberation time, in seconds (RT-60).
+ fun float revtime(float _revtime);
+}
+#!- Compressor
+class Compressor extends UGen {
+ fun float ratio();
+ #!- Ratio to compress with, a value > 1 will compress
+ fun float ratio(float _ratio);
+ fun float thresh();
+ #!- Threshold (in dB) 0 = max
+ fun float thresh(float _thresh);
+ fun float atk();
+ #!- Compressor attack
+ fun float atk(float _atk);
+ fun float rel();
+ #!- Compressor release
+ fun float rel(float _rel);
+}
+#!- Partioned convolution.
+#!- This module will perform partitioned convolution on an input signal using
+#!- an ftable as an impulse response.
+class Conv extends UGen {
+ #!- Ftable used as the impulse response.
+ #!- Partition length (in samples).
+ #!- Must be a power of 2. Lower values will add less latency, at the cost
+ #!- of requiring more CPU power.
+ fun void init(ftbl _ftfloat _iPartLen);
+}
+#!- Trigger-based fixed counter
+#!-
+#!- The signal output will count from 0 to [N-1], and then
+#!- repeat itself. Count will start when it has been triggered, otherwise it will be -1.
+class Count extends UGen {
+ fun float count();
+ #!- Number to count up to (count - 1). Decimal points will be truncated.
+ fun float count(float _count);
+ fun float mode();
+ #!- Counting mode. 0 = wrap-around, 1 = count up to N -1, then stop and spit out -1
+ fun float mode(float _mode);
+}
+#!- Crossfade two signals.
+#!- This module will perform a linear crossfade between two input signals.
+class Crossfade extends UGen {
+ fun float pos();
+ #!- Crossfade position. 0 = all signal 1, 1 = all signal 2
+ fun float pos(float _pos);
+}
+#!- A simple DC block filter
+class Dcblock extends UGen {
+}
+#!- Adds a delay to an incoming signal with optional feedback.
+class Delay extends UGen {
+ #!- Delay time, in seconds.
+ fun void init(float _time);
+ fun float feedback();
+ #!- Feedback amount. Should be a value between 0-1.
+ fun float feedback(float _feedback);
+}
+#!- Diode-ladder virtual analogue low-pass filter
+#!- This is a diode-ladder filter designed by Will Pirkle.
+#!- More information can be found in this paper here:
+#!- http://www.willpirkle.com/Downloads/AN-6DiodeLadderFilter.pdf
+class Diode extends UGen {
+ fun float freq();
+ #!-
+ fun float freq(float _freq);
+ fun float res();
+ #!-
+ fun float res(float _res);
+}
+#!- Read from an audio file
+#!-
+#!- Expects a 1-channel file matching the project samplerate. Diskin should be able to read any file format that libsndfile supports.
+class Diskin extends UGen {
+ #!- Filename of the audio file.
+ fun void init(string _filename);
+}
+#!- Distortion using a modified hyperbolic tangent function
+class Dist extends UGen {
+ fun float pregain();
+ #!- Gain applied before waveshaping.
+ fun float pregain(float _pregain);
+ fun float postgain();
+ #!- Gain applied after waveshaping
+ fun float postgain(float _postgain);
+ fun float shape1();
+ #!- Shape of the positive part of the signal. A value of 0 gets a flat clip.
+ fun float shape1(float _shape1);
+ fun float shape2();
+ #!- Like shape1, only for the negative part of the signal.
+ fun float shape2(float _shape2);
+}
+#!- Delta Metro
+#!-
+#!- Produce a set of triggers spaced apart by time.
+class Dmetro extends UGen {
+ fun float time();
+ #!- Time between triggers (in seconds). This will update at the start of each trigger.
+ fun float time(float _time);
+}
+#!- Water drop physical model
+#!-
+#!- Physical model of the sound of dripping water. When triggered, it will produce a droplet of water.
+class Drip extends UGen {
+ #!- Period of time over which all sound is stopped.
+ fun void init(float _dettack);
+ fun float num_tubes();
+ #!- Number of units.
+ fun float num_tubes(float _num_tubes);
+ fun float amp();
+ #!- Amplitude.
+ fun float amp(float _amp);
+ fun float damp();
+ #!- The damping factor. Maximum value is 2.0.
+ fun float damp(float _damp);
+ fun float shake_max();
+ #!- The amount of energy to add back into the system.
+ fun float shake_max(float _shake_max);
+ fun float freq();
+ #!- Main resonant frequency.
+ fun float freq(float _freq);
+ fun float freq1();
+ #!- The first resonant frequency.
+ fun float freq1(float _freq1);
+ fun float freq2();
+ #!- The second resonant frequency.
+ fun float freq2(float _freq2);
+}
+#!- Delta trigger
+#!-
+#!- This is able to create spaced out triggers. It is set off by a single trigger.
+class Dtrig extends UGen {
+ #!- An ftable containing times in seconds.
+ fun void init(ftbl _ft);
+ fun int loop();
+ #!- When set to 1, dtrig will wrap around and loop again.
+ fun int loop(int _loop);
+ fun float delay();
+ #!- This sets a delay (in seconds) on the triggered output when it is initially triggered. This is useful for rhythmic sequences with rests in the beginnings.
+ fun float delay(float _delay);
+ fun float scale();
+ #!- Scales the timing signal. A scale of 1 is normal, a scale of 2 will double the duration, and a scale of 0.5 will halve it.
+ fun float scale(float _scale);
+}
+#!- A series of random impulses
+class Dust extends UGen {
+ fun float amp();
+ #!-
+ fun float amp(float _amp);
+ fun float density();
+ #!-
+ fun float density(float _density);
+ fun int bipolar();
+ #!- Bipolar flag. A non-zero makes the signal bipolar as opposed to unipolar.
+ fun int bipolar(int _bipolar);
+}
+#!- 2nd order tunable equalization filter
+#!-
+#!- This provides a peak/notch filter for building parametric/graphic equalizers. With gain above 1, there will be a peak at the center frequency with a width dependent on bw. If gain is less than 1, a notch is formed around the center frequency (freq).
+#!-
+class Eqfil extends UGen {
+ fun float freq();
+ #!- The center frequency of the filter
+ fun float freq(float _freq);
+ fun float bw();
+ #!- The peak/notch bandwidth in Hertz
+ fun float bw(float _bw);
+ fun float gain();
+ #!- The peak/notch gain
+ fun float gain(float _gain);
+}
+#!- Produce a line segment with exponential slope
+#!- This will generate a line from value A to value B in given amount of time.
+#!- When it reaches it's target, it will stay at that value.
+class Expon extends UGen {
+ fun float a();
+ #!- Inital point.
+ fun float a(float _a);
+ fun float dur();
+ #!- Duration (in seconds)
+ fun float dur(float _dur);
+ fun float b();
+ #!- End point
+ fun float b(float _b);
+}
+#!- Produces sinusoid bursts for granular and formant synthesis
+#!-
+class Fof extends UGen {
+ #!- ftable for sine wave.
+ #!- Ftable for envelope function (use either gen_line or gen_sinecomp)
+ #!- Maximum number of foflet overlaps.
+ #!- Phase
+ fun void init(ftbl _sineftbl _winint _iolapsfloat _iphs);
+ fun float amp();
+ #!- Overall amplitude
+ fun float amp(float _amp);
+ fun float fund();
+ #!- Fundamental frequency
+ fun float fund(float _fund);
+ fun float form();
+ #!- Formant frequency.
+ fun float form(float _form);
+ fun float oct();
+ #!- Octaviation index, if greater than zero, lowers the effective fund frequency by attenuating odd-numbered sine bursts. whole numbers are full octaves. fractions transpositional.
+ fun float oct(float _oct);
+ fun float band();
+ #!- Bandwidth (in -6db) expressed in Hz. The bandwidth determines the rate of exponential decay throughout the sineburst, before the enveloping is applied.
+ fun float band(float _band);
+ fun float ris();
+ #!- Rise of sinusoid burst (in seconds)
+ fun float ris(float _ris);
+ fun float dec();
+ #!- Decay of the sinusoid burst (in seconds).
+ fun float dec(float _dec);
+ fun float dur();
+ #!- OVerall duration of sinusoid burst (in seconds).
+ fun float dur(float _dur);
+}
+#!- Formant filter
+#!- When fed with a pulse train, it will generate a series of overlapping grains. Overlapping will occur when 1/freq < dec, but there is no upper limit on the number of overlaps. (cited from www.csounds.com/manual/html/fofilter.html)
+class Fofilt extends UGen {
+ fun float freq();
+ #!- Center frequency.
+ fun float freq(float _freq);
+ fun float atk();
+ #!- Impulse response attack time (in seconds).
+ fun float atk(float _atk);
+ fun float dec();
+ #!- Impulse reponse decay time (in seconds)
+ fun float dec(float _dec);
+}
+#!- Sucession of grains from data in a stored function table
+class Fog extends UGen {
+ #!- ftable for sample.
+ #!- Ftable for envelope function (use either gen_line or gen_sinecomp)
+ #!- Maximum number of foglet overlaps.
+ #!- Phase
+ fun void init(ftbl _wavftbl _winint _iolapsfloat _iphs);
+ fun float amp();
+ #!- Overall amplitude
+ fun float amp(float _amp);
+ fun float dens();
+ #!- Density. The frequency of grains/second.
+ fun float dens(float _dens);
+ fun float trans();
+ #!- Transposition, in terms of playback speed
+ fun float trans(float _trans);
+ fun float spd();
+ #!- Starting sample index, normalized 0-1.
+ fun float spd(float _spd);
+ fun float oct();
+ #!- Octaviation index, if greater than zero, lowers the effective fund frequency by attenuating odd-numbered sine bursts. whole numbers are full octaves. fractions transpositional.
+ fun float oct(float _oct);
+ fun float band();
+ #!- Bandwidth (in -6db) expressed in Hz. The bandwidth determines the rate of exponential decay throughout the sineburst, before the enveloping is applied.
+ fun float band(float _band);
+ fun float ris();
+ #!- Rise of sinusoid burst (in seconds)
+ fun float ris(float _ris);
+ fun float dec();
+ #!- Decay of the sinusoid burst (in seconds).
+ fun float dec(float _dec);
+ fun float dur();
+ #!- OVerall duration of sinusoid burst (in seconds).
+ fun float dur(float _dur);
+}
+#!- Adds artificial foldover to an audio signal
+#!-
+#!- Primarily created for use with Decimator.
+class Fold extends UGen {
+ fun float incr();
+ #!- Increment
+ fun float incr(float _incr);
+}
+#!- A short title describing the module
+#!-
+#!- This is a description of the entire module. This is not a real module. This description should be a comprehensive sumary of what this function does.
+#!-
+#!- Inside the Lua table, this is expressed as a multiline string, however it does not adhere to the tradtional 80 column rule found in programming.
+#!-
+#!- Write as much text as needed here...
+#!- FM oscilator pair with linear interpolation
+class Fosc extends UGen {
+ #!- Wavetable to read from. Note: the size of this table must be a power of 2.
+ fun void init(ftbl _tbl);
+ fun float freq();
+ #!- Frequency (in Hz)
+ fun float freq(float _freq);
+ fun float amp();
+ #!- Amplitude (typically a value between 0 and 1).
+ fun float amp(float _amp);
+ fun float car();
+ #!- Carrier frequency, expressed as a ratio number in C:M ratio. Typically an integer.
+ fun float car(float _car);
+ fun float mod();
+ #!- Modulator frequency, expressed as a ratio number in C:M ratio. Typically an integer.
+ fun float mod(float _mod);
+ fun float indx();
+ #!- Modulation index. Most commercial synthesizers have a range from 0-8, but there's nothing stopping you from going beyond that.
+ fun float indx(float _indx);
+}
+#!- Series of partials from the harmonic series
+#!-
+#!- GBuzz comes from the `buzz` family of Csound opcodes, and is capable of producing a rich spectrum of harmonic content, useful for subtractive synthesis implementation.
+class Gbuzz extends UGen {
+ #!- Soundpipe function table used internally. This should be a sine wave.
+ #!- Phase to start on (in the range 0-1)
+ fun void init(ftbl _ftfloat _iphs);
+ fun float freq();
+ #!- Frequency, in Hertz.
+ fun float freq(float _freq);
+ fun float amp();
+ #!- Amplitude (Typically a value between 0 and 1).
+ fun float amp(float _amp);
+ fun float nharm();
+ #!- Number of harmonics.
+ fun float nharm(float _nharm);
+ fun float lharm();
+ #!- Lowest harmonic present. This should be a whole number integer.
+ fun float lharm(float _lharm);
+ fun float mul();
+ #!- Multiplier. This determines the relative strength of each harmonic.
+ fun float mul(float _mul);
+}
+#!- Generate a composite waveform of sinusoids
+#!- Reads from a wav file
+#!-
+#!- This will only load as many samples as the length of the ftable.
+#!- Gaussian distribution
+#!- A series of line segments
+#!- An implementation of the Padsynth Algorithm by Paul Nasca.
+#!-
+#!- This is a basic implemenation of the padsynth algorithm. More information can be found here:
+#!-
+#!- http://zynaddsubfx.sourceforge.net/doc/PADsynth/PADsynth.htm
+#!-
+#!- This gen routine requires libfftw, and is not compiled by default. See config.mk for more info.
+#!-
+#!-
+#!- Generates a user defined random number distribution.
+#!- Scrambles phase of ftable.
+#!- This gen routine will copy the ftable, apply an FFT, apply
+#!- a random phase, and then do an inverse FFT. This effect
+#!- is ideal for creating pad-like sounds.
+#!- generates a sampled sinusoid
+#!- Waveform as a sum of harmonically related sine waves
+#!- generates a sampled triangle wave
+#!- A series of exponential segments
+#!- Hilbert transform
+#!-
+class Hilbert extends UGen {
+}
+#!- Reads from standard input.
+#!-
+#!- Expects type of SPFLOAT, which by default is a float. If the input data is larger than the number of samples, you will get a complaint about a broken pipe (but it will still work). If there is no input data from STDIN, it will hang.
+#!-
+#!-
+#!-
+#!-
+#!- The expected use case of sp_in is to utilize pipes from the commandline, like so:
+#!-
+#!-
+#!-
+#!-
+#!- cat /dev/urandom | ./my_program
+#!-
+#!-
+#!-
+#!-
+#!- Assuming my_program is using sp_in, this will write /dev/urandom (essentially white noise) to an audio file.
+class In extends UGen {
+}
+#!- Trigger-based Incrementor
+#!- When triggered, this module will increment and decrement a value bounded between a min
+#!- and max. Initially, this was designed for the specific use case of interfacing with the
+#!- griffin knob.
+class Incr extends UGen {
+ #!- Initial value
+ fun void init(float _val);
+ fun float step();
+ #!- Step value to increment by.
+ fun float step(float _step);
+ fun float min();
+ #!- Minimum value
+ fun float min(float _min);
+ fun float max();
+ #!- Maximum value
+ fun float max(float _max);
+}
+#!- John Chowning reverberator
+#!-
+#!- This is was built using the JC reverb implentation found in FAUST. According to the source code, the specifications for
+#!- this implementation were found on an old SAIL DART backup tape.
+#!-
+#!- This class is derived from the CLM JCRev function, which is based on the use of
+#!- networks of simple allpass and comb delay filters. This class implements three series
+#!- allpass units, followed by four parallel comb filters, and two decorrelation delay lines in
+#!- parallel at the output.
+class Jcrev extends UGen {
+}
+#!- A signal with random fluctuations
+#!-
+#!- This is useful for emulating jitter found in analogue equipment.
+class Jitter extends UGen {
+ fun float amp();
+ #!- The amplitude of the line. Will produce values in the range of (+/-)amp.
+ fun float amp(float _amp);
+ fun float cpsMin();
+ #!- The minimum frequency of change in Hz.
+ fun float cpsMin(float _cpsMin);
+ fun float cpsMax();
+ #!- The maximum frequency of change in Hz.
+ fun float cpsMax(float _cpsMax);
+}
+#!- Produce a line segment with linear slope
+#!- This will generate a line from value A to value B in given amount of time.
+#!- When it reaches it's target, it will stay at that value.
+class Line extends UGen {
+ fun float a();
+ #!- Inital point.
+ fun float a(float _a);
+ fun float dur();
+ #!- Duration (in seconds)
+ fun float dur(float _dur);
+ fun float b();
+ #!- End point
+ fun float b(float _b);
+}
+#!- A linear predictive coding filter.
+#!- This module is a wrapper for the open source library openlpc, which implements
+#!- the LPC10 audio codec optimized for speech signals. This module takes in an
+#!- input signal, downsamples it, and produces a decoded LPC10 audio signal, which
+#!- has a similar sound to that of a speak and spell. In this context, the LPC
+#!- signal is meant to be more of a audio effect rather than a utility for
+#!- communication.
+#!-
+#!- Because the LPC10 encoder
+#!- relies on frames for encoding, the output signal has a few milliseconds of
+#!- delay. The delay can be calculated in seconds as (framesize * 4) / samplerate.
+#!-
+#!- In addition to using the LPC as a decoder/encoder, this module can also be
+#!- set to synth mode. Instead of reading from an input signal, the LPC can
+#!- instead read from parameters set directly in a scaled ftable.
+#!-
+class Lpc extends UGen {
+ #!- Sets the frame size for the encoder.
+ fun void init(int _framesize);
+}
+#!- 3-pole (18 db/oct slope) Low-Pass filter with resonance and tanh distortion
+class Lpf18 extends UGen {
+ fun float cutoff();
+ #!- Filter cutoff frequency, in Hertz
+ fun float cutoff(float _cutoff);
+ fun float res();
+ #!- Resonance. Expects a value in the range 0-1. A value of 1.0 will self oscillate at the cutoff frequency.
+ fun float res(float _res);
+ fun float dist();
+ #!- Distortion amount.
+ fun float dist(float _dist);
+}
+#!- A randomly open or closed `maybe gate`
+#!-
+#!- It takes in a trigger, and then it will randomly decide to turn the gate on or not. One particular application for maygate is to arbitrarily turn on/off sends to effects. One specific example of this could be a randomized reverb throw on a snare.
+class Maygate extends UGen {
+ fun float prob();
+ #!- Probability of maygate. This is a value between 0-1. The closer to 1, the more likely the maygate will let a signal through.
+ fun float prob(float _prob);
+ fun int mode();
+ #!- If mode is nonzero, maygate will output one sample triggers instead of a gate signal.
+ fun int mode(int _mode);
+}
+#!- Metronome
+#!-
+#!- Metro produces a series of 1-sample ticks at a regular rate. Typically, this is used alongside trigger-driven modules.
+class Metro extends UGen {
+ fun float freq();
+ #!- The frequency to repeat.
+ fun float freq(float _freq);
+}
+#!- Phase-locked vocoder.
+#!-
+#!- Mincer is a phase-locked vocoder. It has the ability to play back an audio
+#!- file loaded into an ftable like a sampler would. Unlike a typical sampler, mincer allows
+#!- time and pitch to be controlled separately.
+class Mincer extends UGen {
+ #!- ftable containing an audio file.
+ #!- FFT window size. Should be a power of 2.
+ fun void init(ftbl _ftint _winsize);
+ fun float time();
+ #!- Position in time. When non-changing it will do a spectral freeze of a the current point in time.
+ fun float time(float _time);
+ fun float amp();
+ #!- Amplitude.
+ fun float amp(float _amp);
+ fun float pitch();
+ #!- Pitch ratio. A value of. 1 normal, 2 is double speed, 0.5 is halfspeed, etc.
+ fun float pitch(float _pitch);
+}
+#!- Resonance filter used for modal synthesis
+#!-
+#!- Plucked and bell sounds can be created by passing an impulse through a combination of modal filters.
+class Mode extends UGen {
+ fun float freq();
+ #!- Resonant frequency of the filter.
+ fun float freq(float _freq);
+ fun float q();
+ #!- Quality factor of the filter. Roughly equal to q/freq.
+ fun float q(float _q);
+}
+#!- Low pass resonant filter based on the Moogladder filter
+class Moogladder extends UGen {
+ fun float freq();
+ #!- Filter cutoff frequency.
+ fun float freq(float _freq);
+ fun float res();
+ #!- Filter resonance
+ fun float res(float _res);
+}
+#!- White noise generator
+class Noise extends UGen {
+ fun float amp();
+ #!- Amplitude. (Value between 0-1).
+ fun float amp(float _amp);
+}
+#!- Nanosamp: a tiny sampler built for Soundpipe
+#!-
+#!- A nanosamp file is comprised of a mono audio file and an ini file. Nanosamp is geared towards percussive and found sound sample players, and is intended to be combined with soundpipe modules.
+#!-
+#!- The ini file contains mappings that correspond to the audio file. Such an entry would look like this:
+#!-
+#!-
+#!-
+#!- [keyword]
+#!-
+#!- pos = 2.3
+#!-
+#!- size = 3
+#!-
+#!-
+#!- </pre>
+#!- In this instance, an entry called `keyword` has been made, starting at 2.3 seconds in the
+#!- audio file, with a length of 3 seconds. An example file oneart.ini has been created in the
+#!- examples folder.
+#!-
+#!- The SoundPipe implementation of nanosamp will automatically index the entries
+#!- in the order they appear in the INI file and must be selected this way by changing the index
+#!- parameter. Soundpipe will only select the new entry when the trigger input is a non-zero value.
+#!-
+class Nsmp extends UGen {
+ #!- ftbl of the audio file. It should be mono.
+ #!- samplerate.
+ #!- ini file.
+ fun void init(ftbl _ftint _srstring _init);
+ fun int index();
+ #!- This is an optional parameter. These values are always set to a value by default, and can be set after the init function has been called.
+ fun int index(int _index);
+}
+#!- Table-lookup oscilator with linear interpolation
+class Osc extends UGen {
+ #!- Wavetable to read from. Note: the size of this table must be a power of 2.
+ #!- Initial phase of waveform, expects a value 0-1
+ fun void init(ftbl _tblfloat _phase);
+ fun float freq();
+ #!- Frequency (in Hz)
+ fun float freq(float _freq);
+ fun float amp();
+ #!- Amplitude (typically a value between 0 and 1).
+ fun float amp(float _amp);
+}
+#!- Wavetable morphing oscillator
+#!-
+#!- This is an oscillator with linear interpolation that is capable of morphing
+#!- between an arbitrary number of wavetables.
+class Oscmorph extends UGen {
+ #!- An array of ftables to read from. Note: the size of these tables must be a power of 2 (and the same size as well).
+ #!- Number of ftbls
+ #!- Initial phase of waveform, expects a value 0-1
+ fun void init(ftbl[] _tblint _nftfloat _phase);
+ fun float freq();
+ #!- Frequency (in Hz)
+ fun float freq(float _freq);
+ fun float amp();
+ #!- Amplitude (typically a value between 0 and 1).
+ fun float amp(float _amp);
+ fun float wtpos();
+ #!- Wavetable position. (scaled 0-1)
+ fun float wtpos(float _wtpos);
+}
+#!- Panner
+class Pan2 extends UGen {
+ fun int type();
+ #!- Panning type. 0 = equal power, 1 = square root, 2 = linear,
+ #!- 3 = alternative equal power. Values outside this range will wrap.
+ fun int type(int _type);
+ fun float pan();
+ #!- Panning. A value of -1 is hard left, and a value of 1 is hard right, and 0 is center.
+ fun float pan(float _pan);
+}
+#!- Stereo Panner
+class Panst extends UGen {
+ fun int type();
+ #!- Panning type. 0 = equal power, 1 = square root, 2 = linear,
+ #!- 3 = alternative equal power. Values outside this range will wrap.
+ fun int type(int _type);
+ fun float pan();
+ #!- Panning. A value of -1 is hard left, and a value of 1 is hard right.
+ fun float pan(float _pan);
+}
+#!- Parametric Equalizer
+#!- This is an implementation of Zoelzer's parametric equalizer filter.
+class Pareq extends UGen {
+ fun float fc();
+ #!- Center frequency in peak mode, corner frequency in shelving mode.
+ fun float fc(float _fc);
+ fun float v();
+ #!- Amount at which the center frequency value shall be increased or decreased. A value of 1 is a flat response.
+ fun float v(float _v);
+ fun float q();
+ #!- Q of the filter. sqrt(0.5) is no resonance.
+ fun float q(float _q);
+ fun float mode();
+ #!- EQ mode. 0 = peak, 1 = low shelving, 2 = high shelving
+ fun float mode(float _mode);
+}
+#!- An extreme time-stretching algorithm by Paul Nasca Octavian
+#!- This is an implementation of the popular paulstretch algorithm used for time
+#!- stretching an audio signal to create ambient textures. Ideally, this algorithm
+#!- is best used for stretching signals by very very long amounts.
+#!-
+#!- This version of paulstretch will take an ftable and loop through it, make
+#!- it an ideal means for creating sustained pads.
+class Paulstretch extends UGen {
+ #!- ftable containing audio data
+ #!- Window size, in seconds.
+ #!- Stretch factor, 1.0 is no stretch.
+ fun void init(ftbl _ftfloat _windowsizefloat _stretch);
+}
+#!- Casio-style phase distortion with `pivot point` on the X axis
+#!- This module is designed to emulate the classic phase distortion synthesis technique.
+#!- From the mid 90's. The technique reads the first and second halves of the ftbl
+#!- at different rates in order to warp the waveform. For example, pdhalf can
+#!- smoothly transition a sinewave into something approximating a sawtooth wave.
+class Pdhalf extends UGen {
+ fun float amount();
+ #!- Amount of distortion, within the range [-1, 1]. 0 is no distortion.
+ fun float amount(float _amount);
+}
+#!- Peak limiter
+#!- This is a simple peak limiting algorithm, based off code from the Stanford
+#!- Music-424 class.
+class Peaklim extends UGen {
+ fun float atk();
+ #!- Attack time, in seconds
+ fun float atk(float _atk);
+ fun float rel();
+ #!- Release time, in seconds
+ fun float rel(float _rel);
+ fun float thresh();
+ #!- Threshold, in dB
+ fun float thresh(float _thresh);
+}
+#!- A stereo phaser
+#!-
+#!- This is a stereo phaser, generated from Faust code taken from the
+#!- Guitarix project.
+class Phaser extends UGen {
+ fun float MaxNotch1Freq();
+ #!- Between 20 and 10000
+ fun float MaxNotch1Freq(float _MaxNotch1Freq);
+ fun float MinNotch1Freq();
+ #!- Between 20 and 5000
+ fun float MinNotch1Freq(float _MinNotch1Freq);
+ fun float Notch_width();
+ #!- Between 10 and 5000
+ fun float Notch_width(float _Notch_width);
+ fun float NotchFreq();
+ #!- Between 1.1 and 4
+ fun float NotchFreq(float _NotchFreq);
+ fun float VibratoMode();
+ #!- 1 or 0
+ fun float VibratoMode(float _VibratoMode);
+ fun float depth();
+ #!- Between 0 and 1
+ fun float depth(float _depth);
+ fun float feedback_gain();
+ #!- Between 0 and 1
+ fun float feedback_gain(float _feedback_gain);
+ fun float invert();
+ #!- 1 or 0
+ fun float invert(float _invert);
+ fun float level();
+ #!- -60 to 10 dB
+ fun float level(float _level);
+ fun float lfobpm();
+ #!- Between 24 and 360
+ fun float lfobpm(float _lfobpm);
+}
+#!- Normalized sawtooth wave from 0 to 1
+#!-
+#!- Phasors are often used when building table-lookup oscillators.
+class Phasor extends UGen {
+ #!- initial phase
+ fun void init(float _iphs);
+ fun float freq();
+ #!- Frequency.
+ fun float freq(float _freq);
+}
+#!- Pink pinknoise generator
+class Pinknoise extends UGen {
+ fun float amp();
+ #!- Amplitude. (Value between 0-1).
+ fun float amp(float _amp);
+}
+#!- Pitch detection using AMDF method.
+#!- Pitchamdf tracks the pitch of signal using the AMDF (Average Magnitude Difference Function) method of
+#!- Pitch following.
+class Pitchamdf extends UGen {
+ #!- Minimum expected frequency to detect
+ #!- Maximum expected frequency to detect
+ fun void init(float _minfloat _max);
+}
+#!- Karplus-Strong plucked string instrument.
+class Pluck extends UGen {
+ #!- Sets the initial frequency. This frequency is used to allocate all the buffers needed for the delay. This should be the lowest frequency you plan on using.
+ fun void init(float _ifreq);
+ fun float freq();
+ #!- Variable frequency. Values less than the initial
+ #!- frequency (ifreq) will be doubled until it is greater than or equal to ifreq.
+ fun float freq(float _freq);
+ fun float amp();
+ #!- Amplitude
+ fun float amp(float _amp);
+}
+#!- Portamento-style control signal smoothing
+#!-
+#!- Useful for smoothing out low-resolution signals and applying glissando to filters.
+class Port extends UGen {
+ #!-
+ fun void init(float _htime);
+ fun float htime();
+ #!-
+ fun float htime(float _htime);
+}
+#!- High-precision table-lookup posc3ilator with cubic interpolation
+class Posc3 extends UGen {
+ #!- Wavetable to read from. Note: the size of this table must be a power of 2.
+ fun void init(ftbl _tbl);
+ fun float freq();
+ #!- Frequency (in Hz)
+ fun float freq(float _freq);
+ fun float amp();
+ #!- Amplitude (typically a value between 0 and 1).
+ fun float amp(float _amp);
+}
+#!- A simple progress bar for the commandline
+#!-
+#!- Mostly ideal for offline renderings and programs with finite length. Escape characters are used to show/hide the cursor. Interruption before finishing may cause the cursor to disappear.
+class Progress extends UGen {
+ fun int nbars();
+ #!-
+ fun int nbars(int _nbars);
+ fun int skip();
+ #!- How many samples to skip before checking
+ fun int skip(int _skip);
+}
+#!- Simple rhythmic notation gate generator
+#!-
+#!- Creates a gate using a simple rhythmic notation system called prop. When it reaches the end of the prop string, it will loop back to the beginning.
+#!-
+#!- Prop has a few basic rules:
+#!-
+#!- 1. A '+' denotes a on. A '-' denotes an off (rest). They each have an equal duration of a quarter note.
+#!-
+#!- 2. On and off values can be strung together to create equally spaced gates: +-+--
+#!-
+#!- 3. When notes are enclosed in parantheses '()' following a positive integer N, their duration is reduced N times: ++2(+-)
+#!-
+#!- 4. When notes are enclosed in brackets '[]' following a positive integer N, their duration is scaled by a factor of N: ++2[++]
+#!-
+#!- 5. Parenthesis and brackets can be nested: +- 2[3(+2(++)+)]2(++)
+#!-
+class Prop extends UGen {
+ #!- Prop string to be parsed.
+ fun void init(string _str);
+ fun float bpm();
+ #!- Beats per minute of the prop string.
+ fun float bpm(float _bpm);
+}
+#!- Time-domain pitch shifter.
+class Pshift extends UGen {
+ fun float shift();
+ #!- Pitch shift (in semitones), range -24/24.
+ fun float shift(float _shift);
+ fun float window();
+ #!- Window size (in samples), max 10000
+ fun float window(float _window);
+ fun float xfade();
+ #!- Crossfade (in samples), max 10000
+ fun float xfade(float _xfade);
+}
+#!- Track pitch of a signal.
+#!- Ptrack is a pitch tracker, based on an algorithm originally created by
+#!- Miller Puckette.
+class Ptrack extends UGen {
+ #!- hop size.
+ #!- Number of peaks.
+ fun void init(int _ihopsizeint _ipeaks);
+}
+#!- Random number generator with hold time.
+#!- Randh is loosely based off of the Csound opcode randomh. The design is equivalent
+#!- to scaled noise sent through a classic sample and hold module.
+class Randh extends UGen {
+ fun float min();
+ #!- Minimum value to use.
+ fun float min(float _min);
+ fun float max();
+ #!- Maximum value to use.
+ fun float max(float _max);
+ fun float freq();
+ #!- Frequency of randomization (in Hz)
+ fun float freq(float _freq);
+}
+#!- Line segments between random values within a range
+class Randi extends UGen {
+ fun float min();
+ #!- Minimum value
+ fun float min(float _min);
+ fun float max();
+ #!- Maximum value
+ fun float max(float _max);
+ fun float cps();
+ #!- Frequency to change values.
+ fun float cps(float _cps);
+ fun float mode();
+ #!- Randi mode (not yet implemented yet.)
+ fun float mode(float _mode);
+}
+#!- Random values within a range
+class Random extends UGen {
+ fun float min();
+ #!- Minimum value.
+ fun float min(float _min);
+ fun float max();
+ #!- Maximum value.
+ fun float max(float _max);
+}
+#!- A second-order resonant filter. NOTE: The output for reson appears to be very hot, so take caution when using this module.
+class Reson extends UGen {
+ fun float freq();
+ #!- Center frequency of the filter, or frequency position of the peak response.
+ fun float freq(float _freq);
+ fun float bw();
+ #!- Bandwidth of the filter.
+ fun float bw(float _bw);
+}
+#!- Signal reverser
+#!-
+#!- Reverse will store a signal inside a buffer and play it back reversed.
+class Reverse extends UGen {
+ #!- Delay time in seconds.
+ fun void init(float _delay);
+}
+#!- 8 FDN stereo reverb
+class Revsc extends UGen {
+ fun float feedback();
+ #!- Value between 0-1 that sets feedback value. The larger the value, the longer the decay.
+ fun float feedback(float _feedback);
+ fun float lpfreq();
+ #!- low pass cutoff frequency.
+ fun float lpfreq(float _lpfreq);
+}
+#!- RMS-averaged signal amplitude
+#!-
+#!- Perform `root-mean-square` on a signal to get overall amplitude of a signal. The output signal looks similar to that of a classic VU meter.
+class Rms extends UGen {
+ fun float ihp();
+ #!- Half-power point (in Hz) of internal lowpass filter. This parameter is fixed at 10Hz and is not yet mutable.
+ fun float ihp(float _ihp);
+}
+#!- Trigger based beat-repeat stuttering effect
+#!-
+#!- When the input is a non-zero value, rpt will load up the buffer and loop a certain number of times. Speed and repeat amounts can be set with the sp_rpt_set function.
+class Rpt extends UGen {
+ #!- Maximum delay duration in seconds. This will set the buffer size.
+ fun void init(float _maxdur);
+}
+#!- Random spline curve generator
+#!- This is a function that generates random spline curves. This signal generator
+#!- is ideal for control signals. Curves are quite smooth when cps_min is not
+#!- too different from cps_max. When the range of these two is big,
+#!- some discontinuity may occur. Due to the interpolation, the output
+#!- may be greater than the range values.
+class Rspline extends UGen {
+ fun float min();
+ #!- Minimum range.
+ fun float min(float _min);
+ fun float max();
+ #!- Maximum range
+ fun float max(float _max);
+ fun float cps_min();
+ #!-
+ fun float cps_min(float _cps_min);
+ fun float cps_max();
+ #!-
+ fun float cps_max(float _cps_max);
+}
+#!- Classic sample and hold
+class Samphold extends UGen {
+}
+#!- Soft clip saturating distortion, based on examples from Abel/Berners' Music 424 course at Stanford.
+class Saturator extends UGen {
+ fun float drive();
+ #!- Input gain into the distortion section, in decibels. Controls overall amount of distortion.
+ fun float drive(float _drive);
+ fun float dcoffset();
+ #!- Constant linear offset applied to the signal. A small offset will introduce odd harmonics into the distoration spectrum, whereas a zero offset will have only even harmonics.
+ fun float dcoffset(float _dcoffset);
+}
+#!- Bipolar Scale
+#!-
+#!- This module scales from unipolar [0, 1] to another range defined by min and max.
+class Scale extends UGen {
+ fun float min();
+ #!- Minimum value to scale to.
+ fun float min(float _min);
+ fun float max();
+ #!- Maximum value to scale to.
+ fun float max(float _max);
+}
+#!- Delays a signal by a number of samples.
+class Sdelay extends UGen {
+ #!- Size of delay (in samples)
+ fun void init(float _size);
+}
+#!- Yet another slice-based sample player.
+#!- This module takes in an audio buffer and a table with slice points.
+class Slice extends UGen {
+ #!- A table containing slice points, in samples
+ #!- The buffer containing the audio samples.
+ fun void init(ftbl _valsftbl _buf);
+ fun float id();
+ #!- Value position.
+ fun float id(float _id);
+}
+#!- Smooth variable delay line without varispeed pitch.
+#!- Smooth delay is based off the sdelay module in Faust. The smooth delay
+#!- algorithm involves a double delay line. Any time the delay time changes,
+#!- the delay time of buffer not heard changes, then is crossfaded to
+#!- that buffer.
+class Smoothdelay extends UGen {
+ #!- Maximum delay time (in seconds)
+ #!- interpolation time (in samples)
+ fun void init(float _maxdelint _interp);
+ fun float feedback();
+ #!-
+ fun float feedback(float _feedback);
+ fun float del();
+ #!-
+ fun float del(float _del);
+}
+#!- Stream a Soundpipe Audio File
+#!- Similar to sp_diskin, sp_spa will stream a file in the internal soundpipe
+#!- audio format. Such a format is useful for instances where you need to read
+#!- audio files, but can't use libsndfile.
+class Spa extends UGen {
+ #!- Filename of SPA file
+ fun void init(string _filename);
+}
+#!- Writes signal to spa file.
+class Sparec extends UGen {
+ #!- Filename to write to
+ fun void init(string _filename);
+}
+#!- String resonator filter
+class Streson extends UGen {
+ fun float freq();
+ #!- Fundamental frequency of string.
+ fun float freq(float _freq);
+ fun float fdbgain();
+ #!- Feedback amount (value between 0-1)
+ fun float fdbgain(float _fdbgain);
+}
+#!- Switch between two signals
+#!-
+#!- By default, the incoming first signal is selected. When triggered, the output signal will switch to the other signal.
+class Switch extends UGen {
+}
+#!- Table
+#!- Read through an sp_ftbl with linear interpolation.
+#!-
+class Tabread extends UGen {
+ #!- A properly allocated table (using a function like sp_gen_file).
+ #!- 1 = scaled index, 0 = unscaled index
+ fun void init(ftbl _ftfloat _mode);
+ fun float index();
+ #!- index position, either scaled or unscaled with mode parameter
+ fun float index(float _index);
+ fun float offset();
+ #!- Offset from beginning of ftable. If the mode is scaled, then it is in range 0-1, other wise it is the index position.
+ fun float offset(float _offset);
+ fun float wrap();
+ #!- Enable wraparound. 1 = on; 0 = 0ff.
+ fun float wrap(float _wrap);
+}
+#!- Triggerable classic ADSR envelope
+class Tadsr extends UGen {
+ fun float atk();
+ #!- Attack time
+ fun float atk(float _atk);
+ fun float dec();
+ #!- Decay time
+ fun float dec(float _dec);
+ fun float sus();
+ #!- Sustain Level
+ fun float sus(float _sus);
+ fun float rel();
+ #!- release
+ fun float rel(float _rel);
+}
+#!- A high talkbox emulation, simular to a vocoder.
+#!- This is the talkbox plugin ported from the MDA plugin suite. In many ways,
+#!- this Talkbox functions like a vocoder: it takes in a source signal (usually
+#!- speech), which then excites an excitation signal
+#!- (usually a harmonically rich signal like a saw wave). This particular algorithm
+#!- uses linear-predictive coding (LPC), making speech intelligibility better
+#!- than most vocoder implementations.
+class Talkbox extends UGen {
+ fun float quality();
+ #!- Quality of the talkbox sound. 0=lowest fidelity. 1=highest fidelity
+ fun float quality(float _quality);
+}
+#!- Record a signal to an ftable.
+#!- This module will write audio-rate signals to a preallocated soundpipe ftable.
+#!- Every time record is enabled, it will got back to index 0 overwrite any
+#!- previous information that was on it.
+class Tblrec extends UGen {
+ #!-
+ fun void init(ftbl _bar);
+}
+#!- Emulation of the Roland TB-303 filter
+class Tbvcf extends UGen {
+ fun float fco();
+ #!- Filter cutoff frequency
+ fun float fco(float _fco);
+ fun float res();
+ #!- Resonance
+ fun float res(float _res);
+ fun float dist();
+ #!- Distortion. Value is typically 2.0; deviation from this can cause stability issues.
+ fun float dist(float _dist);
+ fun float asym();
+ #!- Asymmetry of resonance. Value is between 0-1
+ fun float asym(float _asym);
+}
+#!- Trigger divider.
+#!- This module will take in a trigger signal, and output a trigger signal
+#!- every N times.
+#!-
+#!- For instance, when N = 3:
+#!-
+#!- in: * * * * * * * * *
+#!-
+#!- out * * *
+#!-
+class Tdiv extends UGen {
+ fun float num();
+ #!- Triggers every N times.
+ fun float num(float _num);
+ fun float offset();
+ #!- Offset amoutn.
+ fun float offset(float _offset);
+}
+#!- Trigger based linear AHD envelope generator
+class Tenv extends UGen {
+ fun float atk();
+ #!- Attack time, in seconds.
+ fun float atk(float _atk);
+ fun float hold();
+ #!- Hold time, in seconds.
+ fun float hold(float _hold);
+ fun float rel();
+ #!- Release time, in seconds.
+ fun float rel(float _rel);
+}
+#!- Linear 2-stage Attack/Release envelope generator
+#!-
+#!- This envelope takes 2 triggers. When triggered once,
+#!- the envelope will rise to 1 according to the attack time. When triggered again, it will decay to 0 according to
+#!- the decay time.
+class Tenv2 extends UGen {
+ fun float atk();
+ #!- Attack time (in seconds).
+ fun float atk(float _atk);
+ fun float rel();
+ #!- Release time (in seconds).
+ fun float rel(float _rel);
+}
+#!- Trigger based exponential AHD envelope generator.
+#!- This envelope generator emulates the exponential behavior of analogue
+#!- envelope generators by passing a gate signal (whose duration is specified via
+#!- the hold parameter) through a one-pole filter, whose filter coefficeints are
+#!- calculated in terms of tau.
+#!-
+class Tenvx extends UGen {
+ fun float atk();
+ #!- Tau attack time, in seconds. Must be non-zero.
+ fun float atk(float _atk);
+ fun float hold();
+ #!- Hold time, in seconds. The duration of the gate signal.
+ fun float hold(float _hold);
+ fun float rel();
+ #!- Tau release time, in seconds. Must be non-zero.
+ fun float rel(float _rel);
+}
+#!- A triggerable gate.
+class Tgate extends UGen {
+ fun float time();
+ #!- Duration of the gate (in seconds)
+ fun float time(float _time);
+}
+#!- Trigger generator for signals that cross a given threshold.
+class Thresh extends UGen {
+ fun float thresh();
+ #!- Threshold level
+ fun float thresh(float _thresh);
+ fun int mode();
+ #!- Sets when to detect theshold crossings. 0 = from below. 1 = from above. 2 = from above/below
+ fun int mode(int _mode);
+}
+#!- Tap-tempo like timer
+#!-
+#!- When triggered, timer will begin an internal stopwatch until it is triggered again.
+#!- The output of the timer will be the time elapsed in seconds.
+class Timer extends UGen {
+}
+#!- Similar to in, tin reads SPFLOATs (by default, this is a 4 byte binary float) from standard input every time it is triggered. behaves like a sample and hold, retaining the previous value (initial set to 0) until triggered.
+class Tin extends UGen {
+}
+#!- First-order recursive lowpass filter
+class Tone extends UGen {
+ fun float hp();
+ #!- The response curve's half power point (aka cutoff frequency).
+ fun float hp(float _hp);
+}
+#!- Triggered random number generator.
+class Trand extends UGen {
+ fun float min();
+ #!- Minimum value to use.
+ fun float min(float _min);
+ fun float max();
+ #!- Maximum value to use.
+ fun float max(float _max);
+}
+#!- This module creates a series of line segments.
+class Tseg extends UGen {
+ #!- Beginning value.
+ fun void init(float _ibeg);
+ fun float end();
+ #!- End parameter to go to.
+ fun float end(float _end);
+ fun float dur();
+ #!- duration to rise to (in seconds).
+ fun float dur(float _dur);
+ fun float type();
+ #!- The type of line, which determines slope of line
+ fun float type(float _type);
+}
+#!- Function table looper
+#!-
+#!- TSeq runs through values in an ftable. It will change values when the trigger input is a non-zero value, and wrap around when it reaches the end.
+class Tseq extends UGen {
+ #!- An ftable of values
+ fun void init(ftbl _ft);
+ fun int shuf();
+ #!- When shuf is non-zero, randomly pick a value rather than cycle through sequentially.
+ fun int shuf(int _shuf);
+}
+#!- Delay line with cubic interpolation
+class Vdelay extends UGen {
+ #!- The maximum delay time, in seconds.
+ fun void init(float _maxdel);
+ fun float del();
+ #!- Delay time (in seconds) that can be changed during performance. This value must not exceed the maximum delay time.
+ fun float del(float _del);
+ fun float feedback();
+ #!- Amount of feedback in delay line. Should be in range 0-1.
+ fun float feedback(float _feedback);
+}
+#!- A vocal tract physical model.
+#!-
+#!- Based on the Pink Trombone algorithm by Neil Thapen, Voc implements a physical
+#!- model of the vocal tract glottal pulse wave. The tract model is based on the
+#!- classic Kelly-Lochbaum
+#!- segmented cylindrical 1d waveguide model, and the glottal pulse wave is a
+#!- LF glottal pulse model.
+#!-
+#!- The soundpipe source code for Voc is generated via ctangle, one half of the
+#!- literate documentation system known CWEB. The CWEB are maintained in a
+#!- separate repository. They are hosted on github here:
+#!- http://www.github.com/paulbatchelor/voc
+#!-
+#!- This documentation is a stub. For a full overview on proper usage, consult
+#!- the `Top-level functions` section of the documented code, a copy of which
+#!- can be found at the Voc project page pbat.ch/proj/voc, or generate the PDF
+#!- from the github page described above.
+class Voc extends UGen {
+}
+#!- 16-band channel vocoder
+class Vocoder extends UGen {
+ fun float atk();
+ #!- Attack time . (Range 0.001 and 0.5 seconds)
+ fun float atk(float _atk);
+ fun float rel();
+ #!- Release time
+ fun float rel(float _rel);
+ fun float bwratio();
+ #!- Coeffecient to adjust the bandwidth of each band (0.1 - 2)
+ fun float bwratio(float _bwratio);
+}
+#!- Simple Time-stretching from repeating wavecyles
+#!- This module looks for zero-crossings and repeats them by a integer factor.
+#!- While a crude means for time stretching, it is a very aesthetically pleasing
+#!- effect to use on sounds and often produces a `wet` sound.
+#!-
+#!- The waveset algorithm was originally created by Trevor Wishart for the Composer
+#!- Desktop Project (CDP), and was then ported to Csound.
+class Waveset extends UGen {
+ #!- Length of buffer (in seconds).
+ fun void init(float _ilen);
+ fun float rep();
+ #!- Number of repeats.
+ fun float rep(float _rep);
+}
+#!- Reads a mono WAV file.
+#!-
+#!- This module reads a mono WAV file from disk. It uses the public-domain
+#!- dr_wav library for decoding, so it can be a good substitute for libsndfile.
+class Wavin extends UGen {
+ #!- Filename
+ fun void init(string _filename);
+}
+#!- Writes a mono signal to a WAV file.
+#!- This module uses the public-domain dr_wav library to write WAV files
+#!- to disk. This module is ideal for instances where GPL-licensed libsndfile
+#!- cannot be used for legal reasons.
+class Wavout extends UGen {
+ #!- The filename of the output file.
+ fun void init(string _filename);
+}
+#!- Analogue model of the Korg 35 Lowpass Filter
+#!-
+#!- Original port done by Will Pirkle:
+#!- http://www.willpirkle.com/Downloads/AN-5Korg35_V3.pdf
+#!-
+class Wpkorg35 extends UGen {
+ fun float cutoff();
+ #!- Filter cutoff
+ fun float cutoff(float _cutoff);
+ fun float res();
+ #!- Filter resonance (should be between 0-2)
+ fun float res(float _res);
+ fun float saturation();
+ #!- Filter saturation.
+ fun float saturation(float _saturation);
+}
+#!- 8 FDN stereo zitareverb algorithm, imported from Faust.
+class Zitarev extends UGen {
+ fun float in_delay();
+ #!- Delay in ms before reverberation begins.
+ fun float in_delay(float _in_delay);
+ fun float lf_x();
+ #!- Crossover frequency separating low and middle frequencies (Hz).
+ fun float lf_x(float _lf_x);
+ fun float rt60_low();
+ #!- Time (in seconds) to decay 60db in low-frequency band.
+ fun float rt60_low(float _rt60_low);
+ fun float rt60_mid();
+ #!- Time (in seconds) to decay 60db in mid-frequency band.
+ fun float rt60_mid(float _rt60_mid);
+ fun float hf_damping();
+ #!- Frequency (Hz) at which the high-frequency T60 is half the middle-band's T60.
+ fun float hf_damping(float _hf_damping);
+ fun float eq1_freq();
+ #!- Center frequency of second-order Regalia Mitra peaking equalizer section 1.
+ fun float eq1_freq(float _eq1_freq);
+ fun float eq1_level();
+ #!- Peak level in dB of second-order Regalia-Mitra peaking equalizer section 1
+ fun float eq1_level(float _eq1_level);
+ fun float eq2_freq();
+ #!- Center frequency of second-order Regalia Mitra peaking equalizer section 2.
+ fun float eq2_freq(float _eq2_freq);
+ fun float eq2_level();
+ #!- Peak level in dB of second-order Regalia-Mitra peaking equalizer section 2
+ fun float eq2_level(float _eq2_level);
+ fun float mix();
+ #!- 0 = all dry, 1 = all wet
+ fun float mix(float _mix);
+ fun float level();
+ #!- Output scale factor (in dB).
+ fun float level(float _level);
+}
+```
projects / gwion.git / commitdiff