From 809a12c7135063898b488a3584da84ce9b0fdbdd Mon Sep 17 00:00:00 2001 From: =?utf8?q?J=C3=A9r=C3=A9mie=20Astor?= Date: Wed, 23 Mar 2022 08:58:00 +0100 Subject: [PATCH] again --- docs/Reference/Plugins/Analys.mdr | 47 + docs/Reference/Plugins/Emoji.mdr | 10 + docs/Reference/Plugins/File.mdr | 11 + docs/Reference/Plugins/Lsys.mdr | 13 + docs/Reference/Plugins/Machine.mdr | 15 + docs/Reference/Plugins/Math.mdr | 49 + docs/Reference/Plugins/Modules.mdr | 36 + docs/Reference/Plugins/Sndfile.mdr | 6 + docs/Reference/Plugins/Soundpipe.mdr | 1559 ++++++++++++++++++++++++++ docs/Reference/Plugins/Std.mdr | 25 + docs/Reference/Plugins/TinySF.mdr | 12 + docs/Reference/Plugins/Tuple.mdr | 19 + docs/Reference/Plugins/list | 14 + 13 files changed, 1816 insertions(+) create mode 100644 docs/Reference/Plugins/Analys.mdr create mode 100644 docs/Reference/Plugins/Emoji.mdr create mode 100644 docs/Reference/Plugins/File.mdr create mode 100644 docs/Reference/Plugins/Lsys.mdr create mode 100644 docs/Reference/Plugins/Machine.mdr create mode 100644 docs/Reference/Plugins/Math.mdr create mode 100644 docs/Reference/Plugins/Modules.mdr create mode 100644 docs/Reference/Plugins/Sndfile.mdr create mode 100644 docs/Reference/Plugins/Soundpipe.mdr create mode 100644 docs/Reference/Plugins/Std.mdr create mode 100644 docs/Reference/Plugins/TinySF.mdr create mode 100644 docs/Reference/Plugins/Tuple.mdr create mode 100644 docs/Reference/Plugins/list diff --git a/docs/Reference/Plugins/Analys.mdr b/docs/Reference/Plugins/Analys.mdr new file mode 100644 index 00000000..ac464471 --- /dev/null +++ b/docs/Reference/Plugins/Analys.mdr @@ -0,0 +1,47 @@ +# Analys + +compiler generated documentation + +```gwion +#!+ Analys +class FFT extends UGen { + fun int init(int size); + fun void compute(); +} +class ANA extends Object { + var @internal @_fft; + late FFT @fft; + var @internal @fn; + fun float compute(); + fun FFT fft(); + fun FFT fft(FFT arg); +} +class Centroid extends ANA { +} +class Spread extends ANA { +} +class Skewness extends ANA { +} +class Kurtosis extends ANA { +} +class RMS extends ANA { +} +class Rolloff extends ANA { + fun float percent(); + fun float percent(float arg); +} +class Freq extends ANA { +} +class ASC extends ANA { +} +class ASS extends ANA { +} +class FC extends Object { + var @internal @vector; + fun float[] compute(); + fun ANA add(ANA arg); + fun ANA rem(ANA arg); +} +operator FC => (ANA, FC); +operator FC =< (ANA, FC); +``` diff --git a/docs/Reference/Plugins/Emoji.mdr b/docs/Reference/Plugins/Emoji.mdr new file mode 100644 index 00000000..e63dabba --- /dev/null +++ b/docs/Reference/Plugins/Emoji.mdr @@ -0,0 +1,10 @@ +# Emoji + +compiler generated documentation + +```gwion +#!+ Emoji +class Emoji extends string { + operator auto new(string arg); +} +``` diff --git a/docs/Reference/Plugins/File.mdr b/docs/Reference/Plugins/File.mdr new file mode 100644 index 00000000..375b54cd --- /dev/null +++ b/docs/Reference/Plugins/File.mdr @@ -0,0 +1,11 @@ +# File + +compiler generated documentation + +```gwion +#!+ File +class File:[ module ] extends Event { +} +operator File @scan (); +operator @ctor (File); +``` diff --git a/docs/Reference/Plugins/Lsys.mdr b/docs/Reference/Plugins/Lsys.mdr new file mode 100644 index 00000000..2571e449 --- /dev/null +++ b/docs/Reference/Plugins/Lsys.mdr @@ -0,0 +1,13 @@ +# Lsys + +compiler generated documentation + +```gwion +#!+ Lsys +class Lsys extends Object { + fun void parse(int ordstring str); + fun void reset(); + fun int size(); + fun string get(); +} +``` diff --git a/docs/Reference/Plugins/Machine.mdr b/docs/Reference/Plugins/Machine.mdr new file mode 100644 index 00000000..cb61bc4e --- /dev/null +++ b/docs/Reference/Plugins/Machine.mdr @@ -0,0 +1,15 @@ +# Machine + +compiler generated documentation + +```gwion +#!+ Machine +fun static int add(string filename); +fun static int remove(int id); +fun static int replace(int idstring filename); +fun static int[] shreds(); +fun static int check(string code); +fun static int compile(string code); +fun static int compile_replace(string codestring filename); +fun static int pass(string[] passes); +``` diff --git a/docs/Reference/Plugins/Math.mdr b/docs/Reference/Plugins/Math.mdr new file mode 100644 index 00000000..3eb23cb8 --- /dev/null +++ b/docs/Reference/Plugins/Math.mdr @@ -0,0 +1,49 @@ +# Math + +compiler generated documentation + +```gwion +#!+ Math +fun static int abs(int value); +fun static int rand(); +fun static int rand2(int minint max); +fun static float randf(); +fun static float rand2f(float value1float value2); +fun static float fabs(float value); +fun static float srand(float value); +fun static float sgn(float value); +fun static float sin(float value); +fun static float cos(float value); +fun static float tan(float value); +fun static float asin(float value); +fun static float acos(float value); +fun static float atan(float value); +fun static float sinh(float value); +fun static float cosh(float value); +fun static float tanh(float value); +fun static float asinh(float value); +fun static float acosh(float value); +fun static float atanh(float value); +fun static float sqrt(float value); +fun static float exp(float value); +fun static float log(float value); +fun static float log2(float value); +fun static float log10(float value); +fun static float floor(float value); +fun static float ceil(float value); +fun static float round(float value); +fun static float trunc(float value); +fun static float isinf(float value); +fun static float isnan(float value); +fun static float hypot(float value1float value2); +fun static float atan2(float value1float value2); +fun static float pow(float value1float value2); +fun static float fmod(float value1float value2); +fun static float remainder(float value1float value2); +fun static float min(float value1float value2); +fun static float max(float value1float value2); +operator float ** (float, float); +operator float ** (int, float); +operator float ** (float, int); +operator int ** (int, int); +``` diff --git a/docs/Reference/Plugins/Modules.mdr b/docs/Reference/Plugins/Modules.mdr new file mode 100644 index 00000000..df5dd287 --- /dev/null +++ b/docs/Reference/Plugins/Modules.mdr @@ -0,0 +1,36 @@ +# Modules + +compiler generated documentation + +```gwion +#!+ Modules +class SinOsc extends UGen { + fun void init(int size); + fun void init(int sizefloat phase); + fun float freq(); + fun float freq(float freq); + fun float amp(); + fun float amp(float amp); +} +class Gain extends UGen { + fun float gain(); + fun float gain(float arg0); +} +class Impulse extends UGen { + fun float next(); + fun float next(float arg0); +} +class FullRect extends UGen { +} +class HalfRect extends UGen { +} +class Step extends UGen { + fun float next(); + fun float next(float arg0); +} +class ZeroX extends UGen { +} +typedef Bltriangle TriOsc; +typedef Blsquare SquareOsc; +typedef Blsaw SawOsc; +``` diff --git a/docs/Reference/Plugins/Sndfile.mdr b/docs/Reference/Plugins/Sndfile.mdr new file mode 100644 index 00000000..0d8931a6 --- /dev/null +++ b/docs/Reference/Plugins/Sndfile.mdr @@ -0,0 +1,6 @@ +# Sndfile + +compiler generated documentation + +```gwion +``` diff --git a/docs/Reference/Plugins/Soundpipe.mdr b/docs/Reference/Plugins/Soundpipe.mdr new file mode 100644 index 00000000..2aaedac6 --- /dev/null +++ b/docs/Reference/Plugins/Soundpipe.mdr @@ -0,0 +1,1559 @@ +# 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 +#!- +#!- +#!- +#!- 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); +} +``` diff --git a/docs/Reference/Plugins/Std.mdr b/docs/Reference/Plugins/Std.mdr new file mode 100644 index 00000000..a4d1522d --- /dev/null +++ b/docs/Reference/Plugins/Std.mdr @@ -0,0 +1,25 @@ +# Std + +compiler generated documentation + +```gwion +#!+ Std +fun static int clamp(int valueint minint max); +fun static float clampf(float valuefloat minfloat max); +fun static float scale(float valuefloat srcminfloat srcmaxfloat dstminfloat dstmax); +fun static int setenv(string keystring value); +fun static int atoi(string keyRef:[ int ] idx); +fun static float atof(string keyRef:[ int ] idx); +fun static int atoi(string key); +fun static float atof(string key); +fun static int system(string value); +fun static string getenv(string value); +fun static float mtof(float value); +fun static float ftom(float value); +fun static float powtodb(float value); +fun static float rmstodb(float value); +fun static float dbtopow(float value); +fun static float dbtorms(float value); +fun static float dbtolin(float value); +fun static float lintodb(float value); +``` diff --git a/docs/Reference/Plugins/TinySF.mdr b/docs/Reference/Plugins/TinySF.mdr new file mode 100644 index 00000000..f9fa011c --- /dev/null +++ b/docs/Reference/Plugins/TinySF.mdr @@ -0,0 +1,12 @@ +# TinySF + +compiler generated documentation + +```gwion +#!+ TinySF +class TinySF extends UGen { + operator auto new(string file); + fun void noteOn(int notefloat vel); + fun void noteOff(int note); +} +``` diff --git a/docs/Reference/Plugins/Tuple.mdr b/docs/Reference/Plugins/Tuple.mdr new file mode 100644 index 00000000..1a0862d9 --- /dev/null +++ b/docs/Reference/Plugins/Tuple.mdr @@ -0,0 +1,19 @@ +# Tuple + +compiler generated documentation + +```gwion +#!+ Tuple +class Tuple extends Object { +} +primitive @Undefined; +operator @ctor (Tuple); +operator Tuple @scan (); +operator => (Object, Tuple); +operator $ (Object, Tuple); +operator @implicit (Object, Tuple); +operator @array (int, Tuple); +primitive Unpack; +operator @ctor (Unpack); +operator => (Object, Unpack); +``` diff --git a/docs/Reference/Plugins/list b/docs/Reference/Plugins/list new file mode 100644 index 00000000..fb00685a --- /dev/null +++ b/docs/Reference/Plugins/list @@ -0,0 +1,14 @@ +Soundpipe +TinySF +Analys +Emoji +File +Lsys +Machine +Math +Modules +Sndfile +Soundpipe +Std +TinySF +Tuple -- 2.43.0