ugen
A converter UGen that takes an audio-rate input and produces a control-rate output by means of sampling.
All pass delay line with cubic interpolation.
All pass delay line with cubic interpolation.
The input signal.
The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)
Delay time in seconds.
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
All pass delay line with linear interpolation.
All pass delay line with linear interpolation.
The input signal.
The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)
Delay time in seconds.
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
All pass delay line with no interpolation.
All pass delay line with no interpolation.
The input signal.
The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)
Delay time in seconds.
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency.
A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency.
Implements the formula: (root / freq).pow(exp)
Higher frequencies are normally perceived as louder, therefore AmpComp
outputs lower values for them. For example, with default parameters, the pitch
C4 (frequency 262 Hz) produces the base factor of 1.0, whereas a pitch one
octave up, C5 (or 523 Hz) produces a factor of 0.793719 (an attenuation of -2
dB).
An alternative is AmpCompA that better models the bell-shaped equal loudness
contours of the hearing system. Especially note that the output of this UGen can
become very high for frequencies much lower than the root parameter.
the frequency in Hertz for which to determine the compensation factor
the base frequency corresponding to a compensation factor of 1.0
the exponent determines how steep the compensation curve decreases for increasing frequencies. In general, the louder a signal is played, the shallower the equal loudness contours become.
A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency.
A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency. It uses the A-weighting curve that is based on the Fletcher-Munson curve for rather low volume sounds (40 phon).
Only the freq parameter can be modulated, the other parameters are read at
initialization time only.
the frequency in Hertz for which to determine the compensation factor
the root frequency in Hertz, relative to which the curve is calculated. This is usually lowest expected frequency. (init-time only)
amplitude at the minimum point of the curve. This is
the factor output when freq is approx. 2512 Hz.
(init-time only)
amplitude at the root frequency of the curve. This is
the factor output when freq == root . (init-time
only)
An amplitude follower UGen.
An amplitude follower UGen. Tracks and reports the peak amplitude of its input signal.
input signal to be analyzed
60 dB convergence time in for following attacks, in seconds
60 dB convergence time in for following decays, in seconds
A UGen that finds the largest value across the channels of its input signal, providing both the value and the index.
A UGen that finds the smallest value across the channels of its input signal, providing both the value and the index.
An all pass filter UGen.
An all pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
input signal to be processed.
cutoff frequency.
the reciprocal of Q, hence bandwidth / cutoffFreq.
An band pass filter UGen.
An band pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
input signal to be processed.
center frequency.
the bandwidth in octaves between -3 dB frequencies
An band stop (reject) filter UGen.
An band stop (reject) filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
input signal to be processed.
center frequency.
the bandwidth in octaves between -3 dB frequencies
A 2nd order (12db per oct roll-off) resonant high pass filter UGen.
A 2nd order (12db per oct roll-off) resonant high pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
input signal to be processed.
cutoff frequency.
the reciprocal of Q, hence bandwidth / cutoffFreq.
A high shelf equalizer UGen.
A high shelf equalizer UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
input signal to be processed.
cutoff frequency.
the reciprocal of the slope S (Shell boost/cut slope).
When S = 1 , the shelf slope is as steep as it can be
and remain monotonically increasing or decreasing gain
with frequency. The shelf slope, in dB/octave, remains
proportional to S for all other values for a fixed
freq/sample-rate and gain .
boost/cut at the cutoff frequency (in decibels).
A 2nd order (12db per oct roll-off) resonant low pass filter UGen.
A 2nd order (12db per oct roll-off) resonant low pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
input signal to be processed.
cutoff frequency.
the reciprocal of Q, hence bandwidth / cutoffFreq.
A low shelf equalizer UGen.
A low shelf equalizer UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
input signal to be processed.
cutoff frequency.
the reciprocal of the slope S (Shell boost/cut slope).
When S = 1 , the shelf slope is as steep as it can be
and remain monotonically increasing or decreasing gain
with frequency. The shelf slope, in dB/octave, remains
proportional to S for all other values for a fixed
freq/sample-rate and gain .
boost/cut at the cutoff frequency (in decibels).
A second order band pass filter UGen.
A second order band pass filter UGen.
input signal to be filtered
center frequency in Hertz
reciprocal of Q. The Q (or quality) is conventionally defined as center-frequency / bandwidth, meaning that rq = bandwidth / center-frequency. A higher Q or lower rq produces a steeper filter.
a special fixed band-pass filter UGen.
An parametric equalizer UGen.
An parametric equalizer UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
input signal to be processed.
center frequency.
the reciprocal of Q, hence bandwidth / cutoffFreq.
boost/cut at the center frequency (in decibels).
A second order band reject (notch) filter UGen.
A second order band reject (notch) filter UGen.
input signal to be filtered
center frequency in Hertz
reciprocal of Q. The Q (or quality) is conventionally
defined as center-frequency / bandwidth, meaning that rq
= bandwidth / center-frequency. A higher Q or
lower rq produces a steeper filter. Too high values for
rq may blow the filter up!
a special fixed band-reject filter UGen.
An equal power two channel balancing UGen.
An equal power two channel balancing UGen. It takes a left and right input
signal and attenuates them according to the pos value, producing again a
stereophonic output.
The left input signal
The right input signal
The balance position from -1 (left only, right muted)
to +1 (right only, left muted). The curve follows an
equal power law, such that
left.squared + right.squared == 1 , e.g. at the middle
position 0 , both channels are multiplied with factor
sqrt(0.5) = 0.707 = -3 dB .
An autocorrelation based beat tracker UGen.
An autocorrelation based beat tracker UGen.
The underlying model assumes 4/4, but it should work on any isochronous beat structure, though there are biases to 100-120 bpm; a fast 7/8 may not be tracked in that sense. There are four control-rate outputs, being ticks at quarter, eighth and sixteenth level from the determined beat, and the current detected tempo. Note that the sixteenth note output won't necessarily make much sense if the music being tracked has swing; it is provided just as a convenience.
This beat tracker determines the beat, biased to the mid-tempo range by weighting functions. It does not determine the measure level, only a tactus. It is also slow reacting, using a 6 second temporal window for its autocorrelation maneuvres. Don't expect human musician level predictive tracking.
On the other hand, it is tireless, relatively general (though obviously best at transient 4/4 heavy material without much expressive tempo variation), and can form the basis of computer processing that is decidedly faster than human.
Warning: This UGen only works properly at 44.1 or 48.0 kHz.
the output (buffer) of an FFT UGen which transforms the audio input to track. The expected size of FFT is 1024 for 44100 and 48000 sampling rate, and 2048 for double those. No other sampling rates are supported.
If this argument is greater than 0.5, the tracker will lock at its current periodicity and continue from the current phase. Whilst it updates the model's phase and period, this is not reflected in the output until lock goes back below 0.5. Can be control-rate modulated.
A template matching beat tracker UGen.
A template matching beat tracker UGen. This beat tracker is based on exhaustively testing particular template patterns against feature streams; the testing takes place every 0.5 seconds. The two basic templates are a straight (groove=0) and a swung triplet (groove=1) pattern of 16th notes; this pattern is tried out at scaling factors corresponding to the tempi from 60 to 180 bpm. This is the cross-correlation method of beat tracking. A majority vote is taken on the best tempo detected, but this must be confirmed by a consistency check after a phase estimate. Such a consistency check helps to avoid wild fluctuating estimates, but is at the expense of an additional half second delay. The latency of the beat tracker with default settings is thus at least 2.5 seconds; because of block-based amortisation of calculation, it is actually around 2.8 seconds latency for a 2.0 second temporal window.
This beat tracker is designed to be flexible for user needs; you can try out different window sizes, tempo weights and combinations of features. However, there are no guarantees on stability and effectiveness, and you will need to explore such parameters for a particular situation.
The UGen has six outputs corresponding to beat-tick, eighth-tick, groove-tick, tempo, phase, and groove. Warning: it reads from input control bus instead of taking a regular control input signal as its first argument!
index of a control bus to read from. the number of
channels of that bus are expected to match the
numChannels argument. To track a particular audio
signal, analyse it first into numChannels features,
that is onset-detection-triggers, as generated by
Onsets , and write the trigger-output to this control
bus.
(scalar) How many features (ie how many control bus channels) are provided (init-time only)
(scalar) Size of the temporal window desired (2.0 to 3.0 seconds models the human temporal window). You might use longer values for stability of estimate at the expense of reactiveness.
(scalar) Relates to how many different phases to test. At the default of 0.02 seconds, 50 different phases spaced by those 0.02 seconds would be tried out for 60bpm; 16 would be trialed for 180 bpm. Larger phaseSpacing means more tests and more CPU cost.
If this argument is greater than 0.5, the tracker will lock at its current periodicity and continue from the current phase. Whilst it updates the model's phase and period, this is not reflected in the output until lock goes back below 0.5. Can be control-rate modulated.
(scalar) Use (-2.5) for flat weighting of tempi, (-1.5) for compensation weighting based on the number of events tested (because different periods allow different numbers of events within the temporal window). If an integer from 0 upwards is given, this is specifying the ID of a buffer containing 120 frames which represent individual tempo weights; tempi go from 60 to 179 bpm in steps of one bpm, so you make sure the buffer has 120 frames.
A two dimensional Ambisonics B-format encoder UGen for a two-channel input signal.
A two dimensional Ambisonics B-format encoder UGen for a two-channel input signal. ambisonic B-format. It places the two input channels at opposite poles of the 2D (W, X, Y) Ambisonics field. It is equivalent to:
PanB2(_, inA, azimuth, level) + PanB2(_, inB, azimuth + 1, level)the first (monophonic) input signal, which will appear opposite to the first second signal
the second (monophonic) input signal, which will appear opposite to the first input signal
Band Limited ImPulse generator UGen.
Band Limited ImPulse generator UGen. All harmonics have equal amplitude. This is the equivalent of 'buzz' in Music-N languages. It is capable of cross-fading during a control period block if the number of harmonics changes, avoiding audible pops.
Fundamental frequency in Hertz
Number of harmonics. This will be automatically limited to avoid aliasing.
A noise generator UGen whose spectrum falls off in power by 6 dB per octave.
A noise generator UGen whose spectrum falls off in power by 6 dB per octave.
The values produced by this UGen lie between -1 and +1 , the RMS is approx.
-4.8 dB (the same as white noise).
Not actually a UGen input, this argument produces a
multiplication of the output by this factor. A
multi-channel mul argument will cause the generation
of multiple independent noise generators.
All pass delay line with cubic interpolation which uses a buffer for its internal memory.
All pass delay line with cubic interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
Buffer id.
The input signal.
Delay time in seconds.
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
All pass delay line with linear interpolation which uses a buffer for its internal memory.
All pass delay line with linear interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
Buffer id.
The input signal.
Delay time in seconds.
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
All pass delay line with no interpolation which uses a buffer for its internal memory.
All pass delay line with no interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
Buffer id.
The input signal.
Delay time in seconds.
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
Returns the current number of channels of the buffer at the provided index.
Returns the current number of channels of the buffer at the provided index.
Buffer id.
Comb delay line with cubic interpolation which uses a buffer for its internal memory.
Comb delay line with cubic interpolation which uses a buffer for its internal memory.
Buffer id.
The input signal.
Delay time in seconds.
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower. Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
Comb delay line with linear interpolation which uses a buffer for its internal memory.
Comb delay line with linear interpolation which uses a buffer for its internal memory.
Buffer id.
The input signal.
Delay time in seconds.
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower. Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
Comb delay line with no interpolation which uses a buffer for its internal memory.
Comb delay line with no interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
Buffer id.
The input signal.
Delay time in seconds.
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
Simple delay line with cubic interpolation which uses a buffer for its internal memory.
Simple delay line with cubic interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
Buffer id.
The input signal.
Delay time in seconds.
Simple delay line with linear interpolation which uses a buffer for its internal memory.
Simple delay line with linear interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
Buffer id.
The input signal.
Delay time in seconds.
Simple delay line with no interpolation which uses a buffer for its internal memory.
Simple delay line with no interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
Buffer id.
The input signal.
Delay time in seconds.
Returns the current duration of the buffer at the provided index.
Returns the current duration of the buffer at the provided index.
Buffer id.
Returns the number of allocated frames of the buffer at the provided index.
Returns the number of allocated frames of the buffer at the provided index.
Buffer id.
A UGen that finds the largest value in a buffer, providing both the value and the index.
A UGen that finds the largest value in a buffer, providing both the value and the index.
identifier of the buffer containing the values to analyze. It treats multi-channel buffers as monophonic, and indices will refer to the de-interleaved frames and channels.
when closed (zero), holds the last output value.
A UGen that finds the smallest value in a buffer, providing both the value and the index.
A UGen that finds the smallest value in a buffer, providing both the value and the index.
identifier of the buffer containing the values to analyze. It treats multi-channel buffers as monophonic, and indices will refer to the de-interleaved frames and channels.
when closed (zero), holds the last output value.
Returns a ratio by which the playback of the buffer at the provided index is to be scaled relative to the current sample rate of the server.
Returns a ratio by which the playback of the buffer at the provided index is to be scaled relative to the current sample rate of the server.
buffer sample rate / server sample rate
Buffer id.
A UGen which reads the content of a buffer, using an index pointer.
A UGen which reads the content of a buffer, using an index pointer.
Warning: if the supplied bufID refers to a buffer whose number of channels
differs from numChannels , the UGen will fail silently.
An alternative to BufRd is PlayBuf . While PlayBuf plays through the
buffer by itself, BufRd only moves its read point by the index input and
therefore has no pitch input. PlayBuf uses cubic interpolation, while BufRd
has variable interpolation. PlayBuf can determine the end of the buffer and
issue a done-action.
number of channels that the buffer will be. Since this is an integer constant, a change in the number of channels must be reflected by creating different SynthDefs.
the identifier of the buffer to use
audio rate frame-index into the buffer. Can be fractional.
1 to enable looping, 0 to disable looping. this can be modulated.
1 for no interpolation, 2 for linear, and 4 for cubic interpolation. (init-time only)
Returns the buffer's current sample rate.
Returns the buffer's current sample rate.
Buffer id.
Returns the current number of allocated samples in the Buffer at the provided index.
Returns the current number of allocated samples in the Buffer at the provided index. A sample is not the same as a frame (compare with BufFrames ); a frame includes the samples in each channel of the buffer. Only for a mono buffer are samples the same as frames.
samples = frames * numChannels
Buffer id.
A UGen that writes a signal to a buffer, using an index pointer.
A UGen that writes a signal to a buffer, using an index pointer.
Warning: if the supplied bufID refers to a buffer whose number of channels
differs from those of the input signal, the UGen will fail silently.
An alternative to BufWr is RecordBuf . While RecordBuf advances the index
into the buffer by itself, BufWr only moves its write point by the index
input, making it possible to adjust the writing speed or to access the buffer in
a non-linear way. RecordBuf can determine the end of the buffer and issue a
done-action.
input signal to record
the identifier of the buffer to use
audio rate frame-index into the buffer.
1 to enable looping, 0 to disable looping. this can be modulated.
A graph element that produces an integer sequence from zero until the number-of-channels of the input element.
A graph element that produces an integer sequence from zero until the number-of-channels of the input element.
the element whose indices to produce
A UGen to test for infinity, not-a-number (NaN), and denormal numbers.
A UGen to test for infinity, not-a-number (NaN), and denormal numbers. Its output is as follows: 0 = a normal float, 1 = NaN, 2 = infinity, and 3 = a denormal. According to the post settings it will print the information to the console along with a given identifier.
the signal to be tested
an identifier showing up with the values in the console
One of three post modes: 0 = no posting; 1 = post a line for every bad value; 2 = post a line only when the floating-point classification changes (e.g., normal -> NaN and vice versa)
This is a UGen like Ramp , but it always takes the shortest way around a
defined circle, wrapping values where appropriate.
This is a UGen like Ramp , but it always takes the shortest way around a
defined circle, wrapping values where appropriate. This can be useful when
smoothing panning signals for speaker rings, for instance in Vector Base
Amplitude Panning.
The signal to be smoothed.
Ramp duration in seconds
The lower wrap value
The upper wrap value
A scalar (init-time) UGen that fills the contents of a buffer with zeroes.
A UGen that constrains a signal to a given range, by limiting values outside the range to the range margins.
A UGen that constrains a signal to a given range, by limiting values outside
the range to the range margins. This is similar to the clip2 binary operator
but permits both a lower range value lo and an upper range value hi .
Mathematically, this is equivalent to in.max(lo).min(hi).
Be aware that there seems to be an initialization bug. The following crashes,
indicating that Clip.ar outputs a zero initially:
{{ play { val bar = Integrator.ar(DC.ar(0), coeff = 0.999) val foo = Clip.ar(bar, lo = 1.0, hi = 44100.0) // .max(1.0) val sum = RunningSum.ar(DC.ar(0), length = foo) sum.poll(1, "sum") () } }}
input signal to constrain
lower margin of clipping
upper margin of clipping
A noise generator UGen whose values are either -1 or +1 (before being
multiplied by mul ).
A noise generator UGen whose values are either -1 or +1 (before being
multiplied by mul ). This produces the maximum energy (an RMS of 0 dB) for the
least peak to peak amplitude.
Not actually a UGen input, this argument produces a
multiplication of the output by this factor. A
multi-channel mul argument will cause the generation
of multiple independent noise generators.
A UGen that randomly filters an input trigger signal.
A UGen that randomly filters an input trigger signal. When a trigger arrives,
it may pass with a probability given by the prob argument.
the input triggers to filter
the probability between zero (no trigger passed) and 1 (all triggers passed)
The argument order is different from its sclang counterpart.
Comb delay line with cubic interpolation.
Comb delay line with cubic interpolation.
The input signal.
The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)
Delay time in seconds.
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
Comb delay line with linear interpolation.
Comb delay line with linear interpolation.
The input signal.
The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)
Delay time in seconds.
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
Comb delay line with no interpolation.
Comb delay line with no interpolation.
The input signal.
The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)
Delay time in seconds.
Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.
A compressor, expander, limiter, gate and ducking UGen.
A compressor, expander, limiter, gate and ducking UGen. This dynamic processor uses a hard-knee characteristic. All of the thresholds and ratios are given as direct values, not in decibels!
The signal to be compressed / expanded / gated.
The signal whose amplitude controls the processor. Often the same as in, but one may wish to apply equalization or delay to it to change the compressor character (side-chaining), or even feed a completely different signal, for instance in a ducking application.
Control signal amplitude threshold, which determines the break point between slopeBelow and slopeAbove. Usually 0..1. The control signal amplitude is calculated using RMS.
Slope of the amplitude curve below the threshold. If this slope > 1.0, the amplitude will drop off more quickly the softer the control signal gets; when the control signal is close to 0 amplitude, the output should be exactly zero -- hence, noise gating. Values < 1.0 are possible, but it means that a very low-level control signal will cause the input signal to be amplified, which would raise the noise floor.
Slope of the amplitude curve above the threshold. Values < 1.0 achieve compression (louder signals are attenuated); > 1.0, you get expansion (louder signals are made even louder). For 3:1 compression, you would use a value of 1/3 here.
The amount of time it takes for the amplitude adjustment to kick in fully. This is usually pretty small, not much more than 10 milliseconds (the default value). I often set it as low as 2 milliseconds (0.002).
The amount of time for the amplitude adjustment to be released. Usually a bit longer than attack; if both times are too short, you can get some (possibly unwanted) artifacts.
A scalar constant used as an input to a UGen.
A scalar constant used as an input to a UGen. These constants are stored in a separate table of the synth graph.
A UGen that reports the server's current control period in seconds.
A UGen that reports the server's current control period in seconds. This is
equivalent to the reciprocal of ControlRate
A UGen that reports the server's current control rate.
A UGen that reports the server's current control rate. This is equivalent to
the reciprocal of ControlDur
A ControlOutProxy is similar to a UGenOutProxy in that it denotes an output channel of a control UGen.
A ControlOutProxy is similar to a UGenOutProxy in that it denotes an output channel of a control UGen. However it refers to a control-proxy instead of a real control ugen, since the proxies are synthesized into actual ugens only at the end of a synth graph creation, in order to clump several controls together. ControlOutProxy instance are typically returned from the ControlProxyFactory class, that is, using the package implicits, from calls such as "myControl".kr.
A UGen that performs a convolution with an continuously changing kernel.
A UGen that performs a convolution with an continuously changing kernel. If the
kernel is static or must only change occasionally, Convolution2 will be a more
CPU friendly alternative. The process introduces a delay of
frameSize - blockSize .
first operand of the convolution
second operand of the convolution
convolution size in sample frames, which is half of the FFT size. Must be a power of two. There is maximum frame-size of 16384 (if exceeded, the server may crash). (init-time only)
A frequency-domain convolution UGen using a fixed kernel which can be updated by a trigger signal.
A frequency-domain convolution UGen using a fixed kernel which can be updated
by a trigger signal. The delay caused by the convolution when the kernel is a
dirac impulse is equal to frameSize - controlBlockSize , so for a frameSize
of 2048 and a control-block size of 64, this is 1984 sample frames.
the realtime input to be convolved
buffer identifier for the fixed kernel, which may be modulated in combination with the trigger. Even a trigger input of zero is used, upon UGen initialization the kernel must point to a valid buffer, otherwise the UGen aborts.
updates the kernel on a change from non-positive to positive (<= 0 to >0)
size of the kernel. this must be a power of two. the
FFT calculated internally by the UGen has a size of
twice this value. The maximum allowed frameSize is
16384. (init-time only)
A frequency-domain convolution UGen using two linearly interpolated fixed kernels.
A frequency-domain convolution UGen using two linearly interpolated fixed kernels. When a trigger is received, a linear fade will be performed from the previously used kernel (internally stored by the UGen) towards the snapshot of the current kernel content upon receiving the trigger.
The delay caused by the convolution when the kernel is a dirac impulse is equal
to frameSize - controlBlockSize , so for a frameSize of 2048 and a
control-block size of 64, this is 1984 sample frames.
Note: If a trigger is received before the previous fade is complete, the interpolation is broken and the kernel instead jumps straight to one of the two buffers.
the realtime input to be convolved
buffer identifier for the fixed kernel, which may be modulated in combination with the trigger. Even a trigger input of zero is used, upon UGen initialization the kernel must point to a valid buffer, otherwise the UGen aborts.
begins a fade to update the kernel on a change from non-positive to positive (<= 0 to >0).
size of the kernel. this must be a power of two. the
FFT calculated internally by the UGen has a size of
twice this value. The maximum allowed frameSize is
16384. (init-time only)
fade duration expressed as number of convolved blocks.
If the desired duration in seconds is dur , then the
number of periods can be calculated as
fadePeriods = dur * SampleRate.ir / frameSize .
(init-time only)
A UGen for triggered convolution in the time domain.
A UGen for triggered convolution in the time domain.
Warning: This UGen seems currently broken (SC 3.6.3)
the realtime input to be convolved
buffer identifier for the fixed kernel, which may be modulated in combination with the trigger. Even a trigger input of zero is used, upon UGen initialization the kernel must point to a valid buffer, otherwise the UGen aborts.
(init-time only)
A noise generator UGen based on a chaotic function.
A noise generator UGen based on a chaotic function. Output values lie between zero and one. Although this is a deterministic process, it is randomly seeded.
A parameter of the chaotic function with useful values
from just below 1.0 to just above 2.0. Towards 2.0 the
sound crackles. Values greater than 2.01 are not safe,
as the UGen can switch to outputting NaNs. A early more
crackling sound appears with a value of 1.33 .
A linear-interpolating sound generator based on the difference equation:
A linear-interpolating sound generator based on the difference equation:
x[n+1] = a - b * sqrt(abs(x[n]))Iteration frequency in Hertz
Equation variable
Equation variable
Initial value of x
A non-interpolating sound generator based on the difference equation:
A non-interpolating sound generator based on the difference equation:
x[n+1] = a - b * sqrt(abs(x[n]))Iteration frequency in Hertz
Equation variable
Equation variable
Initial value of x
A UGen that creates a constant signal at a given calculation rate.
A UGen that creates a constant signal at a given calculation rate.
constant value to output, fixed at initialisation time. (init-time only)
A digital filter UGen which aims at accurately modeling an analog filter.
A digital filter UGen which aims at accurately modeling an analog filter. It provides low-pass and high-pass modes, and the filter can be overdriven and will self-oscillate at high resonances.
Input signal to filter.
Cutoff frequency in Hertz.
Resonance of the filter. Resonance is minimal at 0.0
and high at 1.0 , above which the filter starts
overdrive and sound saturated (e.g. 1.2 ).
Linear gain applied to the input signal.
The filter can be used in low-pass ( 0 ) or high-pass
( 1 ) mode.
Amount (amplitude) of noise added to the model.
A demand-rate UGen that reads out a buffer.
An integrator UGen with exponential decay of past values.
An integrator UGen with exponential decay of past values. This is essentially
the same as Integrator except that instead of supplying the coefficient
directly, it is calculated from a 60 dB decay time. This is the time required
for the integrator to lose 99.9 % of its value or -60dB.
Note: This should not be confused with Lag which does not overshoot due to
integration, but asymptotically follows the input signal.
input signal to be processed
A integrator UGen with controllable attack and release times.
A integrator UGen with controllable attack and release times. While Decay has
a very sharp attack and can produce clicks, Decay2 rounds off the attack by
subtracting one Decay from another. It can be seen as equivalent to
Decay.ar(in, release) - Decay.ar(in, attack)
Note: This should not be confused with LagUD which does not overshoot due to
integration, but asymptotically follows the input signal.
input signal to be processed
A two dimensional Ambisonics B-format decoding UGen.
A two dimensional Ambisonics B-format decoding UGen. It assumes a set of
speakers in a regular polygon. The output channels are in clockwise order. The
position of the first speaker is specified by the orient argument.
the number of output channels to produce
W (first) channel of B-format input signal
X (second) channel of B-format input signal
Y (third) channel of B-format input signal
orientation of the first channel. If zero, the first
channel corresponds to the front vertex of the polygon.
If the polygon does not have an edge at the front but a
vertex, then an orient of 0.5 indicates that the first
channel corresponds to the speaker left of the center.
A UGen that uses an input signal as an index into an octave repeating table of pitch classes.
A UGen that uses an input signal as an index into an octave repeating table of pitch classes. The input is truncated to an integer, and indices wrap around the table and shift octaves as they do.
buffer which contains the steps for each scale degree.
input index signal
number of steps per octave in the scale.
Tap a delay line from a DelTapWr UGen.
Tap a delay line from a DelTapWr UGen.
Buffer where DelTapWr has written signal. Max delay time is based on buffer size.
the current phase of the DelTapWr UGen. This is the output of DelTapWr.
Delay time in seconds.
The kind of interpolation to be used. 1 is none, 2 is linear, 4 is cubic..
Write to a buffer for a DelTapRd UGen
Write to a buffer for a DelTapRd UGen
The buffer to write signal into. Max delay time is
based on buffer size. DelTapWr outputs its current
sample value for use in the phase argument of
DelTapRd .
The input signal.
A UGen that delays the input by 1 audio frame or control period.
A UGen that delays the input by 1 audio frame or control period.
For audio-rate signals the delay is 1 audio frame, and for control-rate signals the delay is 1 control period.
Note: The first value output is not zero but the same as the first input
value! In this respect the UGen behaves different than DelayN .
input to be delayed
A UGen that delays the input by 2 audio frames or control periods.
A UGen that delays the input by 2 audio frames or control periods.
For audio-rate signals the delay is 2 audio frames, and for control-rate signals the delay is 2 control periods.
Warning: the The first value output is zero, while both the second and the
third value output equal the first input value! In this respect the UGen behaves
different than DelayN .
input to be delayed
Simple delay line with cubic interpolation.
Simple delay line with linear interpolation.
Simple delay line with no interpolation.
A UGen which polls results from demand-rate ugens when receiving a trigger.
A UGen which polls results from demand-rate ugens when receiving a trigger.
When there is a trigger at the trig input, a value is demanded from each ugen
in the in input and output. The unit generators in the list should be
demand-rate. When there is a trigger at the reset input, the demand rate ugens
in the list are reset.
Note: By design, a reset trigger only resets the demand ugens; it does not
reset the value at Demand's output. Demand continues to hold its value until the
next value is demanded, at which point its output value will be the first
expected item in the in argument.
Note: One demand-rate ugen represents a single stream of values, so that embedding the same ugen twice calls this stream twice per demand, possibly yielding different values. To embed the same sequence twice, either make sure the ugen is demanded only once, or create two instances of the ugen.
Warning: Demand currently seems to have problems with infinite sequences.
As a workaround use a very large length instead. E.g. instead of
Dbrown(0, 1, inf) use Dbrown(0, 1, 0xFFFFFFFF) !
Warning: Demand seems to have a problem with initial triggers. For
example Demand.kr(Impulse.kr(0), 1) will have a spurious zero value output
first.
trigger. Can be any signal. A trigger happens when the signal changes from non-positive to positive.
a demand-rate signal (possibly multi-channel) which is read at each trigger
trigger. Resets the list of ugens (in) when triggered.
An envelope generator UGen using demand-rate inputs for the envelope segments.
An envelope generator UGen using demand-rate inputs for the envelope segments. For each parameter of the envelope (levels, durations and shapes), values are polled every time a new segment starts.
demand-rate ugen (or other ugen) returning level values
demand-rate ugen (or other ugen) returning duration values
demand-rate ugen (or other ugen) returning shape number for the envelope segment.
demand-rate ugen (or other ugen) returning curvature values. these are used for curveShape segments (shape number 5) and should be zero for other shapes.
a control rate gate: if gate is x >= 1, the ugen runs. if gate is 0 > x > 1, the ugen is released at the next level (according to doneAction). if gate is x <= 0, the ugen is sampled and held.
a trigger signal. a trigger occurs when passing from non-positive to positive. when the trigger amplitude is < 1, the input ugens (those that are demand-rated) are reset when the current segment ends. if the trigger amplitude is > 1, the reset is performed immediately.
demand-rate ugen returning level scaling values
demand-rate ugen returning level offset values
demand-rate ugen returning time scaling values
a done action performed when one of the demand-rated series ends
A UGen which determines the index in a buffer at which the value matches a given input signal.
A UGen which determines the index in a buffer at which the value matches a given input signal. If the input value is not found, it outputs -1.
For example, if the buffer contains values 5, 3, 2, 8, and the input signal is
3, the output will be 1. If the input is 3.001, the output will be -1. Unlike
IndexInBetween , this UGen always searches through the entire buffer until the
value is found or the end has been reached (returning -1).
A UGen which detects whether its input signal falls below a given amplitude for a given amount of time (becoming "silent").
A UGen which detects whether its input signal falls below a given amplitude for
a given amount of time (becoming "silent"). A silence is detected if the
absolute sample values of the input remain less than or equal to the amp
threshold for a consecutive amount of time given by the dur argument.
A value of 1 is output when this condition is met, and a value of 0 is
output when the condition is not met (i.e. at least one sample occurs in the
input whose absolute value is greater than amp ). Besides, when the output
changes from zero to one, the doneAction is executed (unless it is doNothing
).
A special case is the initial condition of the UGen: It will begin with an
output value of 0 (no silence detected), even if the input signal is below the
amplitude threshold. It is only after the first input sample rising above the
threshold that the actual monitoring begins and a trigger of 1 or the firing
of the done-action may occur.
input signal to be measured.
minimum amplitude threshold which must be exceeded for the input signal to be considered non-silent. (init-time only)
The duration in seconds for which the input signal must be continuously smaller than or equal to the threshold to be considered silent. (init-time only)
an action to be performed when the output changes from zero to one (silence detected).
A UGen to stream in a signal from an audio file.
A UGen to stream in a signal from an audio file. Continuously plays a longer audio file from disk. This requires a buffer to be preloaded with one buffer size of sound. If loop is set to 1, the file will loop.
Note: The buffer size must be a multiple of (2 * the server's block
size). See Buffer#cue for details.
the amount of channels the file and the buffer will have. This is an Int and hence must be pre-determined. Different SynthDefs must be created for different numbers of channels.
the id of the buffer with the correct number of channels and frames
whether the file should loop when its end is reached
A UGen which writes a signal to a sound file on disk.
A UGen which writes a signal to a sound file on disk. To achieve this efficiently, a buffer is needs to be provides which is used to buffer the incoming signal.
Note: It might be that the buffer size must be a multiple of (2 * the server's block size). We haven't currently verified this, but to be safe, you should make sure this property is met.
The signal output by the UGen represents the number of frames written.
the buffer used internally by the UGen. this number of
frames in the buffer must be a power of two (this is
currently not checked!). The buffer must have been
initialized with a write command whose leaveOpen
argument is true. Note that the number of channels of
the buffer and of the input signal must be the same,
otherwise DiskOut will fail silently (and not write
anything to the file). Warning: Crashes the server
if the number of channels exceeds 32.
the signal to be recorded
A UGen which monitors another UGen to see when it is finished.
A UGen which monitors another UGen to see when it is finished. Some UGens, such
as PlayBuf , RecordBuf , Line , XLine , EnvGen , Linen , BufRd ,
BufWr , DbufRd , and the Buffer delay UGens set a 'done' flag when they are
finished playing. This UGen echoes that flag as an explicit output signal when
it is set to track a particular UGen. When the tracked UGen changes to done, the
output signal changes from zero to one.
the UGen to track
A demand rate UGen printing the current output value of its input to the console when polled.
A demand rate UGen printing the current output value of its input to the console when polled.
the signal you want to poll
a string or symbol to be printed with the polled value (init-time only)
if 1 the polling is active, if 0 it is inactive.
if greater then 0, a "/tr" OSC message is sent back
to the client (similar to SendTrig )
A demand-rate UGen which produces an arithmetic (linear) series.
A demand-rate UGen which produces an arithmetic (linear) series.
The arguments can be constant or any other ugens.
the start value of the series
the incremental step by which the series changes. the step is added to the previous value on each demand.
the number of elements to produces (maybe be infinite)
A UGen generating random impulses with values ranging from 0 to +1 .
A UGen generating random impulses with values ranging from 0 to +1 . The
pulse duration is one sample for audio-rate and one block for control-rate
operation.
The approximate RMS energy is (density/sr).log2 * 3 - 4.8 where sr is the
sample-rate. For example, at 44.1 kHz, a density of 1000 Hz yields an RMS of
approx. -21.2 dB.
the average number of impulses per second
A UGen generating random impulses with values ranging from -1 to +1 .
A UGen which polls results from demand-rate ugens in intervals specified by a duration input.
A UGen which polls results from demand-rate ugens in intervals specified by a
duration input. A value from the level ugen is demanded and output according
to a stream of duration values. When there is a trigger at the reset input, the
level and the dur input are reset.
the provider of time values. Can be a demand-rate ugen or any signal. The next poll is acquired after the previous duration.
a demand-rate ugen providing the output values.
a trigger which resets the dur input (if demand-rated) and the the level input ugen. The reset input may also be a demand-rate ugen, in this case providing a stream of reset times.
a doneAction that is evaluated when the duration stream ends.
The argument order is different from its sclang counterpart.
An envelope generator UGen.
An envelope generator UGen. It uses a break point description in its envelope
input, typically coming from an Env object. The envelope may be re-triggered
using the gate input. Upon start and upon re-triggering, the envelope ,
levelScale , levelBias and timeScale parameters are polled and remain
constant for the duration of the envelope.
To construct a manual envelope without the use of the Env class, the format
should be as follows:
val env = Seq[GE](startLevel, numSegments, releaseNode, loopNode, targetLevel1, duration1, curveType1, curvature1, targetLevel2, duration2, curveType2, curvature2, ...)
Where the curve-type is one of Curve.step.id , Curve.lin.id ,
Curve.exp.id , etc. The curvature values are only relevant for the parametric
curve type. The releaseNode and loopNode parameters are segment indices or
the special value -99 indicating that there are no release or loop segments.
Note: The actual minimum duration of a segment is not zero, but one sample step for audio rate and one block for control rate. This may result in asynchronicity when in two envelopes of different number of levels, the envelope times add up to the same total duration. Similarly, when modulating times, the new time is only updated at the end of the current segment; this may lead to asynchronicity of two envelopes with modulated times.
the description of the envelope break-points. Typically
you pass an instance of Env which will then
automatically expand to the correct format.
triggers the envelope and holds it open while greater
than zero. If the envelope is of fixed duration (e.g.
Env.linen , Env.perc ), the gate argument is used
as a simple trigger. If it contains a sustained segment
(e.g. Env.adsr , Env.asr ), the envelope is held
open until the gate becomes 0, at which point is
released. If gate is less than zero, a release is
enforced with duration -1.0 - gate .
amplitude factor with which the nominal envelope is multiplied.
amplitude offset which is added to the nominal envelope.
time scale factor with which the envelope segment durations are multiplied.
action to be performed when the envelope reaches its end point.
A scalar UGen that generates a single random decimal value, using an
exponential distribution from lo to hi .
A non-interpolating sound generator based on the difference equations:
A non-interpolating sound generator based on the difference equations:
x[n+1] = sin(im * y[n] + fb * x[n]) y[n+1] = (a * y[n] + c) % 2pi
This uses a linear congruential function to drive the phase indexing of a sine wave. For im = 1, fb = 0 , and a = 1 a normal sine wave results.
Iteration frequency in Hertz
Index multiplier amount
Feedback amount
Phase multiplier amount
Phase increment amount
Initial value of x
Initial value of y
A non-interpolating sound generator based on the difference equations:
A non-interpolating sound generator based on the difference equations:
x[n+1] = sin(im * y[n] + fb * x[n]) y[n+1] = (a * y[n] + c) % 2pi
This uses a linear congruential function to drive the phase indexing of a sine wave. For im = 1, fb = 0, and a = 1 a normal sine wave results.
Iteration frequency in Hertz
Index multiplier amount
Feedback amount
Phase multiplier amount
Phase increment amount
Initial value of x
Initial value of y
A non-interpolating sound generator based on the difference equations:
A non-interpolating sound generator based on the difference equations:
x[n+1] = sin(im * y[n] + fb * x[n]) y[n+1] = (a * y[n] + c) % 2pi
This uses a linear congruential function to drive the phase indexing of a sine wave. For im = 1, fb = 0, and a = 1 a normal sine wave results.
Iteration frequency in Hertz
Index multiplier amount
Feedback amount
Phase multiplier amount
Phase increment amount
Initial value of x
Initial value of y
A UGen performing short-time forward fourier transformations.
A UGen performing short-time forward fourier transformations. In order to
properly link the spectral ugens ( PV_... ), you should begin by using the
output of each UGen (which is just the fft buffer identifier), and use that as
buffer input of the next UGen. That way, the UGen graph is correctly sorted.
E.g. IFFT(PV_...(FFT(buf, in))) .
The UGen will initially output zero until the first FFT can be performed. This
is the case after hop * fftSize . Thus for a default fft buffer size of 1024
and a hop of 0.5, and for a default control block size of 64, for the first
1024*0.5/64 = 8 control blocks the UGen will output zero. This also implies that
the first FFT in this case if performed on the first 512 samples of the in
signal (prepended by 512 zeros). In other words, the first 'full' FFT of the
input happens after fftSize/controlBlockSize cycles, no matter what hop size was
chosen.
If you use FFT for performing signal analysis and not phase vocoder effects, make sure you change the window type accordingly.
The buffer to use for writing the FFT to. The size must
be a power of two. Since FFT operates at control rate
(also being a power of two), the buffer should probably
be at least as long as the control block size.
(init-time only)
The time domain signal to be transformed into the spectral domain.
A factor determining the step size between successive FFTs. That is, FFTs are performed every fftSize * hop sample frames. The default of 0.5 means thus a 50% overlap, while a hope of 1.0 means no overlapping. Choosing 0.0 will most likely crash the server! (init-time only)
The window function applied before each FFT is taken.
The default of 0 is a sine window which is good for
phase vocoder applications (using the PV_... UGens).
For analysis applications, you may want to use -1
which is a rectangle window (effectively no windowing)
or 1 which is a Hann window. A Hann window gives
perfect overlap-add reconstruction for a hope size of
0.5 (or 0.25 etc.) (init-time only)
This parameter can be temporarily set to <= 0 to pause the FFT operation.
With the default value of zero, the window size equals the fft size. If you wish to perform zero padding, an explicit window size can be specified. (init-time only)
A phase vocoder UGen that takes a buffer and prepares it to be used in FFT chains, without doing an actual FFT on a signal.
A phase vocoder UGen that takes a buffer and prepares it to be used in FFT chains, without doing an actual FFT on a signal. This is useful if you want to provide a buffer whose content had already been transformed into the Fourier domain.
the identifier of the buffer to use (init-time only)
the hop size for timing triggers (init-time only)
whether the complex buffer content is given in cartesian coordinates (0) or in polar coordinates (1) (init-time only)
A first order filter section UGen.
A sine oscillator UGen using a fast approximation.
A sine oscillator UGen using a fast approximation. It uses a ringing filter and
is less CPU expensive than SinOsc . However, the amplitude of the wave will
vary with frequency. Generally the amplitude will go down when the frequency
rises and it will go up as if the frequency is lowered.
Warning: In the current implementation, the amplitude can blow up if the
frequency is modulated by certain alternating signals (e.g. abruptly by TRand
).
frequency in Hertz
initial phase of the oscillator in radians. This cannot
be modulated. A value of 0.5 Pi means the output
starts at +1. A value of 1.5 Pi means the output
starts at -1, (init-time only)
A graph element that flattens the channels from a nested multi-channel structure.
A graph element that flattens the channels from a nested multi-channel structure.
the element to flatten
A UGen that constrains a signal to a given range, by "folding" values outside the range.
A UGen that constrains a signal to a given range, by "folding" values outside
the range. This is similar to the fold2 binary operator but permits both a
lower range value lo and an upper range value hi .
Folding can be understood as "reflecting" around the boundaries. For example, if the upper margin is 3, then if an input value exceeds 3, the excess is negatively reflected; 3.1 becomes 2.9, 3.2 becomes 2.8, etc. until the lower margin is reached again where another reflection occurs. Likewise, if the lower margin is 1, then if an input value falls below 1, the undershoot is reflected; 0.9 becomes 1.1, 0.8 becomes 1.2, etc. until the upper margin is reached again where another reflection occurs.
input signal to constrain
lower margin of folding
upper margin of folding
A UGen which reads a single sample value from a buffer at a given index.
A UGen which reads a single sample value from a buffer at a given index.
It uses the in argument as index into the buffer, truncating that argument to
an integer. Out-of-range index values are "folded" inside the valid range.
Folding means reflecting the excess at the valid range's boundaries.
For example, if the buffer has four samples, index 4 is wrapped to index 2 (the excess beyond the maximum index of 3 is 4 - 3 = 1, and the excess is folded so that and 3 - 1 = 2), index 5 is folded to index 1, index -1 is folded to index 1, index -2 is folded to index 2, etc.
While designed for monophonic buffers, it works with multi-channel buffers by
treating them as de-interleaved. See the Index UGen for details.
The buffer to read from.
The sample index into the buffer. This is truncated to an integer automatically.
A UGen that generates a set of harmonics around a formant frequency at a given fundamental frequency.
A UGen that generates a set of harmonics around a formant frequency at a given fundamental frequency.
Fundamental frequency in Hertz. Read at control-rate, so if input is audio-rate, it will be sub-sampled.
Formant frequency in Hertz. This determines the overtone(s) most prominently perceived. Read at control-rate, so if input is audio-rate, it will be sub-sampled.
Pulse width frequency in Hertz. Controls the bandwidth
of the formant. Must be greater than or equal to
fundFreq . Read at control-rate, so if input is
audio-rate, it will be sub-sampled.
A FOF-like resonant filter UGen.
A FOF-like resonant filter UGen. Its impulse response is like that of a sine
wave with a Decay2 envelope over it. It is possible to control the attack and
decay times.
Formlet is equivalent to:
Ringz(in, freq, decay) - Ringz(in, freq, attack)
The great advantage to this filter over FOF (Fonction d'onde formantique) is that there is no limit to the number of overlapping grains since the grain is just the impulse response of the filter.
input signal to be filtered
resonant frequency in Hertz
the 60 dB attack time in seconds
the 60 dB decay time in seconds
A UGen that, when triggered, frees a given node.
A UGen that, when triggered, frees enclosing synth.
A UGen that, when triggered, frees enclosing synth. It frees the enclosing synth when the input signal crosses from non-positive to positive.
Note that if the trigger is initially high the UGen will not react. For
example, FreeSelf.kr("foo".kr) will not work if the control is initially 1 .
A work-around is to wrap the input in this case in a Trig object:
FreeSelf.kr(Trig.kr("foo".kr)) . This is most likely a bug.
This UGen outputs its input signal for convenience.
the input signal which will trigger the action.
A UGen that, when its input UGen is finished, frees enclosing synth.
A UGen that, when its input UGen is finished, frees enclosing synth. This is
essentially a shortcut for FreeSelf.kr(Done.kr(src)) , so instead of providing
a trigger signal it reads directly the done flag of an appropriate ugen (such as
Line or PlayBuf ).
This UGen outputs its input signal for convenience.
the input UGen which when finished will trigger the action.
A monophonic reverb UGen.
A monophonic reverb UGen. All parameters are specified in and automatically clipped to the range 0 to 1. The UGen is stateless insofar it does not use a random number generator.
input signal to reverberate
dry/wet balance from zero (only dry) to one (only wet)
room size
high frequency attenuation (1 is maximum attenuation)
A stereophonic reverb UGen.
A stereophonic reverb UGen. All parameters are specified in and automatically clipped to the range 0 to 1. The UGen is stateless insofar it does not use a random number generator. However, if the same input is used for left and right channel, the output channels are different and uncorrelated. There is also some cross-feed between the two channels.
left channel of input signal to reverberate
right channel of input signal to reverberate
dry/wet balance from zero (only dry) to one (only wet)
room size
high frequency attenuation (1 is maximum attenuation)
A frequency shifting UGen.
A frequency shifting UGen. It implements single sideband (SSB) amplitude modulation, also known as frequency shifting, but not to be confused with pitch shifting. Frequency shifting moves all the components of a signal by a fixed amount but does not preserve the original harmonic relationships.
the shift amount in Hertz. Positive values shift upwards, negative values shift downwards.
a phase parameter in radians (0 to 2 Pi).
A stereophonic reverb UGen.
A stereophonic reverb UGen. It is based on the GVerb LADSPA effect by Juhana Sadeharju.
Note: A CPU spike may occur when the synth is instantiated.
Warning: The UGen has a bug which results in loud noise if the room size
is increased during playback. It seems safe to start with a large room size and
decrease the value during playing. Warning: The UGen may crash the
server if roomSize becomes larger than maxRoomSize .
Size of the virtual room in meters. It must not be
greater than maxRoomSize . Note that quick changes in
roomSize may result in zipper noise and an audible
Doppler effect.
reverberation time in seconds.
high frequency attenuation (1 is maximum attenuation)
high frequency attenuation of the input signal (0 to 1)
stereo spread of the reverb signal. Units?
amount of dry signal
amount of early reflections
amount of late reverberation
maximum value that roomSize can take. This is used
for the early reflection delay lines and is only read at
initialization time. (init-time only)
A gate or hold UGen.
A gate or hold UGen. It allows the input signal value to pass when the gate
argument is positive, otherwise it holds last value.
Before the first high gate value is registered, this UGen outputs zero.
the input signal to gate
the signal specifying whether to pass the input signal (when greater than zero) or whether to close the gate and hold the last value (when less than or equal to zero)
Iteration frequency in Hertz
Initial value of y
A non-interpolating sound generator based on the difference equations:
A non-interpolating sound generator based on the difference equations:
x[n+1] = 1 - y[n] + abs(x[n]) y[n+1] = x[n]
The behavior of the system is only dependent on its initial conditions. Reference: Devaney, R. L. "The Gingerbreadman." Algorithm 3, 15-16, Jan. 1992.
Iteration frequency in Hertz
Initial value of y
A granular synthesis UGen taking sound stored in a buffer.
A granular synthesis UGen taking sound stored in a buffer. Another buffer can be used to provide an amplitude envelope. The input sound buffer must be monophonic, but output may be multi-channel, using a panorama control.
All arguments except numChannels and maxGrain are polled at grain creation
(trigger) time.
the number of channels to output. If 1 , a monophonic
signal is returned and the pan argument is ignored.
a control- or audio-rate trigger to start a new grain. For audio-rate, timing is sample frame accurate.
grain duration in seconds
buffer holding a mono audio signal portions of which are read as grains
playback speed of the grain, where 1.0 is original
rate, 0.5 is half speed etc.
grain start position, where 0 is beginning and 1 is
the end of the input buffer
interpolation type when using pitch-shifting via
speed . 1 for no interpolation (nearest sample), 2
for linear interpolation, and 4 for cubic
interpolation.
panning position when numChannels is greater than
one. Equivalent to the pan position of Pan2 (for
stereo output) or PanAz (for more than two channels)
identifier of a buffer containing a signal to use for
the grain envelope. The default value of -1 means that
a built-in Hann envelope is used.
maximum number of overlapping grains that can be used at a given time. This value is set at the UGens init time and cannot be modified later. Lower value mean that less memory is used.
A noise generator UGen which results from flipping random bits in a word.
A noise generator UGen which results from flipping random bits in a word. The
resulting waveform looks like a sample-and-hold function with values between
-1 and +1 (before being multiplied by mul ).
This type of noise has a high RMS level relative to its peak to peak level. With approx. -4.8 dB, the RMS is the same as white noise, but the spectrum is emphasized towards lower frequencies.
Not actually a UGen input, this argument produces a
multiplication of the output by this factor. A
multi-channel mul argument will cause the generation
of multiple independent noise generators.
A second order high pass filter UGen.
A two point difference filter UGen.
three point difference filter UGen.
A UGen that returns a unique output value from zero to one for each input value according to a hash function.
A UGen that returns a unique output value from zero to one for each input value according to a hash function. The same input value will always produce the same output value. The input values can have any range.
input to calculate the hash function for
A cubic-interpolating sound generator based on the difference equation:
A cubic-interpolating sound generator based on the difference equation:
x[n+2] = 1 - a * pow(x[n+1], 2) + b * x[n]
This equation was discovered by French astronomer Michel Hénon while studying the orbits of stars in globular clusters.
Iteration frequency in Hertz
Equation variable
Equation variable
Initial value of x
Second value of x
A linear-interpolating sound generator based on the difference equation:
A linear-interpolating sound generator based on the difference equation:
x[n+2] = 1 - a * pow(x[n+1], 2) + b * x[n]
This equation was discovered by French astronomer Michel Hénon while studying the orbits of stars in globular clusters.
Iteration frequency in Hertz
Equation variable
Equation variable
Initial value of x
Second value of x
A non-interpolating sound generator based on the difference equation:
A non-interpolating sound generator based on the difference equation:
x[n+2] = 1 - a * pow(x[n+1], 2) + b * x[n]
This equation was discovered by French astronomer Michel Hénon while studying the orbits of stars in globular clusters.
Iteration frequency in Hertz
Equation variable
Equation variable
Initial value of x
Second value of x
A Hilbert transform UGen.
A Hilbert transform UGen. This transformation produces two signals from a given input with identical frequency content, but with their respective phases shifted to be 90 degrees apart (0.5 pi radians).
The two signals output by Hilbert correspond to the real and imaginary part
of the complex transformed signal. Due to the method used (an IIR filter),
distortion occurs in the upper octave of the frequency spectrum.
The transform can be used to implemented single-side-band (SSB) modulation, but
a dedicated UGen FreqShift is already provided for this case.
input signal to be processed
Envelope generator UGen with random access index pointer into the break-point function.
Envelope generator UGen with random access index pointer into the break-point function.
Warning: The envelope must be generated using IEnv not Env . IEnv
has a completely different format. Using the wrong format ( Env ) may crash
the server.
To construct a manual envelope without the use of the IEnv class, the format
should be as follows:
val env = Seq[GE](offset, startLevel, numSegments, totalDuration, duration1, curveType1, curvature1, targetLevel1, duration2, curveType2, curvature2, targetLevel2 ...)
the description of the envelope break-points. Typically
you pass an instance of IEnv which will then
automatically expand to the correct format.
index point into the envelope, given as time in seconds
A UGen performing an inverse FFT, transforming a buffer containing a spectral domain signal back into the time domain.
A UGen performing an inverse FFT, transforming a buffer containing a spectral domain signal back into the time domain.
reference to the spectral signal, returned as a
buffer-identifier from FFT or the PV_... UGens.
The window function applied after each IFFT is taken.
The default of 0 is a sine window, -1 is a rectangle
window, and 1 is a Hann window. (init-time only)
With the default value of zero, the window size equals the fft size. If you wish to perform zero padding, an explicit window size can be specified. (init-time only)
A scalar UGen that generates a single random integer value, using a uniform
distribution from lo to hi .
A non-band-limited generator UGen for single sample impulses.
A UGen that reads a signal from a bus.
A UGen that reads a signal from a bus. Whether an audio- or control-bus is used depends on the rate of the UGen.
In.ar and In.kr behave differently with respect to signals left on the bus
in the previous calculation cycle (control block): In.ar can access audio
signals that were generated in the current calculation cycle by synths appearing
earlier in the node tree. It does not read signals produced by nodes in the
previous calculation cycle (i.e. synths appearing later in the node tree), the
input would instead be zero. To allow such "feedback", InFeedback can be used.
In contrast, In.kr does not distinguish between "new" and "old" data: It will
always read the most recent value found on the bus, whether it was generated
earlier in this calculation cycle, left over from the last one, or set before by
the client.
Note: The server uses the first NumOutputBuses channels to write to the
sound card, followed by another NumInputBuses to read from the sound card. For
convenience, the pseudo-UGens PhysicalOut and PhysicalIn can be used.
index of the bus to read from. When numChannels is
greater than one, the other channels or read from the
adjacent indices.
number of channels to read
A UGen which reads a signal from an audio bus with a current or one cycle old timestamp.
A UGen which reads a signal from an audio bus with a current or one cycle old timestamp.
Audio buses adhere to the concept of a cycle timestamp, which increases for
each audio block calculated. When the various output ugens ( Out , OffsetOut
, XOut ) write data to a bus, they mix it with any data from the current
cycle, but overwrite any data from the previous cycle. ( ReplaceOut overwrites
all data regardless.) Thus depending on node order and what synths are writing
to the bus, the data on a given bus may be from the current cycle or be one
cycle old at the time of reading.
In.ar checks the timestamp of any data it reads in and zeros any data from
the previous cycle (for use within that node; the data remains on the bus). This
is fine for audio data, as it avoids feedback, but for control data it is useful
to be able to read data from any place in the node order. For this reason
In.kr also reads data that is older than the current cycle.
In some cases one might also want to read audio from a node later in the
current node order. This can be achieved with InFeedback . It reads from the
previous cycle, and hence introduces a delay of one block size, which by
default is 64 sample frames (equal to about 1.45 ms at 44.1 kHz sample rate).
Note that no delay occurs when the bus contains a signal which has been written already in the current cycle. The delay is only introduced when no present signal exists.
the index of the audio bus to read in from.
the number of channels (i.e. adjacent buses) to read in. Since this is a constant, a change in number of channels of the underlying bus must be reflected by creating different SynthDefs.
A UGen that tests if a signal is within a given range.
A UGen that tests if two signals lie both within a given ranges.
A UGen that tests if two signals lie both within a given ranges. The two input signals can be understood as horizontal and vertical coordinates, therefore the test become one that determines whether the input is within a given "rectangle".
If x >= left and x <= right and y > top and y <= bottom , outputs 1.0,
otherwise outputs 0.0.
"horizontal" signal to test
"vertical" signal to test
lower margin of horizontal test range (inclusive)
lower margin of vertical test range (inclusive)
upper margin of horizontal test range (inclusive)
upper margin of vertical test range (inclusive)
A UGen which generates a trigger anytime a control bus is set.
A UGen which generates a trigger anytime a control bus is set.
Any time the bus is "touched" i.e. has its value set (using "/c_set" etc.), a
single impulse trigger will be generated. Its amplitude is the value that the
bus was set to. Note that if a signal is continuously written to that bus, for
instance using Out.kr , only one initial trigger is generated once that ugen
starts writing, but no successive triggers are generated.
the index of the control bus to read in from.
the number of channels (i.e. adjacent buses) to read in. Since this is a constant, a change in number of channels of the underlying bus must be reflected by creating different SynthDefs.
A UGen which reads a single sample value from a buffer at a given index.
A UGen which reads a single sample value from a buffer at a given index.
It uses the in argument as index into the buffer, truncating that argument to
an integer. Out-of-range index values are clipped to the valid range.
While designed for monophonic buffers, it works with multi-channel buffers by treating them as de-interleaved. For example, if the buffer has two frames and two channels, index 0 corresponds to frame 0, channel 0, index 1 correspond to frame 0, channel 1, index 2 corresponds to frame 1, channel 0, and index 3 corresponds to frame 1, channel 1.
The buffer to read from.
The sample index into the buffer. This is truncated to an integer automatically.
A UGen which determines the (lowest) index in a buffer at which the two neighboring values contain a given input signal.
A UGen which determines the (lowest) index in a buffer at which the two neighboring values contain a given input signal. The output index is a decimal whose fractional part is suitable for linearly interpolating between the buffer slot values.
For example, if the Buffer contains values 3, 21, 25, 26 and the input signal has the value 22, then the output will be 1.25, because the value 22 is in-between the values stored at indices 1 and 2 and the linear location of 22 is one-quarter of the way along the interval between them: 21 * (1 - 0.25) + 25 * (1 - 0.75) = 22.
If the input value is smaller than the first sample, the output will be zero. If the input value is larger than any sample in the buffer, the output will be the buffer size minus one.
While designed for monophonic buffers, it works with multi-channel buffers by treating them as de-interleaved. For example, if the buffer has two frames and two channels, and the algorithm finds the frame 1 in channel 0, the reported index is 2 (frame * numChannels + channel).
IndexInBetween is the complement of the IndexL UGen.
The buffer to search in.
The input signal whose value is looked up in the buffer.
A UGen which reads from a buffer at a given index, linearly interpolating between neighboring points.
A UGen which reads from a buffer at a given index, linearly interpolating between neighboring points.
It uses the in argument as index into the buffer. Out-of-range index values
are clipped to the valid range. If the index has a fractional part, it is used
to interpolate between the buffer index at the floor and the buffer index at the
ceiling of the index argument.
While designed for monophonic buffers, it works with multi-channel buffers by
treating them as de-interleaved. See the Index UGen for details.
The buffer to read from.
The sample index into the buffer. This can have a fractional part.
A filter UGen to integrate an input signal with a leak.
A converter UGen that takes a control-rate input and produces an audio-rate output by means of linear interpolation.
A converter UGen that takes a control-rate input and produces an audio-rate output by means of linear interpolation. The current control input value is always reached in at the beginning of the subsequent control block. A special case is the initialization which begins directly at the first control input value (therefore, the first control block of the audio-rate output is is always constant.)
For example, if the block size is 64, and the first three input values are -0.5, 0.6, 0.3, then the output signal will be 65 samples of value -0.5, followed by a linear ramp of 64 samples towards 0.6, followed by a linear ramp of 64 samples to towards 0.3.
control-rate signal to convert
A UGen that detects a specific keyboard stroke.
A UGen that detects a specific keyboard stroke. When the given key is not
pressed, the lo value is output, while the key is pressed the hi value is
output. If lag is greater than zero, a Lag -type operation is applied for a
smoother transition between lo and hi .
hardware code for the key to monitor. This is likely platform dependent. For example, on Linux, key-codes 24 to 29 correspond to 'Q', 'W', 'E', 'R', 'T', 'Y'.
value output when the currently pressed does not match the code
value output when the currently pressed does match the code
60 dB lag time in seconds.
A (12TET major/minor) key tracker UGen.
A (12TET major/minor) key tracker UGen. It is based on a pitch class profile of energy across FFT bins and matching this to templates for major and minor scales in all transpositions. It assumes a 440 Hz concert A reference. Output is 0-11 C major to B major, 12-23 C minor to B minor.
the output (buffer) of an FFT UGen which transforms the audio input to track. For the FFT chain, with a standard hop of half FFT size, the FFT size should be 4096 at 44.1 or 48 kHz and 8192 at 88.2 or 96 kHz sampling rate.
Number of seconds for the influence of a window on the final key decision to decay by 40dB (to 0.01 its original value). Can be control-rate modulated.
Each frame, the chroma values are set to the previous value multiplied by this chroma decay. 0.0 will start each frame afresh with no memory. Can be control-rate modulated.
A UGen that randomly generates the values -1 or +1 at a rate given by the nearest integer division of the sample rate by the frequency argument.
A UGen that randomly generates the values -1 or +1 at a rate given by the
nearest integer division of the sample rate by the frequency argument. The
difference to LFClipNoise is that this UGen quantizes time to the nearest
integer division of the sample-rate, and the frequency input is only polled at
the moment a new output value is scheduled.
rate at which to generate random values.
A sine-like oscillator UGen with a shape made of two cubic pieces.
A sine-like oscillator UGen with a shape made of two cubic pieces. It is
smoother than LFPar .
oscillator frequency in Hertz
initial phase in cycle (0 to 1) (init-time only)
A UGen that randomly generates the values -1 or +1 at a rate given by the nearest integer division of the sample rate by the frequency argument.
A UGen that randomly generates the values -1 or +1 at a rate given by the
nearest integer division of the sample rate by the frequency argument. The
difference to LFClipNoise is that this UGen does not quantize time and
recovers fast from frequency input changes.
rate at which to generate random values.
A dynamic step noise UGen.
A dynamic step noise UGen. Like LFNoise0 , it generates abruptly changing
random values between -1 and +1 at a rate given by the freq argument, with
two differences: There is no time quantization, and it there is fast recovery
from low freq values.
In contrast, LFNoise0 , LFNoise1 , and LFNoise2 quantize to the nearest
integer division of the sample rate, and they poll the freq argument only when
scheduled, and thus seem to hang when the frequencies get very low.
If very high or very low frequencies are not needed, or fixed frequencies are
used, LFNoise0 is more efficient.
rate at which to generate random values.
A dynamic ramp noise UGen.
A dynamic ramp noise UGen. Like LFNoise1 , it generates linearly interpolated
random values between -1 and +1 at a rate given by the freq argument, with
two differences: There is no time quantization, and it there is fast recovery
from low freq values.
In contrast, LFNoise0 , LFNoise1 , and LFNoise2 quantize to the nearest
integer division of the sample rate, and they poll the freq argument only when
scheduled, and thus seem to hang when the frequencies get very low.
If very high or very low frequencies are not needed, or fixed frequencies are
used, LFNoise1 is more efficient.
rate at which to generate random values.
A dynamic ramp noise UGen.
A dynamic ramp noise UGen. It is similar to LFNoise2 , with three
differences: It uses cubic instead of quadratic interpolation for the random
values between -1 and +1 at a rate given by the freq argument. There is no
time quantization, and it there is fast recovery from low freq values.
In contrast, LFNoise0 , LFNoise1 , and LFNoise2 quantize to the nearest
integer division of the sample rate, and they poll the freq argument only when
scheduled, and thus seem to hang when the frequencies get very low.
rate at which to generate random values.
A non-band-limited gaussian function oscillator UGen.
A non-band-limited gaussian function oscillator UGen. Output ranges from
minVal to 1. It implements the formula:
f(x) = exp((x - phase).squared / (-2 * width.squared))where x is to vary in the range -1 to 1 over the period dur . minVal is
the initial value at -1. E.g. for default parameters, it is exp(-50) or
roughly zero.
duration in seconds of a full -1 <= x <= 1 cycle, or the reciprocal of the frequency
relative width of the bell. Best to keep below 0.25 when used as envelope.
phase offset
if greater than zero, the UGen oscillates. Otherwise it
calls doneAction after one cycle.
evaluated after cycle completes
A step noise UGen.
A step noise UGen. It generates abruptly changing random values between -1
and +1 at a rate given by the freq argument.
The frequency is quantized to the nearest integer division of the sample rate,
and changes in frequency are only picked up at the next trigger. In contrast,
variant LFDNoise0 has precise frequency and reacts to frequency changes
instantly.
rate at which to generate random values.
A ramp noise UGen.
A ramp noise UGen. It generates line segments whose start and end points are
chosen randomly between -1 and +1 . New breakpoints are generated at a
specified frequency.
The frequency is quantized to the nearest integer division of the sample rate,
and changes in frequency are only picked up at the next trigger. In contrast,
variant LFDNoise1 has precise frequency and reacts to frequency changes
instantly.
rate at which to generate new breakpoints.
A quadratically interpolating noise UGen.
A quadratically interpolating noise UGen. This interpolation happens between
breakpoints chosen randomly between -1 and +1 at a specified frequency.
The frequency is quantized to the nearest integer division of the sample rate,
and changes in frequency are only picked up at the next trigger. In contrast,
variant LFDNoise3 has precise frequency and reacts to frequency changes
instantly.
Note: Due to the interpolation, the output values can occasionally extend beyond the normal range of -1 to +1, if the frequency varies in certain ways.
rate at which to generate new breakpoints.
A sine-like oscillator UGen with a shape made of two parabolas.
A sine-like oscillator UGen with a shape made of two parabolas. It has audible odd harmonics and is non-band-limited. Its output ranges from -1 to +1.
oscillator frequency in Hertz
initial phase in cycle (0 to 1) (init-time only)
A non-band-limited pulse oscillator UGen.
A non-band-limited pulse oscillator UGen. Outputs a high value of one and a low value of zero.
oscillator frequency in Hertz
initial phase offset in cycles ( 0..1 ). If you think
of a buffer of one cycle of the waveform, this is the
starting offset into this buffer. Hence, an iphase of
0.25 means that you will hear the first impulse after
0.75 periods! If you prefer to specify the perceived
delay instead, you could use an iphase of -0.25 + 1
which is more intuitive. Note that the phase is not
automatically wrapped into the range of 0..1 , so
putting an iphase of -0.25 currently results in a
strange initial signal which only stabilizes to the
correct behaviour after one period! (init-time only)
pulse width duty cycle from zero to one. If you want to
specify the width rather in seconds, you can use the
formula width = freq * dur , e.g. for a single sample
impulse use width = freq * SampleDur.ir .
A sawtooth oscillator UGen.
A sawtooth oscillator UGen. The oscillator is creating an aliased sawtooth,
that is it does not use band-limiting. For a band-limited version use Saw
instead. The signal range is -1 to +1.
oscillator frequency in Hertz
initial phase offset. For efficiency reasons this is a value ranging from -1 to 1 (thus equal to the initial output value). Note that a phase of zero (default) means the wave starts at 0 and rises to +1 before jumping down to -1. Use a phase of 1 to have the wave start at -1. (init-time only)
A triangle oscillator UGen designed for low frequency control signals (being non-band-limited).
A triangle oscillator UGen designed for low frequency control signals (being non-band-limited). The output varies from -1 to 1.
With an initial phase of zero, the oscillator begins at 0, rises to 1, then falls to -1 and goes back to zero after one complete phase. With an initial phase of 1 (corresponding to 90 degrees), the oscillator begins at 1 and then falls to -1. With an initial phase of 3 (or 270 degrees), the oscillator begins at -1 and then rises to 1.
frequency in Hertz
initial phase of the oscillator. A full phase (2 Pi or
360 degrees) is represented by an iphase value of 4.
The initial phase cannot be modulated. (init-time
only)
A second order low pass filter UGen.
two point average filter UGen.
two point average filter UGen. Implements the formula :
out(i) = 0.5 * (in(i) + in(i-1))
input signal to be filtered
three point average filter UGen.
An exponential lag UGen.
An exponential lag UGen. This is essentially the same as OnePole except that
instead of supplying the coefficient directly, it is calculated from a 60 dB lag
time. This is the time required for the filter to converge to within 0.01 % of a
value. This is useful for smoothing out control signals.
input signal.
60 dB lag time in seconds.
A cascaded exponential lag UGen.
A cascaded exponential lag UGen with separate inputs for up and down slope.
A cascaded exponential lag UGen with separate inputs for up and down slope.
Lag2UD.kr(in, up, down) is equivalent to
LagUD.kr(LagUD.kr(in, up, down), up, down) , thus resulting in a smoother
transition. This saves on CPU as you only have to calculate the decay factors
once instead of twice.
input signal.
60 dB lag time in seconds effective during a rising slope in the input signal
60 dB lag time in seconds effective during a falling slope in the input signal
A cascaded exponential lag UGen.
A cascaded exponential lag UGen. Lag3.kr(in, time) is equivalent to
Lag.kr(Lag.kr(Lag.kr(Lag.kr(in, time), time), time) , thus resulting in a
smoother transition. This saves on CPU as you only have to calculate the decay
factor once instead of three times.
input signal.
60 dB lag time in seconds.
A cascaded exponential lag UGen with separate inputs for up and down slope.
A cascaded exponential lag UGen with separate inputs for up and down slope.
Lag3UD.kr(in, up, down) is equivalent to
LagUD.kr(LagUD.kr(LagUD.kr(in, up, down), up, down), up, down) , thus
resulting in a smoother transition. This saves on CPU as you only have to
calculate the decay factors once instead of three times.
input signal.
60 dB lag time in seconds effective during a rising slope in the input signal
60 dB lag time in seconds effective during a falling slope in the input signal
A UGen that reads a signal from a control bus and applies a lag filter to it.
A UGen that reads a signal from a control bus and applies a lag filter to it.
This is essentially the same as Lag.kr(In.kr(...), time) .
index of the bus to read from. When numChannels is
greater than one, the other channels or read from the
adjacent indices.
number of channels to read
60 dB lag time in seconds.
An exponential lag UGen with separate inputs for up and down slope.
An exponential lag UGen with separate inputs for up and down slope. This is
essentially the same as Lag except that you can supply a different 60 dB time
for when the signal goes up, from when the signal goes down.
input signal.
60 dB lag time in seconds effective during a rising slope in the input signal
60 dB lag time in seconds effective during a falling slope in the input signal
A sample-and-hold UGen that outputs the last value before the input changed more than a threshold.
A sample-and-hold UGen that outputs the last value before the input changed more than a threshold. Change is based on the absolute of the differentiation of input signal.
input signal to analyze and filter
threshold below which the input sign
A sample-and-hold UGen.
A sample-and-hold UGen. When triggered, a new value is taken from the input and hold until the next trigger occurs.
Before the first trigger is registered, this UGen outputs zero.
the input signal
the trigger. The can be any signal. A trigger happens when the signal changes from non-positive to positive.
A cubic-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26.
A cubic-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26. The function is:
x[n+1] = sin(b * y[n]) + c * sin(b * x[n]) y[n+1] = sin(a * y[n]) + d * sin(a * x[n])
According to Pickover, parameters a and b should be in the range from -3 to +3, and parameters c and d should be in the range from 0.5 to 1.5. The function can, depending on the parameters given, give continuous chaotic output, converge to a single value (silence) or oscillate in a cycle (tone). NOTE: This UGen is experimental and not optimized currently, so is rather hoggish of CPU.
Iteration frequency in Hertz.
Equation variable
Equation variable
Equation variable
Equation variable
Initial value of x
Initial value of y
A linear-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26.
A linear-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26. The function is:
x[n+1] = sin(b * y[n]) + c * sin(b * x[n]) y[n+1] = sin(a * y[n]) + d * sin(a * x[n])
According to Pickover, parameters a and b should be in the range from -3 to +3, and parameters c and d should be in the range from 0.5 to 1.5. The function can, depending on the parameters given, give continuous chaotic output, converge to a single value (silence) or oscillate in a cycle (tone). NOTE: This UGen is experimental and not optimized currently, so is rather hoggish of CPU.
Iteration frequency in Hertz
Equation variable
Equation variable
Equation variable
Equation variable
Initial value of x
Initial value of y
A non-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26.
A non-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26. The function is:
x[n+1] = sin(b * y[n]) + c * sin(b * x[n]) y[n+1] = sin(a * y[n]) + d * sin(a * x[n])
According to Pickover, parameters a and b should be in the range from -3 to +3, and parameters c and d should be in the range from 0.5 to 1.5. The function can, depending on the parameters given, give continuous chaotic output, converge to a single value (silence) or oscillate in a cycle (tone). NOTE: This UGen is experimental and not optimized currently, so is rather hoggish of CPU.
Iteration frequency in Hertz.
Equation variable
Equation variable
Equation variable
Equation variable
Initial value of x
Initial value of y
A filter UGen to remove very low frequency content DC offset.
A filter UGen to remove very low frequency content DC offset.
input signal to be filtered
the leak coefficient determines the filter strength. the value must be between zero and one (exclusive) for the filter to remain stable. values closer to one produce less bass attenuation.
A UGen that switches between two input signal depending on which is changing less.
A UGen that switches between two input signal depending on which is changing less. Change is based on the absolute of the differentiation of the respective signals.
first input signal to select from
second input signal to select from
Limits the input amplitude to the given level.
Limits the input amplitude to the given level. Unlike Compander , this UGen
will never overshoot, but it needs to look ahead in the input signal,
introducing a delay in its output. The delay time is equal to twice the value of
the dur parameter (the buffer internally used).
input signal to be limited
maximum amplitude to which the signal is limited. The
limiter will kick in when the input signal exceeds
+level or falls below -level .
look-ahead time in seconds (init-time only)
A cubic-interpolating sound generator based on the difference equation:
A linear-interpolating sound generator based on the difference equation:
A non-interpolating sound generator based on the difference equation:
A UGen which maps a linear range to an exponential range.
A UGen which maps a linear range to an exponential range. The equivalent
formula is (dstHi / dstLo).pow((in - srcLo) / (srcHi - srcLo)) * dstLo .
Note: No clipping is performed. If the input signal exceeds the input range, the output will also exceed its range.
input signal to convert
lower limit of input range
upper limit of input range
lower limit of output range
upper limit of output range
A graph element which maps a linear range to another linear range.
A graph element which maps a linear range to another linear range.
The equivalent formula is (in - srcLo) / (srcHi - srcLo) * (dstHi - dstLo) + dstLo.
Note: No clipping is performed. If the input signal exceeds the input range, the output will also exceed its range.
The input signal to convert.
The lower limit of input range.
The upper limit of input range.
The lower limit of output range.
The upper limit of output range.
A stereo panorama UGen based on linear amplitude control.
A stereo panorama UGen based on linear amplitude control. When in center
position ( pos = 0 ), the signal is attenuated by 0.5 or approx. -6 dB.
(monophonic) input signal to be panned
panorama position between -1 (hard left) via 0 (center) to +1 (hard right)
additional gain control
A scalar UGen that generates a single random decimal value between lo and
hi with a selectable skew towards either end.
A scalar UGen that generates a single random decimal value between lo and
hi with a selectable skew towards either end.
The minMax <= 0 behaves rather odd: If minMax is less than 1, the
distribution is skewed towards lo (with lo = 0 and hi = 1 , the mean is
approx. 0.33). If minMax is greater than or equal to 1, the distribution is
skewed towards hi (with lo = 0 and hi = 1 , the mean is approx 0.66).
lower limit of the output range
upper limit of the output range
if 0 , the output is skewed towards lo , if 1 ,
the output is skewed towards hi .
An linear two channel cross fading UGen.
An linear two channel cross fading UGen. In center position ( pan = 0 ), both
input signals are attenuated by 0.5 or approx. -6 dB.
The first input signal
The second input signal
the cross-fade position from -1 (only input A
audible) to +1 (only input B audible)
An overall amplitude multiplier that is applied to the output signal
A line generator UGen that moves from a start value to the end value in a given duration.
A line generator UGen that moves from a start value to the end value in a given duration.
Starting value (init-time only)
Ending value (init-time only)
Duration in seconds (init-time only)
A done-action that is evaluated when the Line has reached the end value after the given duration
A linear ASR-type envelope generator UGen.
A linear ASR-type envelope generator UGen.
triggers the envelope and holds it open while greater
than zero. A value of less than zero enforces a release
with duration -1.0 - gate .
duration (seconds) of the attack segment
level of the sustain segment
duration (seconds) of the release segment
action to be performed when the envelope reaches its end point.
A UGen that produces a scheduled sequences of trigger impulses.
A UGen that produces a scheduled sequences of trigger impulses. Trigger times
are provided as a list (buffer) of absolute offsets from time zero. A trigger is
output as a single control period of value 1 , after which output returns to
zero.
identifier of the buffer containing the offsets for the
triggers in seconds. The offsets are taken against the
start time of the synth or the last time a reset was
received. They are not accumulative, and the behavior is
undefined if the values are not sorted in ascending
order. The buffer should be monophonic.
the number of values to use from the buffer. Typically,
this should be BufFrames.kr(buf) .
resets the timer and begins reading the time offsets again at the start of the buffer.
this value is added to each of the buffer values. For
example, to delay the list of values all by half a
second, use a delay of 0.5 . This parameter is only
updated at initialization or reset.
The argument order is different from its sclang counterpart.
A UGen that produces a scheduled sequences of trigger impulses.
A UGen that produces a scheduled sequences of trigger impulses. Trigger times
are provided as a list (buffer) of relative durations between consecutive
events. A trigger is output as a single control period of value 1 , after
which output returns to zero.
identifier of the buffer containing the durations for
the triggers in seconds. A value represents a relative
offsets with respect to its predecessor. The first value
indicates the time between the start of the synth or
last reset received and the first trigger. The buffer
should be monophonic.
the number of values to use from the buffer. Typically,
this should be BufFrames.kr(buf) .
resets the timer and begins reading the time deltas again at the start of the buffer.
The argument order is different from its sclang counterpart.
A UGen that allocates a buffer local to the synth.
A UGen that allocates a buffer local to the synth.
This is convenient for example when using an FFT chain.
number of sample frames for the buffer
number of channels for the buffer
A UGen that reads buses that are local to the enclosing synth.
A UGen that reads buses that are local to the enclosing synth. These buses
should be written using a LocalOut ugen. They behave like regular buses, but
are more convenient for the implementation of a self contained effect that uses
a feedback processing loop.
In a synth, there can be only each one control-rate and audio-rate LocalIn /
LocalOut pair. The signal written to a LocalOut will not be read by the
LocalIn until the next control block cycle, introducing a delay of
ControlDur .
Warning: The argument has been changed numChannels: Int in version
1.15.3 to init: GE in version 1.16.0. The previous version was incompatible
with SuperCollider 3.6.x. A previous usage such as LocalIn.ar(2) to create two
channels must now be expressed as LocalIn.ar(Seq(0, 0)) !
the initial state of the UGen. The number of channels
of this signal should match with the number of channels
written via LocalOut .
A UGen that writes to buses that are local to the enclosing synth.
A UGen that writes to buses that are local to the enclosing synth. These buses
should have been defined by a LocalIn ugen. These behave like regular buses,
but are more convenient for the implementation of a self contained effect that
uses a feedback processing loop.
In a synth, there can be only each one control-rate and audio-rate LocalIn /
LocalOut pair. The signal written to a LocalOut will not be read by the
LocalIn until the next control block cycle, introducing a delay of
ControlDur .
For more examples, see LocalIn.
signal to be written to the synth-local bus. The
signal's number of channels must be the same number of
channels as were declared in the corresponding LocalIn
.
A UGen to store values in a buffer upon receiving a trigger.
A UGen to store values in a buffer upon receiving a trigger. When a trigger happens, the current input values are sampled and stored as the next consecutive frame of the buffer.
Storage starts at the buffer beginning and increments the write position until
the buffer is full. While the buffer is not yet full, the UGen outputs 1 ,
then it outputs 0 . The buffer position can be reset using the reset input.
Note that the UGen zeroes the buffer upon first instantiation, to ensure that out-of-date data is not confused with new data.
identifier of the buffer to write to. Its number of
channels should match those of in .
(multi-channel) signal to write to the buffer. Its
number of channels should match those of buf .
a non-positive to positive transition causes the UGen to append the current input values to the buffer
a non-positive to positive transition causes the write index into the buffer to be reset to zero. The contents of the buffer will also be filled with zeroes. If the buffer was full, the UGen output switches back to zero.
The argument order is different from its sclang counterpart.
A noise generator UGen based on the logistic map.
A noise generator UGen based on the logistic map. Its formula is
y[n+1] = chaos * y[n] * (1.0 - y[n])
a parameter of the chaotic function with useful values from 0.0 to 4.0. Chaotic behavior occurs from 3.57 up. Using values outside this range can make the UGen blow up, resulting in NaNs.
Frequency of calculation in Hertz. The value is limited by the sampling rate.
Initial value of the recursive function
A strange attractor discovered by Edward N.
A strange attractor discovered by Edward N. Lorenz while studying mathematical models of the atmosphere. The system is composed of three ordinary differential equations:
x' = s * (y - x) y' = x * (r - z) - y z' = x * y - b * z
The time step amount h determines the rate at which the ODE is evaluated. Higher values will increase the rate, but cause more instability. A safe choice is the default amount of 0.05.
Iteration frequency in Hertz
Equation variable
Equation variable
Equation variable
Integration time step
Initial value of x
Initial value of y
Initial value of z
A UGen for the extraction of instantaneous loudness.
A UGen for the extraction of instantaneous loudness. A perceptual loudness function which outputs loudness in sones; this is a variant of an MP3 perceptual model, summing excitation in ERB bands. It models simple spectral and temporal masking, with equal loudness contour correction in ERB bands to obtain phons (relative dB), then a phon to sone transform. The final output is typically in the range of 0 to 64 sones, though higher values can occur with specific synthesised stimuli.
Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.
the output (buffer) of an FFT UGen which transforms the audio input to track. The FFT size should be 1024 for 44.1 and 48 kHz sampling rate, and 2048 for 88.2 and 96 kHz sampling rate.
Spectral masking parameter: lower bins mask higher bin
power within ERB bands, with a power falloff (leaky
integration multiplier) of smask per bin. Can be
control-rate modulated.
Temporal masking parameter: the phon level let through
in an ERB band is the maximum of the new measurement,
and the previous minus tmask phons. Can be
control-rate modulated.
A UGen for extracting mel frequency cepstral coefficients.
A UGen for extracting mel frequency cepstral coefficients. It generates a set of MFCCs; these are obtained from a band-based frequency representation (using the Mel scale by default), and then a discrete cosine transform (DCT). The DCT is an efficient approximation for principal components analysis, so that it allows a compression, or reduction of dimensionality, of the data, in this case reducing 42 band readings to a smaller set of MFCCs. A small number of features (the coefficients) end up describing the spectrum. The MFCCs are commonly used as timbral descriptors.
The output values are somewhat normalised for the range 0.0 to 1.0, but there are no guarantees on exact conformance to this. Commonly, the first coefficient will be the highest value. The number of output channels corresponds to the number of coefficients specified. Technical note: The 0th coefficient is not generated as it consists of multiplying all bands by 1 and summing
Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.
the output (buffer) of an FFT UGen which transforms the audio input to track. For the FFT chain, with a standard hop of half FFT size, the FFT size should be 1024 at 44.1 or 48 kHz and 2048 at 88.2 or 96 kHz sampling rate.
the number of coefficients, defaults to 13, maximum of
42; more efficient to use less of course! Since this
number determines the number of output channels of the
UGen, it has to be an Int .
A UGen that masks off bits in the mantissa of the floating point sample value.
A UGen that masks off bits in the mantissa of the floating point sample value. This introduces a quantization noise, but is less severe than linearly quantizing the signal.
input signal to quantize
The number of mantissa bits to preserve, from 0 to 23.
A filter UGen that calculates the median of a running window over its input signal.
A filter UGen that calculates the median of a running window over its input signal. This non-linear filter can be used to reduce impulse noise from a signal.
window size. I.e., the number of input samples in which to find the median. Must be an odd number from 1 to 31. A value of 1 has no effect. Warning: This parameter is only read an initialization time and cannot be modulated while the UGen is running. (init-time only)
The argument order is different from its sclang counterpart.
A single band parametric equalizer UGen.
A single band parametric equalizer UGen. It attenuates or boosts a frequency band.
input signal to be filtered
center frequency in Hertz
reciprocal of Q. The Q (or quality) is conventionally
defined as center-frequency / bandwidth, meaning that rq
= bandwidth / center-frequency. A higher Q or
lower rq produces a steeper filter. Too high values for
rq may blow the filter up!
The amount of boost (when positive) or attenuation (when negative) applied to the frequency band, in decibels.
Mixes the channels of a signal together.
Mixes the channels of a signal together. Works exactly like the sclang counterpart.
Here are some examples:
Mix(SinOsc.ar(440 :: 660 :: Nil)) --> SinOsc.ar(440) + SinOsc.ar(660) Mix(SinOsc.ar(440)) --> SinOsc.ar(440) Mix(Pan2.ar(SinOsc.ar)) --> left + right Mix(Pan2.ar(SinOsc.ar(440 :: 660 :: Nil))) --> [left(440) + left(660), right(440) + right(660)]
A Moog VCF style UGen.
A Moog VCF style UGen. This is a type of resonant low pass filter.
The design of this filter is described in Federico Fontana, "Preserving the Digital Structure of the Moog VCF." In: Proceedings of the ICMC, Copenhagen 2007. Ported to SuperCollider by Dan Stowell.
cutoff frequency in Hertz
filter resonance gain, between 0 and 4
when greater than zero, this will reset the state of the digital filters at the beginning of the next control block.
A UGen that switches between two input signal depending on which is changing more.
A UGen that switches between two input signal depending on which is changing more. Change is based on the absolute of the differentiation of the respective signals.
first input signal to select from
second input signal to select from
A UGen that outputs two different values depending on whether the mouse button is pressed.
A UGen that outputs two different values depending on whether the mouse button is pressed. This is useful for testing purposes. Mouse interaction with the regular desktop and windowing system is in no way altered by running this UGen.
value output while button is not pressed
value output while button is pressed
60 dB decay time of a lag-time smoothing. Use zero to avoid any smoothing.
A UGen that maps the horizontal screen location of the mouse to a given linear or exponential range.
A UGen that maps the horizontal screen location of the mouse to a given linear or exponential range. This is useful for testing purposes. Mouse interaction with the regular desktop and windowing system is in no way altered by running this UGen.
value when the mouse is on the left side of the screen
value when the mouse is on the right side of the
screen. Note: this value is never reached, because
the maximum mouse coordinate is one pixel less than the
screen size. For example, if the screen width is 1440,
lo is 0.0 and hi is 1.0, the maximum value output is
1.0 * 1439/1440 = 0.999306 .
curve shape. Either zero (default) for a linear
mapping, or 1 for an exponential mapping. Note:
When using exponential mapping, make sure the lo value
is greater than zero, otherwise NaN values will be
output.
60 dB decay time of a lag-time smoothing. Use zero to avoid any smoothing.
A UGen that maps the vertical screen location of the mouse to a given linear or exponential range.
A UGen that maps the vertical screen location of the mouse to a given linear or
exponential range. The lo value corresponds to the bottom of the screen,
and the hi value corresponds to the top of the screen (not vice-versa).
This UGen is useful for testing purposes. Mouse interaction with the regular desktop and windowing system is in no way altered by running this UGen.
value when the mouse is on the bottom side of the
screen. Note: this value is never reached, because
the maximum mouse coordinate is one pixel less than the
screen height. For example, if the screen height is 900,
lo is 0.0 and hi is 1.0, the minimum value output is
1.0 - 1.0 * 899.0/900 = 0.001111 .
value when the mouse is on the top side of the screen
curve shape. Either zero (default) for a linear
mapping, or 1 for an exponential mapping. Note:
When using exponential mapping, make sure the lo value
is greater than zero, otherwise NaN values will be
output.
60 dB decay time of a lag-time smoothing. Use zero to avoid any smoothing.
A scalar UGen that generates a single random decimal value, averaging a given
number of samples from a uniform distribution between lo and hi .
A scalar UGen that generates a single random decimal value, averaging a given
number of samples from a uniform distribution between lo and hi .
lower limit of the output range
upper limit of the output range
the number of random numbers to average. For n = 1 ,
the result is identical to Rand , for n = 2 , the
distribution is triangular, and for larger values the
distribution converges towards a Gaussian.
Warning: The value should be not be less than one.
Identifier of the node which contains the UGen.
Identifier of the node which contains the UGen.
A UGen that normalizes the input amplitude to the given level.
A UGen that normalizes the input amplitude to the given level. Unlike
Compander , this UGen will not overshoot, but it needs to look ahead in the
input signal, introducing a delay in its output. The delay time is equal to
twice the value of the dur parameter (the buffer internally used).
input signal to be normalized
peak output amplitude level to which to normalize the input
look-ahead time in seconds. Shorter times will produce smaller delays and quicker transient response times, but may introduce amplitude modulation artifacts. (init-time only)
Number of audio buses.
Number of audio buses.
Maximum number of audio buffers.
Maximum number of audio buffers.
A graph element that produces an integer with number-of-channels of the input element.
A graph element that produces an integer with number-of-channels of the input element.
the element whose number-of-channels to produce
Number of control buses.
Number of control buses.
Number of input buses.
Number of input buses.
Number of output buses.
Number of output buses.
Number of currently running synths.
Number of currently running synths.
A helper UGen equivalent to SampleRate.ir * 0.5.
A UGen that writes a signal onto a bus, delaying the signal such that the input will begin to appear on the bus precisely when the encompassing Synth was scheduled according to its OSC bundle.
A UGen that writes a signal onto a bus, delaying the signal such that the input
will begin to appear on the bus precisely when the encompassing Synth was
scheduled according to its OSC bundle. I.e. if the synth is scheduled to be
started part way through a control cycle, OffsetOut will maintain the correct
offset by buffering the output and delaying it until the exact time that the
synth was scheduled for.
This UGen adds ("mixes") the input-signal to the existing contents of the bus.
Multi-channel input signals, for example a PanAz , are written as such to the
bus without expansion. That is, the bus index argument is used for the first
channel, the second channel will appear on bus + 1 , etc.
If you have an expanding multi-channel input, however, you have to be careful.
For example, if you have
PanAz.ar(2, SinOsc.ar(Seq(444, 555, 666)) * 0.2, Seq(-1, 0, 1)) , this results
in one output UGen carrying one channel, and another one carrying two channels.
(The way this works is consistent with SCLang). In order to get the correct
behaviour (left outputs of the PanAz summed, and right output of the PanAz
summed), wrap this expression in a Mix(...) before passing it to the output
UGen.
Note: You cannot currently achieve sample accurate scheduling in SuperCollider. This UGen is therefore more or less useless.
bus index to write to. For an audio-rate UGen, this is an audio-bus, for a control-rate UGen, this is a control-bus.
signal to write to the bus. If the UGen is audio-rate, the input must also be audio-rate.
A one pole (IIR) filter UGen.
A one zero (FIR) filter UGen.
A one zero (FIR) filter UGen. Implements the formula :
out(i) = ((1 - abs(coef)) * in(i)) + (coef * in(i-1))
input signal to be processed
feed forward coefficient. +0.5 makes a two point
averaging filter (see also LPZ1 ), -0.5 makes a
differentiator (see also HPZ1 ), +1 makes a single
sample delay (see also Delay1 ), -1 makes an inverted
single sample delay.
An onset detecting UGen for musical audio signals.
An onset detecting UGen for musical audio signals. It detects the beginning of notes/drumbeats/etc. Outputs a control-rate trigger signal which is 1 when an onset is detected, and 0 otherwise.
The onset detection should work well for a general range of monophonic and polyphonic audio signals. The onset detection is purely based on signal analysis and does not make use of any "top-down" inferences such as tempo.
There are different functions available for the analysis:
- 0 "power" -- generally OK, good for percussive input, and also very efficient - 1 "magsum" -- generally OK, good for percussive input, and also very efficient - 2 "complex" -- performs generally very well, but more CPU-intensive - 3 "rcomplex" (default) -- performs generally very well, and slightly more efficient than "complex" - 4 "phase" -- generally good, especially for tonal input, medium efficiency - 5 "wphase" -- generally very good, especially for tonal input, medium efficiency - 6 "mkl" -- generally very good, medium efficiency, pretty different from the other methods
The differences aren't large, so it is recommended you stick with the default "rcomplex" unless you find specific problems with it. Then maybe try "wphase". The "mkl" type is a bit different from the others so maybe try that too. They all have slightly different characteristics, and in tests perform at a similar quality level.
the output (buffer) of an FFT UGen which transforms the audio input to track. For the FFT chain, you should typically use a frame size of 512 or 1024 (at 44.1 kHz sampling rate) and 50% hop size (which is the default setting in SC). For different sampling rates choose an FFT size to cover a similar time-span (around 10 to 20 ms).
the detection threshold, typically between 0 and 1, although in rare cases you may find values outside this range useful
index of a function to be used to analyse the signal. See main paragraph for possible values (usually can be left to default).
(advanced setting) Specifies the time (in seconds) for the normalisation to "forget" about a recent onset. If you find too much re-triggering (e.g. as a note dies away unevenly) then you might wish to increase this value. Not used with "mkl".
(advanced setting) This is a lower limit, connected to the idea of how quiet the sound is expected to get without becoming indistinguishable from noise. For some cleanly-recorded classical music with wide dynamic variations, it was found helpful to go down as far as 1e-6. Not used with "mkl".
(advanced setting) Specifies a minimum gap (in FFT frames) between onset detections, a brute-force way to prevent too many doubled detections.
(advanced setting) Specifies the size (in FFT frames) of the median window used for smoothing the detection function before triggering.
(advanced setting) ?
(advanced setting) ? (init-time only)
A UGen that writes a signal onto a bus.
A UGen that writes a signal onto a bus. It adds ("mixes") the input-signal to the existing contents of the bus.
Multi-channel input signals, for example a PanAz , are written as such to the
bus without expansion. That is, the bus index argument is used for the first
channel, the second channel will appear on bus + 1 , etc.
If you have an expanding multi-channel input, however, you have to be careful.
For example, if you have
PanAz.ar(2, SinOsc.ar(Seq(444, 555, 666)) * 0.2, Seq(-1, 0, 1)) , this results
in one output UGen carrying one channel, and another one carrying two channels.
(The way this works is consistent with SCLang). In order to get the correct
behaviour (left outputs of the PanAz summed, and right output of the PanAz
summed), wrap this expression in a Mix(...) before passing it to the output
UGen.
bus index to write to. For an audio-rate UGen, this is an audio-bus, for a control-rate UGen, this is a control-bus. Note that the bus index can only be modulated at control-rate.
signal to write to the bus. If the UGen is audio-rate, the input must also be audio-rate.
A phase vocoder UGen that performs a complex addition of the two inputs.
A phase vocoder UGen that performs a complex addition of the two inputs. The
formula is (Re(A) + Re(B)) + i(Im(A) + Im(B)) .
the first FFT'ed buffer (this gets replaced by the output signal)
the second FFT'ed buffer
A phase vocoder UGen that randomizes the order of the bins.
A phase vocoder UGen that randomizes the order of the bins. The trigger will select a new random ordering.
the FFT'ed buffer
the amount of bins scrambled, from 0 (none) to 1 (all bins scrambled).
a value from zero to one, indicating the maximum randomized distance of a bin from its original location in the spectrum.
causes a new random bin re-ordering to be made. a trigger occurs when passing from non-positive to positive value.
A phase vocoder UGen that stretches and shifts the spectrum.
A phase vocoder UGen that stretches and shifts the spectrum. It takes each bin, first stretches (scales) its position (bin number) with a given factor, and then adds a shift to it.
the FFT'ed buffer
the factor to multiply each bin position with, where 0.5 kind of transposes the signal down by an octave, and 2 transposes it up by an octave.
the translation of the spectrum, in number of bins. Since the FFT produces a linear frequency axis, the will produce harmonic distortion.
A phase vocoder UGen that combine low and high bins from two inputs.
A phase vocoder UGen that combine low and high bins from two inputs. It does so by copying low bins from one input and the high bins of the other, thus realizes a kind of "wipe" between the two input signals.
the first FFT'ed buffer (this gets replaced by the output signal)
the second FFT'ed buffer
can range between -1 and +1. if wipe == 0 then the output is the same as inA. if wipe > 0 then it begins replacing with bins from inB from the bottom up. if wipe < 0 then it begins replacing with bins from inB from the top down.
A phase vocoder UGen that clears bins above or below a cutoff point.
A phase vocoder UGen that clears bins above or below a cutoff point.
the FFT'ed buffer
can range between -1 and +1. if wipe == 0 then there is no effect. if wipe > 0 then it acts like a high pass filter, clearing bins from the bottom up. if wipe < 0 then it acts like a low pass filter, clearing bins from the top down.
A UGen that applies the conformal mapping z => (z - a) / (1 - za*) to its
input FFT bins z .
A UGen that applies the conformal mapping z => (z - a) / (1 - za*) to its
input FFT bins z .
It makes a transformation of the complex plane so the output is full of phase
vocoder artifacts but may be musically interesting. One should usually keep
|a| < 1 , although bigger values may be used to produce noise. A value of
a = 0 gives back the input mostly unperturbed.
the FFT'ed buffer
real part of the complex parameter a
imaginary part of the complex parameter a
A phase vocoder UGen that converts the bins into their complex conjugate counterparts.
A phase vocoder UGen that converts the bins into their complex conjugate counterparts. The complex conjugate is equal to the input, but with reversed sign of the imaginary part.
the FFT'ed buffer
A phase vocoder UGen that copies the spectral frames from chainA to chainB.
A phase vocoder UGen that copies the spectral frames from chainA to chainB. This allows for parallel processing of spectral data without the need for multiple FFT UGens, and to copy out data at that point in the chain for other purposes. chainA and chainB must be the same size. The output will carry further chainA, so you chan insert the ugen at the appropriate place in the signal chain.
the first FFT'ed buffer (this gets replaced by the output signal)
the second FFT'ed buffer
A phase vocoder UGen that combines the magnitudes of first input and phases of the second input.
A phase vocoder UGen that combines the magnitudes of first input and phases of the second input. phases of the first input.
the first FFT'ed buffer (this gets replaced by the output signal)
the second FFT'ed buffer
A phase vocoder UGen that adds a different constant random phase shift to each bin.
A phase vocoder UGen that adds a different constant random phase shift to each bin. The trigger will select a new set of random phases.
the FFT'ed buffer
to trigger a new selection of random phases. A trigger occurs when passing from non-positive to positive value.
A phase vocoder UGen that performs a complex division of the two inputs.
A phase vocoder UGen that performs a complex division of the two inputs. Be
careful that chainB , the divisor, does not contain zeroes as they would
obviously blow up the division.
the first FFT'ed buffer (this gets replaced by the output signal)
the second FFT'ed buffer
An FFT based onset detector UGen using a balance of two features.
An FFT based onset detector UGen using a balance of two features. It is based on work described in Hainsworth (2003), "Techniques for the Automated Analysis of Musical Audio," PhD thesis, University of Cambridge. See especially p. 128. The Hainsworth metric is a modification of the Kullback Liebler distance.
the fft signal (buffer) to analyze
what strength of detection signal from Hainsworth metric (0 to 1) to use.
what strength of detection signal from normalized Foote metric (0 to 1) to use.
threshold level for detection
after an onset is detected, further detections are suppressed for this period in seconds, preventing multiple rapid triggers
An FFT based onset detector UGen using a mix of extracted features.
An FFT based onset detector UGen using a mix of extracted features. It is based on work described in Jensen and Andersen (2003), "Real-time Beat Estimation Using Feature Extraction," in: Proceedings of the Computer Music Modeling and Retrieval Symposium.
First order derivatives of the features are taken. The threshold may need to be set low to pick up on changes.
the fft signal (buffer) to analyze
proportion (0 to 1) of spectral centroid feature
proportion (0 to 1) of high frequency energy feature
proportion (0 to 1) of high frequency content feature
proportion (0 to 1) of spectral flux feature
threshold level for detection
after an onset is detected, further detections are suppressed for this period in seconds, preventing multiple rapid triggers
A phase vocoder UGen that passes only those bins whose magnitudes constitute local maxima.
A phase vocoder UGen that passes only those bins whose magnitudes constitute local maxima. Additionally, the given threshold is also used to filter out bins whose magnitude lies below this threshold.
the FFT'ed buffer
magnitude threshold used for general filtering, prior to the local-maximum-filtering
A phase vocoder UGen that passes only those bins whose magnitudes are above a given threshold.
A phase vocoder UGen that passes only those bins whose magnitudes are above a given threshold.
the FFT'ed buffer
magnitude threshold.
A phase vocoder UGen that passes only those bins whose magnitudes are below a given threshold.
A phase vocoder UGen that passes only those bins whose magnitudes are below a given threshold.
the FFT'ed buffer
magnitude threshold.
A phase vocoder UGen that limits (clips) the magnitude of the bins to a given threshold.
A phase vocoder UGen that limits (clips) the magnitude of the bins to a given threshold.
the FFT'ed buffer
magnitude threshold. Each bin's magnitude is limited to be not greater than this threshold.
A phase vocoder UGen that divides magnitudes of two inputs and keeps the phases of the first input.
A phase vocoder UGen that divides magnitudes of two inputs and keeps the phases of the first input.
the first FFT'ed buffer (this gets replaced by the output signal)
the second FFT'ed buffer
the noise floor to assume when detecting zero bins in
chainB that would cause a division by zero and hence
blow up. The ugen will use divide by this magnitude
instead when zeroes are detected, resulting in a maximum
boost of zeroes.reciprocal .
A phase vocoder UGen that freezes the magnitudes at current levels.
A phase vocoder UGen that freezes the magnitudes at current levels. Freezing happens when the freeze input has a value of > 0.
the FFT'ed buffer
whether the current levels are frozen (> 0) or not (0).
A phase vocoder UGen that multiplies the magnitudes of two inputs and keeps the phases of the first input.
A phase vocoder UGen that multiplies the magnitudes of two inputs and keeps the phases of the first input.
the first FFT'ed buffer (this gets replaced by the output signal)
the second FFT'ed buffer
A phase vocoder UGen that multiplies the magnitudes by random noise.
A phase vocoder UGen that multiplies the magnitudes by random noise.
the FFT'ed buffer
A phase vocoder UGen that stretches and shifts the magnitudes of the spectrum.
A phase vocoder UGen that stretches and shifts the magnitudes of the spectrum.
This is live PV_BinShift but instead of scaling and shifting the whole complex
bins (magnitude and phase), this only operates on the magnitudes and leaves the
phases in their original bins.
the FFT'ed buffer
the factor to multiply each bin position with
the translation of the spectrum, in number of bins
A phase vocoder UGen that averages each bin's magnitude with its neighbors.
A phase vocoder UGen that averages each bin's magnitude with its neighbors.
the FFT'ed buffer
number of bins to average on each side of bin. As this number rises, so will CPU usage.
A phase vocoder UGen that squares the magnitudes and re-normalizes to previous peak.
A phase vocoder UGen that squares the magnitudes and re-normalizes to previous peak. This makes weak bins weaker.
the FFT'ed buffer
A phase vocoder UGen that outputs the bins with the maximum magnitude of the two inputs.
A phase vocoder UGen that outputs the bins with the maximum magnitude of the two inputs.
the first FFT'ed buffer (this gets replaced by the output signal)
the second FFT'ed buffer
A phase vocoder UGen that outputs the bins with the minimum magnitude of the two inputs.
A phase vocoder UGen that outputs the bins with the minimum magnitude of the two inputs.
the first FFT'ed buffer (this gets replaced by the output signal)
the second FFT'ed buffer
A phase vocoder UGen that performs a complex multiplication of the two inputs.
A phase vocoder UGen that performs a complex multiplication of the two inputs.
The formula is
(Re(A) * Re(B) - Im(A) * Im(B)) + i(Im(A) * Re(B) + Re(A) * Im(B)) .
the first FFT'ed buffer (this gets replaced by the output signal)
the second FFT'ed buffer
A phase vocoder UGen that shifts the phase of each bins by a given amount.
A phase vocoder UGen that shifts the phase of each bins by a given amount.
the FFT'ed buffer
phase shift in radians
A phase vocoder UGen that shift the phase of all bins by 270 (or -90) degrees.
A phase vocoder UGen that shift the phase of all bins by 270 (or -90) degrees.
the FFT'ed buffer
A phase vocoder UGen that shift the phase of all bins by 90 degrees.
A phase vocoder UGen that shift the phase of all bins by 90 degrees.
the FFT'ed buffer
A phase vocoder UGen that randomly clears out bins of the signal.
A phase vocoder UGen that randomly clears out bins of the signal. Which bins are wiped out is subject to a random choice (only the amount is specified) that remains constant between triggers.
the FFT'ed buffer
the probability (from 0 to 1) of bins being wiped out, hence 0 means no bins are wiped out, 1 means all bins are wiped out (output will be silence).
causes a new random bin selection to be made. a trigger occurs when passing from non-positive to positive value.
A phase vocoder UGen that cross-fades between two input spectra by taking bins randomly from them according to a given probability.
A phase vocoder UGen that cross-fades between two input spectra by taking bins randomly from them according to a given probability.
the first FFT'ed buffer (this gets replaced by the output signal)
the second FFT'ed buffer
the crossfader position from 0.0 (all bins are taken
from chainA ) to 1.0 (all bins are taken from chainB
). For instance, if wipe is 0.5, half of the bins are
taken from either input. The decision whether a bin is
taken from A or B is random, however remains constant
between two triggers.
a signal the triggers the re-newed process of determining for each bin whether it will be taken from input A or B. A trigger occurs when passing from non-positive to positive value.
A phase vocoder UGen that makes a series of gaps in a spectrum.
A phase vocoder UGen that makes a series of gaps in a spectrum. This is done by multiplying the spectrum with a kind of rectangle wave that goes from zero to nyquist. The high slope of the rectangle lets the input bins pass (quasi pass-band), the low slope filters them out (quasi stop-band).
the FFT'ed buffer
the number of periods in the rectangle wave, where zero would mean the input signal is not affected, one means that there is exactly one period of the wave across the spectrum, hence one pass-band and one stop-band.
the phase offset of the rectangle wave, where 1.0 is one full period. This is like the offset into the wavetable holding the rectangle, so a value of 0.25 means we start 25% into the basic waveform, and after 0.75 periods the next full period (high slope) begins.
the pulse width between 0.0 (infinitely small high slope, so all bins filtered out) to 0.5 (half period is high slope, half period is low slope) to 1.0 (maximally wide high slope, no bins filtered out).
A phase vocoder UGen that switches between two input spectra according to a rectangle wave.
A phase vocoder UGen that switches between two input spectra according to a
rectangle wave. This is basically identical to PV_RectComb , however during
the low slopes of the rectangle wave, instead of clearing out the bins, it
copies over the corresponding bins of the second fft input buffer.
the first FFT'ed buffer (this gets replaced by the output signal)
the second FFT'ed buffer
the number of periods in the rectangle wave, where zero would mean the first input signal is fully passed through, one means that there is exactly one period of the wave across the spectrum, hence one pass-band (first signal passed through) and one stop-band (second signal passed through).
the phase offset of the rectangle wave, where 1.0 is one full period. This is like the offset into the wavetable holding the rectangle, so a value of 0.25 means we start 25% into the basic waveform, and after 0.75 periods the next full period (high slope) begins.
the pulse width between 0.0 (infinitely small high slope, so all bins are copied from the second input) to 0.5 (half period is high slope -- copied from first input --, half period is low slope -- copied from second input) to 1.0 (maximally wide high slope, so all bins passed from the first input).
A UGen that writes a complex input signal into an FFT buffer.
A UGen that writes a complex input signal into an FFT buffer. The input is a sequence of interleaved magnitudes and phases. It is written to an FFT buffer ready for transforming it back into time-domain audio using IFFT.
input data to pack. It should be a flat sequence containing interleaved magnitude and phase components of all bins in ascending order. E.g. [mag0, phase0, mag1, phase1, mag2, phase2, ... magN, phaseN]. This input is typically demand-rate.
index of lower bin
index of upper bin (inclusive)
if 1 , clears the buffer before packing the values,
setting its contents to zero.
A graph element that controls the multi-channel expansion of
its in argument to match the to argument by padding (extending
and wrapping) it.
A graph element that controls the multi-channel expansion of
its in argument to match the to argument by padding (extending
and wrapping) it.
the element to replicate
the reference element that controls the multi-channel expansion.
the signal itself is not used or output by Pad.
A stereo panorama UGen based on equal-power amplitude control.
A stereo panorama UGen based on equal-power amplitude control. When in center
position ( pos = 0 ), the signal is attenuated by sqrt(0.5) or approx. -3 dB.
(monophonic) input signal to be panned
panorama position between -1 (hard left) via 0 (center) to +1 (hard right)
additional gain control
A four channel equal-power panorama UGen.
A four channel equal-power panorama UGen. The outputs are in order leftFront
, rightFront , leftBack , rightBack .
(monophonic) input signal to be panned
horizontal panorama position from -1 (left) to +1 (right)
front-to-back panorama position from -1 (back) to +1 (front)
additional gain control
An azimuth-based panorama UGen.
An azimuth-based panorama UGen. It uses vector-based-amplitude panning where
the arbitrary number of speakers is supposed to be distributed in a circle with
even spacing between them. It uses an equal-power-curve to transition between
adjacent speakers. Note the different default value for the orient
argument!
Use case: To spread an multi-channel input signal across an output bus with a
different number of channels, such that the first input channel is played on the
first output channel (no spread to adjacent channels) and the last input channel
is played to the last output channel (no spread to adjacent channels), you would
create a dedicated PanAz per input channel where the pan position is
inChanIdx * 2f / (inChannels - 1) * (outChannels - 1) / outChannels .
the number of output channels
the input signal
the pan position. Channels are evenly spaced over a
cyclic period of 2.0. the output channel position is
pos / 2 * numChannels + orient . Thus, assuming an
orient of 0.0 , and numChannels being for example
3 , a pos of 0*2.0/3 == 0.0 corresponds to the
first output channel, a pos of 1*2.0/3 corresponds
to the second output channel, a pos of 2*2.0/3=4.0/3
corresponds to the third and last output channel, and a
pos of 3*2.0/3=2.0 completes the circle and wraps
again to the first channel. Using a bipolar pan
position, such as a sawtooth that ranges from -1 to +1,
all channels will be cyclically panned through. Must be
control rate.
a control rate level input (linear multiplier).
the width of the panning envelope. The default of 2.0 pans between pairs of adjacent speakers. Width values greater than two will spread the pan over greater numbers of speakers. Width values less than one will leave silent gaps between speakers.
the offset in the output channels regarding a pan
position of zero. Note that ScalaCollider uses a default
of zero which means that a pan pos of zero outputs the
signal exactly on the first output channel. This is
different in sclang where the default is 0.5 which means
that a pan position of zero will output the signal
between the first and second speaker. Accordingly, an
orient of 1.0 would result in a channel offset of
one, where a pan position of zero would output the
signal exactly on the second output channel, and so
forth.
An Ambisonics B-format encoding UGen.
An Ambisonics B-format encoding UGen. B-format is the name for first order Ambisonics which has four channels W, X, Y, Z. By omitting the elevation control, we get a two dimensional planar encoded signal consisting only of the X and Y channels.
Note that unlike PanB2, azimuth is in radians.
(monophonic) input signal to be encoded
position around the circle in radians. -Pi/+Pi is behind, -Pi/2 is left, 0 is front, +Pi/2 is right.
elevation in radians, from -Pi/2 (bottom) to +Pi/2 (top)
additional gain control
A two dimensional Ambisonics B-format encoding UGen.
A two dimensional Ambisonics B-format encoding UGen. B-format is the name for first order Ambisonics which normally has four channels W, X, Y, Z. By omitting the elevation control, we get a two dimensional planar encoded signal consisting only of the W, X and Y channels.
Note that unlike PanB, azimuth is normalized between -1 and +1.
(monophonic) input signal to be encoded
position around the circle from -1 to +1. -1 and +1 correspond to -180/+180 degrees (behind), -0.5 is 90 degrees to the left, 0 is frontal, +0.5 is 90 degrees to the right.
additional gain control
A UGen for partitioned convolution.
A UGen for partitioned convolution. Its advantage over non-partitioning UGens
such as Convolution2 is that the impulse response can be arbitrarily large
amortization is used to spread processing and avoid CPU spikes.
The impulse response buffer must be specially prepared, using a /b_gen
command that transforms an existing regularly formatted buffer to a new
partitioned convolution ready buffer.
the realtime input to be convolved
FFT size which is twice the input signal partition size. This must be a multiple of the control-block size, and there must be at least two blocks per partition (to allow for amortization) (init-time only)
buffer identifier for the fixed kernel (init-time only). (init-time only)
A UGen which pauses and resumes another node.
A UGen which pauses and resumes another node. Note that the UGen initially
assumes the node is running, that is, if gate is initially 1, this will
not resume a paused node. Instead, the gate must go to zero and back to
one to resume the node. Additionally, this UGen will only cause action if the
gate value changes, that is, if the node is paused or resumed otherwise, this
UGen will not interfere with that action, unless the gate value is adjusted.
when 0, node is paused, when 1, node is resumed
the id of the node to be paused or resumed
A UGen that, when triggered, pauses enclosing synth.
A UGen that, when triggered, pauses enclosing synth. It pauses the enclosing synth when the input signal crosses from non-positive to positive.
Note that if the trigger is initially high the UGen will not react. For
example, PauseSelf.kr("foo".kr) will not work if the control is initially 1
. A work-around is to wrap the input in this case in a Trig object:
PauseSelf.kr(Trig.kr("foo".kr)) . This is most likely a bug.
This UGen outputs its input signal for convenience.
the input signal which will trigger the action.
A UGen that, when its input UGen is finished, pauses enclosing synth.
A UGen that, when its input UGen is finished, pauses enclosing synth. This is
essentially a shortcut for PauseSelf.kr(Done.kr(src)) , so instead of
providing a trigger signal it reads directly the done flag of an appropriate
ugen (such as Line or PlayBuf ).
This UGen outputs its input signal for convenience.
the input UGen which when finished will trigger the action.
A UGen to measure a signal's peak amplitude.
A UGen to measure a signal's peak amplitude. Technically, this UGen works like
RunningMax after the absolute value of the input signal is taken.
The UGen keeps an internal state that reflects the maximum absolute input value observed. When a trigger occurs at the reset input, it first copies the current maximum value to its output and then (quasi-simultaneously) resets its internal state to the current absolute input value. This way, the peak value seen from the outside at trigger time is the correct peak value up to that moment. See the 'illustrate timing' example to understand this timing.
input signal to analyze
resets the maximum observed value to the current absolute value of the input signal
A UGen that continually reports the peak amplitude of the signal received at the input.
A UGen that continually reports the peak amplitude of the signal received at
the input. If the absolute input level drops below the observed peak value, this
value decreases by the factor given as decay parameter (but no more than the
current absolute input level).
input signal to trace
feedback coefficient controlling the release rate. This should be less than one, otherwise the UGen may blow up.
A linear repeating ramp UGen between start and end values.
A linear repeating ramp UGen between start and end values. Using a trigger
input, it can be reset to a specific position. Upon reaching the end of its
ramp, Phasor will wrap back to its start value. Note: Since end is
defined as the wrap point, its value is never actually output.
trigger signal that causes the phasor to jump to the
resetVal position
amount of increment per sample frame. I.e at a
speed of 1, each sample output by the UGen will be 1
greater than the preceding sample. To achieve a specific
frequency f in Hertz, use a speed value of
f / SampleRate.ir .
start value of the ramp
end value of the ramp (exclusive)
value to jump to upon receiving a trigger in the trig
input
A graph element which reads from a connected sound driver input.
A graph element which reads from a connected sound driver input. This is a convenience
element for accessing physical input signals, e.g. from a microphone connected to your
audio interface. It expands to a regular In UGen offset by NumOutputBuses.ir.
For example, consider an audio interface with channels 1 to 8 being analog line inputs, channels 9 and 10 being AES/EBU and channels 11 to 18 being ADAT inputs. To read a combination of the analog and ADAT inputs, either of the following statement can be used:
PhysicalIn(Seq(0, 8), Seq(8, 8)) PhysicalIn(Seq(0, 8), Seq(8)) // numChannels wraps!
the physical index to read from (beginning at zero which corresponds to the first channel of the audio interface or sound driver). Maybe be a multichannel element to specify discrete indices.
the number of consecutive channels to read for each index. Wraps around if the sequence has less elements than indices has channels.
A noise generator UGen whose spectrum falls off in power by 3 dB per octave.
A noise generator UGen whose spectrum falls off in power by 3 dB per octave. This gives equal power over the span of each octave. This version gives 8 octaves of pink noise.
The values produced by this UGen were observed to lie with very high
probability between approx. -0.65 and +0.81 (before being multiplied by
mul ). The RMS is approx. -16 dB.
Not actually a UGen input, this argument produces a
multiplication of the output by this factor. A
multi-channel mul argument will cause the generation
of multiple independent noise generators.
An autocorrelation based pitch following UGen.
An autocorrelation based pitch following UGen. It is more accurate than
ZeroCrossing , but more also more CPU costly. For most purposes the default
settings can be used and only in needs to be supplied.
The UGen has two outputs: The first output is the frequency estimate in Hertz,
the second output is a toggle hasFreq , which tells whether a pitch was found
(1) or not (0). If the clarify argument is used, hasFreq has more fine
grained information.
The pitch follower executes periodically at the rate specified by execFreq in
cps. First it detects whether the input peak to peak amplitude is above the
ampThresh . If it is not then no pitch estimation is performed, the hasFreq
output is set to zero and the freq output is held at its previous value.
Otherwise, the autocorrelation is calculated, and the first peak after the peak
around the lag of zero that is above peakThresh times the amplitude of the
peak at lag zero is reported.
The signal to be analyzed.
The initial value of the freq output, until the first
valid pitch is found. (init-time only)
The minimum frequency in Hertz to be considered for reporting. (init-time only)
The maximum frequency in Hertz to be considered for reporting. (init-time only)
The frequency at which the pitch is estimated. This
will be automatically clipped to be between minFreq
and maxFreq . (init-time only)
A value which guides the search for the peak frequency in the first coarse step. Its setting does *not* affect the final pitch resolution; setting it larger will cause the coarse search to take longer, and setting it smaller will cause the fine search to take longer. (init-time only)
This specifies the length of a median filter applied to
the frequency output estimation. With the default value
of 1 the filter is defeated. Median filtering can help
eliminating single spikes and jitter. This will however
add latency to the output. (init-time only)
The minimum amplitude threshold above which the pitch follower operates. An input signal below this threshold is not analyzed. (init-time only)
This is a threshold used to find the first peak in the
autocorrelation signal which gives the reported
frequency. It is a factor of the energy of the signal
(autocorrelation coefficient at zero). Set this value
higher (e.g. to 1 ) to eliminate false frequencies
corresponding to overtones. (init-time only)
An integer factor by which the input signal is down
sampled to reduce CPU overhead. This will also reduce
the pitch resolution. The default value of 1 means
that the input signal is not down sampled. (init-time
only)
If the clarity argument is greater than zero (it is
zero by default) then the hasFreq output is given
additional detail. Rather than simply being 1 when a
pitch is detected, it is a "clarity" measure in the
range between zero and one. (Technically, it's the
height of the autocorrelation peak normalised by the
height of the zero-lag peak.) It therefore gives a kind
of measure of "purity" of the pitched signal.
(init-time only)
A time domain granular pitch shifter.
A time domain granular pitch shifter. Grains have a triangular amplitude envelope and an overlap of 4:1.
The input signal.
The size of the grain window in seconds. (init-time only)
The ratio of the pitch shift. Must be from 0 to 4.
The maximum random deviation of the pitch from the pitchRatio.
A random offset of from zero to timeDispersion seconds is added to the delay of each grain. Use of some dispersion can alleviate a hard comb filter effect due to uniform grain placement. It can also be an effect in itself. timeDispersion can be no larger than windowSize.
A UGen to play back samples from a buffer in memory.
A UGen to play back samples from a buffer in memory.
PlayBuf provides a kind of high-level interface to sample-playback, whereas
BufRd represents a kind of lower-level access. While BufRd has a
random-access-pointer in the form of a phase input, PlayBuf advances the phase
automatically based on a given playback speed. PlayBuf uses cubic
interpolation.
the number of channels that the buffer will be. Since this is a constant, a change in number of channels of the underlying bus must be reflected by creating different SynthDefs. If a buffer identifier is used of a buffer that has a different numChannels then specified in the PlayBuf, it will fail silently.
the identifier of the buffer to use
1 advances the play head by the server's sample rate
each second. So 2 means doubling speed (and pitch), and
0.5 means half speed (and half pitch). Negative numbers
can be used for backwards playback. If the underlying
buffer represents a sound at a different sample rate,
the rate should be multiplied by
BufRateScale.kr(bufID) to obtain the correct speed.
a trigger which causes a jump to the given offset . A
trigger occurs when a signal changes from non-positive
to positive (e.g. <= 0 to > 0).
sample frame to start playback. This is read when a trigger occurs. It may be fractional.
1 to loop after the play head reaches the buffer end, 0 to not loop. This can be modulated.
what to do when the play head reaches the buffer end.
This is only effective when loop is zero.
A Karplus-Strong UGen.
A Karplus-Strong UGen.
An excitation signal.
Upon a negative to positive transition, the excitation signal will be fed into the delay line.
Maximum delay time in seconds (initializes the internal delay buffer). (init-time only)
Delay time in seconds.
Time for the echoes to decay by 60 decibels. Negative times emphasize odd partials.
the coefficient of the internal OnePole filter. Values should be between -1 and +1 (larger values will be unstable... so be careful!).
A UGen for printing the current output value of its input to the console.
A UGen for printing the current output value of its input to the console.
a non-positive to positive transition telling Poll to return a value
the signal you want to poll
a string or symbol to be printed with the polled value
if greater then 0, a "/tr" OSC message is sent back
to the client (similar to SendTrig )
A band-limited pulse wave generator UGen, capable of pulse width modulation.
A band-limited pulse wave generator UGen, capable of pulse width modulation.
Fundamental frequency in Hertz
Pulse width ratio from zero to one. 0.5 makes a
square wave.
A UGen that counts the number of triggers observed.
A UGen that counts the number of triggers observed.
a trigger happens when the signal changes from non-positive to positive
when triggered, resets the counter to zero. When both
trig and reset are triggered at the same time, the
reset takes precedence (output will be zero).
A UGen that decimates trigger by outputting one impulse each time a certain number of triggers at its input have been received.
A UGen that decimates trigger by outputting one impulse each time a certain number of triggers at its input have been received.
a trigger occurs when the signal changes from non-positive to positive.
decimation factor of the UGen. A value of 1 would cause an output trigger for each input trigger, whereas a value of 2 would cause an output trigger each time the internal counter has seen two input triggers.
value of the internal counter. For example, if div is
2 , then a start value of 0 (default) means that
the first output trigger happens after two input
triggers, a start value of 1 means that the first
output trigger happens after just one input trigger.
Negative values can increase the number of required
input triggers for the first output trigger. For
example, if start is -1 , the first output trigger
happens after three input triggers.
A cubic-interpolating sound generator based on the difference equation:
A linear-interpolating sound generator based on the difference equation:
A non-interpolating sound generator based on the difference equation:
A resonant high pass filter UGen.
A resonant high pass filter UGen.
input signal to be filtered
cutoff frequency in Hertz
reciprocal of Q. The Q (or quality) is conventionally defined as cutoff-frequency / bandwidth, meaning that rq = bandwidth / cutoff-frequency. A higher Q or lower rq produces a steeper filter.
A resonant low pass filter UGen.
A resonant low pass filter UGen.
input signal to be filtered
cutoff frequency in Hertz
reciprocal of Q. The Q (or quality) is conventionally defined as cutoff-frequency / bandwidth, meaning that rq = bandwidth / cutoff-frequency. A higher Q or lower rq produces a steeper filter.
A UGen that delivers the conversion factor from frequency in Hertz to radians (normalized frequency).
A UGen that delivers the conversion factor from frequency in Hertz to radians
(normalized frequency). The relation is RadiansPerSample * sr = 2pi , thus
multiplying the UGen with a frequency between zero and nyquist (sr/2) yields the
normalized frequency between zero and pi.
A UGen which produces a linear lag (time smear) regarding and input signal.
A UGen which produces a linear lag (time smear) regarding and input signal.
Other than Lag which is a feedback filter with exponential decay, Ramp
applies a linear ramp. This is achieved by sampling the input signal at regular
intervals given by the lagTime and starting a new line segment after each
interval.
the signal to smooth out
the ramp-time (seconds) which is also the interval of the sampling
A scalar UGen that generates a single random decimal value, using a uniform
distribution from lo to hi .
A UGen that determines which random number generator is used for the enclosing synth.
A UGen that determines which random number generator is used for the enclosing synth. All synths that use the same generator reproduce the same sequence of numbers when the same seed is set again.
the random number generator identifier from zero until
the maximum number of generators specified with the
server switch -r (default: 64)
A UGen that resets the seed of the synth's random number generator upon receiving a trigger.
A UGen that resets the seed of the synth's random number generator upon
receiving a trigger. All synths that use the same random number generator
reproduce the same sequence of numbers again. The generator can be set using the
RandID UGen.
trigger that causes the seed to be set
the seed for the random number generator, read at the moment the trigger arrives.
Records input into a Buffer.
Records input into a Buffer. If recLevel is 1.0 and preLevel is 0.0 then the new input overwrites the old data. If they are both 1.0 then the new data is added to the existing data. (Any other settings are also valid.)
the signal to record
the identifier of the buffer to use
sample frame to begin writing from. This is read when a trigger occurs.
value to multiply by input before mixing with existing data.
value by which the previous buffer contents is multiplied when recording. If this value is zero, the buffer contents is completely overwritten. If this value is one, the new signal is added to the previous content.
if zero the recording pauses, otherwise it resumes. The value of run is only read at control-rate! When the recording is paused, the "write-head" remains in its current position and does not advance.
1 to loop after the write head reaches the buffer end, 0 to not loop. This can be modulated.
a trigger which causes a jump to the given offset . A
trigger occurs when a signal changes from non-positive
to positive (e.g. <= 0 to > 0).
what to do when the write head reaches the buffer end.
This is only effective when loop is zero.
A UGen that replace the contents of a bus with an input signal.
A UGen that replace the contents of a bus with an input signal. Other than
Out , the signal is not added to the previous contents of the bus but replaces
it, allowing for a simple way of an "insert" effect.
Multi-channel input signals, for example a PanAz , are written as such to the
bus without expansion. That is, the bus index argument is used for the first
channel, the second channel will appear on bus + 1 , etc.
If you have an expanding multi-channel input, however, you have to be careful.
For example, if you have
PanAz.ar(2, SinOsc.ar(Seq(444, 555, 666)) * 0.2, Seq(-1, 0, 1)) , this results
in one output UGen carrying one channel, and another one carrying two channels.
(The way this works is consistent with SCLang). In order to get the correct
behaviour (left outputs of the PanAz summed, and right output of the PanAz
summed), wrap this expression in a Mix(...) before passing it to the output
UGen.
bus index to write to. For an audio-rate UGen, this is an audio-bus, for a control-rate UGen, this is a control-bus.
signal to write to the bus. If the UGen is audio-rate, the input must also be audio-rate.
A two pole resonant filter UGen.
A two pole resonant filter UGen. It has zeroes at z = +1 and z = -1.
Based on K. Steiglitz, "A Note on Constant-Gain Digital Resonators", Computer Music Journal, vol 18, no. 4, pp. 8-10, Winter 1994.
input signal to be filtered
resonant frequency in Hertz
reciprocal of Q. The Q (or quality) is conventionally defined as center-frequency / bandwidth, meaning that rq = bandwidth / center-frequency. A higher Q or lower rq produces a steeper filter.
A resonant or "ringing" filter UGen.
A resonant or "ringing" filter UGen. This is the same as Resonz , except that
instead of a Q parameter, the bandwidth is specified as a 60 dB ring decay time.
One Ringz is equivalent to one component of the Klank UGen.
input signal to be filtered
resonant frequency in Hertz
the 60 dB decay time in seconds
A UGen that can be used for rotating an ambisonic B-format sound field around an axis.
A UGen that can be used for rotating an ambisonic B-format sound field around
an axis. It uses an equal-power rotation so it also works well on stereo sounds.
It takes two audio inputs ( x , y ) and an angle control ( pos ). It
outputs again two channels, using these formulas:
xr = cos(angle) * x + sin(angle) * y yr = cos(angle) * y - sin(angle) * x
where angle = pos * Pi . This allows, for example, the use of LFSaw to
create a continuous rotation around a circle.
Note: Be careful when accessing the output channels. xr and yr are
the X and Y output channels, whereas x and y refers to the X and Y input
channel.
B-format X input channel
B-format Y input channel
angle to rotate around the circle, normalized between -1 and +1. -1 and +1 corresponds to -180 and +180 degrees (behind), -0.5 is 90 degrees left, 0 is frontal, +0.5 is 90 degrees right.
A UGen to measure a signal's maximum value between triggers.
A UGen to measure a signal's maximum value between triggers.
The UGen keeps an internal state that reflects the maximum input value observed. When a trigger occurs at the reset input, it first copies the current maximum value to its output and then (quasi-simultaneously) resets its internal state to the current input value.
input signal to analyze
resets the maximum observed value to the current value of the input signal
A UGen to measure a signal's minimum value between triggers.
A UGen to measure a signal's minimum value between triggers.
The UGen keeps an internal state that reflects the minimum input value observed. When a trigger occurs at the reset input, it first copies the current minimum value to its output and then (quasi-simultaneously) resets its internal state to the current input value.
input signal to analyze
resets the minimum observed value to the current value of the input signal
A UGen calculating the running sum of an input signal over a given number of samples.
A UGen calculating the running sum of an input signal over a given number of samples.
the input signal to sum up
the length of the sliding window over the input signal. these are the number of audio sample-frames for audio-rate calculation, or the number of blocks for control-rate calculation summed up. Warning: The UGen crashes when length is zero. (init-time only)
A second order filter section (biquad) UGen.
A second order filter section (biquad) UGen. Filter coefficients are given directly rather than calculated for you. The formula is equivalent to:
out(i) = a0 * in(i) + a1 * in(i-1) + a2 * in(i-2) + b1 * out(i-1) + b2 * out(i-2)
input signal to be filtered
A UGen that reports the server's current (audio) sample period in seconds.
A UGen that reports the server's current (audio) sample period in seconds. This
is equivalent to the reciprocal of SampleRate
A UGen that reports the server's current (audio) sample rate.
A UGen that reports the server's current (audio) sample rate. This is
equivalent to the reciprocal of SampleDur
A band-limited sawtooth wave generator UGen.
A Schmidt trigger UGen.
A Schmidt trigger UGen. Initially it outputs zero. When the input signal rises
above hi , its output switches to 1.0, which is hold until the signal falls
below lo , switching the output again to 0.0. The produces a kind of
hysteresis behavior, preventing heavy oscillations in a noisy system which might
occur with a single-threshold trigger.
input signal to be analyzed
low threshold
high threshold
A UGen which selects among a sequence of inputs, according to an index signal.
A UGen which selects among a sequence of inputs, according to an index signal.
Note that, although only one signal of the multi input is let through at a
time, still all ugens are continuously running.
an index signal into the channels of the in argument.
The index is automatically clipped to lie between 0
and in.numOutputs - 1 . The index is truncated to its
integer part (not rounded), hence using for instance an
index of 0.9 will still be interpreted as index 0 .
a graph element which is composed of the channels to be indexed.
A UGen which sends an sequence of values from the server to all notified clients upon receiving triggers.
A UGen which sends an sequence of values from the server to all notified
clients upon receiving triggers. The message sent is
osc.Message(<(String) msgName>, <(Int) nodeID>, <(Int) replyID>, <(Float) values>*)
.
For sending a single value, SendTrig provides an alternative.
a non-positive to positive transition triggers a message
a graph element comprising the signal channels to be polled
a string specifying the OSC message's name. by convention, this should start with a forward slash and contain only 7-bit ascii characters.
an integer identifier which is contained in the reply
message. While you can distinguish different SendReply
instances from the same Synth by choosing different OSC
message names, depending on the application you may use
the same message name but different ids (similar to
SendTrig ).
The argument order is different from its sclang counterpart.
A UGen that sends a value from the server to all notified clients upon receiving triggers.
A UGen that sends a value from the server to all notified clients upon
receiving triggers. The message sent is
osc.Message("/tr", <(Int) nodeID>, <(Int) trigID>, <(Float) value>) .
For sending an array of values, or using an arbitrary reply command, see
SendReply .
the trigger signal causing the value to be read and sent. A trigger occurs when passing from non-positive to positive.
a changing signal or constant that will be polled at the time of trigger, and its value passed with the trigger message
an arbitrary integer that will be sent along with the
"/tr" message. This is useful to distinguish between
several SendTrig instances per SynthDef.
The argument order is different from its sclang counterpart.
A scalar (init-time) UGen that overwrites contents of a buffer with given values.
A flip-flop UGen with two inputs, one (set) triggering an output of 1.0, the other (reset) triggering an output of 0.0.
A flip-flop UGen with two inputs, one (set) triggering an output of 1.0, the other (reset) triggering an output of 0.0. Subsequent triggers happening within the same input slot have no effect. If both inputs receive a trigger at the same time, the reset input takes precedence.
trigger that sets output to 1. A trigger happens when the signal changes from non-positive to positive.
trigger that sets output to 0. A trigger happens when the signal changes from non-positive to positive.
A waveshaping UGen.
A waveshaping UGen. Waveshaping is a the process of translating an input signal by indexing a table (buffer).
Advanced notes: wavetable format:
Signal: [a0, a1, a2...] Wavetable: [2*a0-a1, a1-a0, 2*a1-a2, a2-a1, 2*a2-a3, a3-a2...]
This strange format is not a standard linear interpolation (integer + frac), but for (integer part -1) and (1+frac)) due to some efficient maths for integer to float conversion in the underlying C code.
buffer filled in wavetable format containing the transfer function.
signal to be fed into the wave shaper
A sinusoidal (sine tone) oscillator UGen.
A sinusoidal (sine tone) oscillator UGen. This is the same as Osc except that
it uses a built-in interpolating sine table of 8192 entries.
Note that currently (SC 3.7.x), the first frame generated is not zero
(i.e. the value of the sine oscillation at time zero) but the value at time
1 / SampleRate.ir .
frequency in Hertz
phase offset or modulator in radians
A slew rate limiter UGen.
A slew rate limiter UGen. Limits the slope of an input signal. The slope is expressed in units per second.
Since the UGen is initialized with the initial value of the input signal, some tricks must be applied to set it to an alternative start value. For example:
val in = Select.kr(ToggleFF.kr(1), Seq("start".ir, "target".kr)) Slew.kr(in) // begins at "start" and moves towards "target"
input signal
maximum upward slope.
maximum downward slope.
A UGen measuring the slope of signal.
A UGen measuring the slope of signal. It calculates the rate of change per second of a signal, as given by the following formula:
out(i) = (in(i) - in(i-1)) * sampleRate It thus equal to HPZ1.ar(_) * 2 * SampleRate.ir
input signal to be measured
A UGen to measure the spectral centroid.
A UGen to measure the spectral centroid. Given an FFT chain, this measures the spectral centroid, which is the weighted mean frequency, or the "centre of mass" of the spectrum. (DC is ignored.) This can be a useful indicator of the perceptual brightness of a signal.
Note that the output frequency is pretty close to the correct value when
feeding in a sine signal, but the estimate is usually too high when using for
example filtered noise. In that case, you will get better results using
SpecPcile at 50%.
Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.
the fft signal (buffer) to analyze
A UGen to measure spectral flatness.
A UGen to measure spectral flatness. Given an FFT chain this calculates the Spectral Flatness measure, defined as a power spectrum's geometric mean divided by its arithmetic mean. This gives a measure which ranges from approx 0 for a pure sinusoid, to approx 1 for white noise.
The measure is calculated linearly. For some applications you may wish to
convert the value to a decibel scale. Note that this UGen may output NaN
when the input is zero (probably due to division by zero). In that case,
CheckBadValues can be used to prevent further problems.
Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.
the fft signal (buffer) to analyze
A UGen to find the percentile of a signal's magnitude spectrum.
A UGen to find the percentile of a signal's magnitude spectrum. Given an FFT
chain this calculates the cumulative distribution of the frequency spectrum, and
outputs the frequency value which corresponds to the desired percentile. For
example, to find the frequency at which 90% of the spectral energy lies below
that frequency, you want the 90-percentile, which means the value of percent
should be 0.9. The 90-percentile or 95-percentile is often used as a measure of
spectral roll-off.
Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.
the fft signal (buffer) to analyze
the percentage between 0.0 (0%) and 1.0 (100%)
specifies whether interpolation should be used to try and make the percentile frequency estimate more accurate, at the cost of a little higher CPU usage. Set it to 1 to enable this.
A linear-interpolating sound generator based on the difference equations:
A linear-interpolating sound generator based on the difference equations:
x[n+1] = (x[n] + y[n+1]) % 2pi y[n+1] = (y[n] + k * sin(x[n])) % 2pi
The standard map is an area preserving map of a cylinder discovered by the plasma physicist Boris Chirikov.
Iteration frequency in Hertz
Perturbation amount
Initial value of x
Initial value of y
A non-interpolating sound generator based on the difference equations:
A non-interpolating sound generator based on the difference equations:
x[n+1] = (x[n] + y[n+1]) % 2pi y[n+1] = (y[n] + k * sin(x[n])) % 2pi
The standard map is an area preserving map of a cylinder discovered by the plasma physicist Boris Chirikov.
Iteration frequency in Hertz
Perturbation amount
Initial value of x
Initial value of y
A pulse counting UGen.
A pulse counting UGen. Each trigger increments a counter which is output as a
signal. The counter wraps inside the interval from lo to hi (inclusive).
That if you use a lo other than zero, you might want to adjust resetVal as
well. Stepper always starts with the value in resetVal , no matter what lo
is or whether the reset trigger is high or not.
The trigger signal which increments the counter. A
trigger happens when the signal changes from
non-positive to positive. Note that if the UGen is
created with the trigger initially high, the counter
will also be incremented immediately. Thus a
Stepper.kr(Impulse.kr(1)) will begin by outputting 1
. If you want to avoid this, you could their subtract
Impulse.kr(0) from the trigger input, or set
resetVal to hi . E.g.
Stepper.kr(Impulse.kr(1), lo = 0, hi = 4, resetVal = 4)
will produce the sequence 0, 1, 2, 4, 0, ...
A trigger which resets the counter to resetVal
immediately.
The minimum value output. For a decremental step
value, the counter jumps to hi if it were to fall
below lo .
The maximum value output. For an incremental step
value, the counter jumps to lo if it were to rise
beyond hi . Note that values greater than 0x7FFFFFBF
(the default) cause numeric overflow and the UGen to
malfunction.
The amount by which the counter increases or decreases
upon receiving triggers. Note that if you use a
decremental counter, still lo must be the minimum and
hi must be the maximum value output. If lo > hi ,
the UGen behaves wrongly. In the case of decremental
counter, set resetVal to hi . E.g. to count from 4
down to 0, use
Stepper.kr(trig, lo = 0, hi = 4, step = -1, resetVal = 4)
, or, if you want to ignore an initial high trigger, you
could do
Stepper.kr(Impulse.kr(1), lo = 0, hi = 4, step = -1, resetVal = 0)
-- so resetVal is lo but due to the initial trigger
from Impulse the Stepper will in fact start
outputting from 4 .
A frequency domain stereo convolution UGen, capable of performing linear cross-fades between kernel updates.
A frequency domain stereo convolution UGen, capable of performing linear
cross-fades between kernel updates. When receiving a trigger, there is a linear
cross-fade between the old kernel the new buffer contents. It operates similar
to Convolution2L , however uses two buffers and outputs a stereo signal,
resulting in better CPU usage than two discrete instances of Convolution2L as
this way one FFT transformation per period is saved.
Warning: This UGen seems currently broken (SC 3.6.3)
the realtime input to be convolved
buffer identifier for the left channel's fixed kernel, which may be modulated in combination with the trigger
buffer identifier for the right channel's fixed kernel, which may be modulated in combination with the trigger
updates the kernel on a change from non-positive to positive (<= 0 to >0), and starts a new cross-fade from the previous kernel to the new one over the given amount of periods.
size of the kernel. this must be a power of two. the
FFT calculated internally by the UGen has a size of
twice this value. The maximum allowed frameSize is
16384. (init-time only)
fade duration expressed as number of convolved blocks.
If the desired duration in seconds is dur , then the
number of periods can be calculated as
fadePeriods = dur * SampleRate.ir / frameSize .
(init-time only)
A UGen that reports the fractional sample offset of the current Synth from its requested scheduled start.
A UGen that reports the fractional sample offset of the current Synth from its requested scheduled start.
When a synth is created from a time stamped osc-bundle, it starts calculation
at the next possible block (normally 64 samples). Using an OffsetOut UGen, one
can delay the audio so that it matches sample accurately.
For some synthesis methods, one even needs subsample accuracy.
SubsampleOffset provides the information where, within the current sample, the
synth was scheduled. It can be used to offset envelopes or resample the audio
output.
A UGen which starts a linear raise from zero each time it is triggered.
A UGen which starts a linear raise from zero each time it is triggered.
When speed is one, one gets a continually-updating measurement of the time (in seconds) since the last trigger.
the trigger that restarts the ramp, when passing from non-positive to positive
the amount of increment of the output signal per
second. In SCLang this argument is named rate , while
ScalaCollider uses speed to avoid conflict with the
UGen's calculation rate.
A sawtooth oscillator UGen that is hard sync'ed to a fundamental pitch.
A sawtooth oscillator UGen that is hard sync'ed to a fundamental pitch. That
is, a sawtooth waveform is produced at one frequency, sawFreq , whereas a
trigger at a another frequency, syncFreq , resets the phase of the sawtooth to
zero.
This produces an effect similar to moving formants or pulse width modulation. This is not a band limited waveform, so it may alias.
synchronizing (master) frequency which is the perceived fundamental
sawtooth (slave) frequency. It should typically be
greater than syncFreq .
A UGen that converts a control-rate trigger input into an audio-rate trigger output.
A UGen that converts a control-rate trigger input into an audio-rate trigger output. A trigger occurs when a signal changes from less than or equal to zero to greater than zero. The output will have a single sample spike of the input trigger's amplitude at the beginning of the calculation block.
control-rate trigger input
A UGen that converts an audio-rate trigger input into a control-rate trigger output.
A UGen that converts an audio-rate trigger input into a control-rate trigger output. A trigger occurs when a signal changes from less than or equal to zero to greater than zero. The UGen behaves strangely in that for a rising slope input signal, it will report the maximum value seen within the calculation block, but if the slope extends to the next block, it will output that second's block maximum value again instead of waiting for a fall to <= 0.
audio-rate trigger input
A delay UGen for trigger signals.
A delay UGen for trigger signals. Other than a normal buffer delay, any new trigger arriving in the time between the previous trigger and the passing of the delay time is ignored.
The input trigger. A trigger is recognized when the signal passes from non-positive to positive. Note that, no matter what the amplitude of the input trigger is, the UGen will output a delayed trigger of amplitude 1.0.
The delay time in seconds.
A UGen which polls results from demand-rate ugens in intervals specified by a duration input, and outputs them as trigger values.
A UGen which polls results from demand-rate ugens in intervals specified by a
duration input, and outputs them as trigger values. A value from the level
ugen is demanded and output for one sample (when running at audio-rate) or one
block (when running at control-rate) according to a stream of duration values.
When there is a trigger at the reset input, the level and the dur input are
reset.
the provider of time values. Can be a demand-rate ugen or any signal. The next poll is acquired after the previous duration.
a demand-rate ugen providing the output values.
a trigger which resets the dur input (if demand-rated) and the the level input ugen. The reset input may also be a demand-rate ugen, in this case providing a stream of reset times.
a doneAction that is evaluated when the duration stream ends.
when 0 (default), the UGen does the first level poll immediately and then waits for the first duration value. When this is 1, the UGen initially polls the first duration value, waits for that duration, and then polls the first level (along with polling the next duration value).
The argument order is different from its sclang counterpart.
A UGen that generates a new random decimal value each time it is triggered,
using an exponential distribution from lo to hi .
A UGen that generates a new random decimal value each time it is triggered,
using an exponential distribution from lo to hi . Values lo and hi must
both have the same sign and be non-zero.
Note: Audio-rate inputs for lo and hi are currently broken in
SuperCollider, and will therefore be converted to control-rate inputs.
lower limit of the output range
upper limit of the output range
signal to trigger new random number
Triggers generate grains from a buffer.
Triggers generate grains from a buffer. Each grain has a Hanning envelope
(sin2(x) for x from 0 to pi)
and is panned between two channels of multiple outputs.
Warning: Due to a bug (SC 3.6.6), this UGen does not work with LocalBuf
but requires a regular buffer.
Number of output channels.
At each trigger, the following arguments are sampled and used as the arguments of a new grain. A trigger occurs when a signal changes from non-positive to positive value. If the trigger is audio rate then the grains will start with sample accuracy.
The buffer index. It must be a one channel (mono) buffer.
1.0 is normal, 2.0 is one octave up, 0.5 is one octave down -1.0 is backwards normal rate etc.
The position in the buffer in seconds at which the grain envelope will reach maximum amplitude.
Duration of the grain in seconds.
A value from -1 to 1. Determines where to pan the output in the same manner as PanAz.
Amplitude of the grain.
1, 2, or 4. Determines whether the grain uses (1) no interpolation, (2) linear interpolation, or (4) cubic interpolation.
A UGen that outputs integer random numbers when triggered.
A UGen that outputs integer random numbers when triggered. The values have a
uniform distribution from lo to hi (inclusive).
Note: Audio-rate inputs for lo and hi are currently broken in
SuperCollider, and will therefore be converted to control-rate inputs.
lower limit of the output range
upper limit of the output range (inclusive)
signal to trigger new random number
A UGen that generates a new random decimal value each time it is triggered,
using a uniform distribution from lo to hi .
A UGen that generates a new random decimal value each time it is triggered,
using a uniform distribution from lo to hi .
Note: Audio-rate inputs for lo and hi are currently broken in
SuperCollider, and will therefore be converted to control-rate inputs.
lower limit of the output range
upper limit of the output range
signal to trigger new random number
A UGen providing a probability-weighted index into a sequence upon receiving a trigger.
A UGen providing a probability-weighted index into a sequence upon receiving a trigger.
When triggered, returns a random index value based the values of the channels
of the prob argument functioning as probabilities. The index is zero based,
hence goes from 0 to prob.numOutputs - 1 .
By default the sequence of probabilities should sum to 1.0, however for
convenience, this can be achieved by the ugen when the normalize flag is set
to 1 (less efficient).
the trigger used to calculate a new index. a trigger occurs when passing from non-positive to positive
a multi-channel graph element, where the output channels correspond to to the probabilities of their respective indices being chosen.
0 if the seq argument already sums up to 1.0 and thus
doesn't need normalization, 1 if the sum is not
guaranteed to be 1.0 and thus the ugen is asked to
provide the normalization.
A UGen that returns time since last triggered.
A UGen that returns time since last triggered. The time returned is in seconds
and is measured from the last received trigger. Note that currently it seems the
initial memory is at -1 sample, so for Impulse.ar(1) the result (at 44.1 kHz)
is 2.26757e-05, followed strangely by 1.00002, and then (as expected) 1.0.
the trigger to update the output signal. A trigger occurs when trig signal crosses from non-positive to positive.
A UGen that toggles like a flip-flop between zero and one upon receiving a trigger.
A UGen that toggles like a flip-flop between zero and one upon receiving a trigger. The flip-flop initially outputs zero and changes to one when the first trigger arrives.
a signal to trigger the flip-flop. a trigger occurs when the signal changes from non-positive to positive.
A UGen which holds and outputs an input value for a given duration when triggered.
A UGen which holds and outputs an input value for a given duration when triggered.
When a trigger occurs at the input, the input value is sampled and output for the specified duration, otherwise zero is output. When a new trigger occurs while this ugens outputs 1, the hold-time is reset to the duration.
Warning: The hold-time is subject to a bug that depends on the input
signal. For example with Trig1.ar(Impulse.ar(0), 4 * SampleDur.ir) one
actually gets a high signal for five sample frames instead of four.
the trigger. This can be any signal. A trigger happens when the signal changes from non-positive to positive.
the duration for which the ugens holds the value of the input signal when triggered
A UGen which outputs a value of 1 for a given duration when triggered.
A UGen which outputs a value of 1 for a given duration when triggered.
When a trigger occurs at the input, a value of 1 is output for the specified duration, otherwise zero is output. When a new trigger occurs while this ugens outputs 1, the hold-time is reset to the duration.
Warning: The hold-time is subject to a bug that depends on the input
signal. For example with Trig1.ar(Impulse.ar(0), 4 * SampleDur.ir) one
actually gets a high signal for five sample frames instead of four.
the trigger. This can be any signal. A trigger happens when the signal changes from non-positive to positive.
the duration for which the ugens holds the value of 1 when triggered
A two pole filter UGen.
A two zero filter UGen.
A UGenOutProxy refers to a particular output of a multi-channel UGen.
A UGenOutProxy refers to a particular output of a multi-channel UGen. A sequence of these form the representation of a multi-channel-expanded UGen.
A UGen for Vector Base Amplitude Panning (VBAP).
A UGen for Vector Base Amplitude Panning (VBAP). This allows for equal power panning of a source over an arbitrary array of equidistant speakers. Normally this would be a ring, a dome, or partial dome.
VBAP was created by Ville Pulkki. For more information on VBAP see http://www.acoustics.hut.fi/research/cat/vbap/ This version of VBAP for SC was ported from the ver. 0.99 PD code by Scott Wilson.
the number of output channels
the signal to be panned
id of a buffer containing data calculated by
VBAPSetup . Its number of channels must correspond to
numChannels
+/- 180° from the median plane (i.e. straight ahead)
+/- 90° from the azimuth plane
A value from 0-100. When 0, if the signal is panned exactly to a speaker location the signal is only on that speaker. At values higher than 0, the signal will always be on more than one speaker. This can smooth the panning effect by making localisation blur more constant.
A UGen to stream in a signal from an audio file with variable playback speed.
A UGen to stream in a signal from an audio file with variable playback speed. Continuously plays a longer audio file from disk. This requires a buffer to be preloaded with one buffer size of sound. If loop is set to 1, the file will loop.
Note: The buffer size must be a multiple of (2 * the server's block
size). See Buffer#cue for details.
If the speed is too high, the UGen will not execute, posting a warning.
the amount of channels the file and the buffer will have. This is an Int and hence must be pre-determined. Different SynthDefs must be created for different numbers of channels
the id of the buffer with the correct number of channels and frames
controls the speed of playback. The buffer is always
streamed at a frequency of SampleRate.ir * speed , so
the buffer's own sample rate is irrelevant. Factors
below 4 are probably fine, but the higher the value, the
more disk activity there is, and the more likelihood
there will be a problem. The following must be true:
rate < bufFrames / (2 * blockSize) , e.g with typical
default values, this will be 32768 / (2 * 64) = 256 .
whether the file should loop when its end is reached
If a value other than zero is used, the UGen sends an
OSC message with this id and the file position each time
it reloads the buffer:
OSCMessage("/diskin", nodeID, sendID, frame)
A sawtooth-triangle oscillator UGen with variable duty.
A sawtooth-triangle oscillator UGen with variable duty. A width of zero
produces a sawtooth of falling slope, with an initial phase of zero making it
start at +1. A width of 0.5 produces a triangle wave, starting at -1 then
raising to +1, then falling again to -1. A width of 1.0 produces a sawtooth of
rising slope, starting -1.
Increasing the initial wave will increase the offset into the waveform. For example, with a phase of 0.5 and a width of 0.5, the result is a triangle waveform that starts at +1.
There is a strange anomaly for the falling sawtooth (zero width): Instead of starting directly at +1, the first sample is -1 and only from the second sample at +1 the waveform starts falling. In other words, the waveform has a delay of one sample.
frequency in Hertz
initial phase offset in cycle (0 to 1)
duty cycle from zero to one.
A low frequency oscillator UGen for modelling vibrato.
A low frequency oscillator UGen for modelling vibrato. It produces a modulating frequency value in Hertz that can be used as the frequency parameter of another UGen.
By setting more extreme settings, one can get back to the timbres of FM synthesis. One can also add in some noise to the vibrato rate and vibrato size (modulation depth) to make for a more realistic motor pattern.
The vibrato output is a waveform based on a squared envelope shape with four stages marking out 0.0 to 1.0, 1.0 to 0.0, 0.0 to -1.0, and -1.0 back to 0.0. The vibrato rate determines how quickly one moves through these stages.
fundamental frequency in Hertz. If the Vibrato UGen is running at audio rate, this must be an audio-rate input as well.
vibrato rate, that is the speed of wobble in Hertz. Note that if this is set to a too low value, you may never get vibrato back, since this input is only checked at the end of a cycle.
amount of vibrato frequency deviation around the fundamental, as a proportion of the fundamental.
delay in seconds before vibrato is established. (init-time only)
transition time in seconds from no vibrato to full vibrato after the initial delay time. (init-time only)
random (noise) variation on the beat parameter,
expressed as a proportion of beat . It can change once
per cycle of vibrato.
random (noise) variation on the depth of modulation,
expressed as a proportion of depth . It can change
once per cycle of vibrato. The noise affects
independently the up and the down part of vibrato shape
within a cycle.
initial phase of vibrato modulation, allowing starting above or below the fundamental rather than on it. (init-time only)
A noise generator UGens whose spectrum has equal power at all frequencies.
A noise generator UGens whose spectrum has equal power at all frequencies.
Output values range from -1 to +1 (before being multiplied by mul ). The
RMS is approx. -4.8 dB.
Not actually a UGen input, this argument produces a
multiplication of the output by this factor. A
multi-channel mul argument will cause the generation
of multiple independent noise generators.
A UGen that constrains a signal to a given range, by "wrapping" values outside the range.
A UGen that constrains a signal to a given range, by "wrapping" values outside
the range. This is similar to the wrap2 binary operator but permits both a
lower range value lo and an upper range value hi .
An input value greater than or equal to hi will be wrapped back to
(in - hi) % (hi - lo) + lo . An input value less than lo will be wrapped
back to hi - (lo - in) % (hi - lo) .
input signal to constrain
lower margin of wrapping (inclusive)
upper margin of wrapping (exclusive)
A UGen which reads a single sample value from a buffer at a given index.
A UGen which reads a single sample value from a buffer at a given index.
It uses the in argument as index into the buffer, truncating that argument to
an integer. Out-of-range index values are wrapped around the valid range. For
example, if the buffer has four samples, index 4 is wrapped to index 0, index 5
is wrapped to index 1, index -1 is wrapped to index 3, index -2 is wrapped to
index 2, etc.
While designed for monophonic buffers, it works with multi-channel buffers by
treating them as de-interleaved. See the Index UGen for details.
The buffer to read from.
The sample index into the buffer. This is truncated to an integer automatically.
An element which writes an input signal to a bus, optionally applying a short fade-in.
An element which writes an input signal to a bus, optionally applying a short fade-in.
This is automatically added when using the play { ... } syntax. If the fade time is
given, an envelope is added with a control named "gate" which can be used to release
the synth. The bus is given by a control named "out" and defaults to zero.
the signal to play to the default output
the fade in time; use a negative number for no fading
An equal power two channel cross fading UGen.
An equal power two channel cross fading UGen. In center position ( pan = 0 ),
both input signals are attenuated by sqrt(0.5) or approx. -3 dB.
The first input signal
The second input signal
the cross-fade position from -1 (only input A
audible) to +1 (only input B audible)
An overall amplitude multiplier that is applied to the output signal
An exponential curve generator UGen that moves from a start value to the end value in a given duration.
An exponential curve generator UGen that moves from a start value to the end value in a given duration.
At a given point in time 0 <= t <= dur , the output value is
start * (stop/start).pow(t/dur) .
Warning: It must be ensured that the both start is not zero and start
and end have the same sign (e.g. a start of -1 and an end of -0.001 are
valid), otherwise the UGen will output a NaN ! While in the case of end
being zero the UGen will also output zero, it is recommended to treat this case
as pathological as well.
Starting value (init-time only)
Ending value (init-time only)
Duration in seconds (init-time only)
A done-action that is evaluated when the Line has
reached the end value after the given duration
A UGen that cross-fades the contents of a bus with an input signal.
A UGen that cross-fades the contents of a bus with an input signal. A linear cross-fade can go from 0.0 (previous bus contents preserved, no input signal added) via 0.5 (previous signal attenuated by -6 dB, input signal attenuated by -6 dB and added) to 1.0 (contents completely replaced by input signal).
bus index to write to. For an audio-rate UGen, this is an audio-bus, for a control-rate UGen, this is a control-bus.
signal to write to the bus. If the UGen is audio-rate, the input must also be audio-rate.
cross-fade value. The new bus contents will be
old_bus_content * (1 - xfade) + in * xfade
A pitch estimation UGen based on counting the zero-crossings of the input signal.
A pitch estimation UGen based on counting the zero-crossings of the input signal. This is a very crude pitch follower, but can be useful in some situations.
signal to analyze
A converter UGen that takes an audio-rate input and produces a control-rate output by means of sampling.
All pass delay line with cubic interpolation.
All pass delay line with linear interpolation.
All pass delay line with no interpolation.
A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency.
A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency.
Implements the formula: (root / freq).pow(exp)
Higher frequencies are normally perceived as louder, therefore AmpComp
outputs lower values for them. For example, with default parameters, the pitch
C4 (frequency 262 Hz) produces the base factor of 1.0, whereas a pitch one
octave up, C5 (or 523 Hz) produces a factor of 0.793719 (an attenuation of -2
dB).
An alternative is AmpCompA that better models the bell-shaped equal loudness
contours of the hearing system. Especially note that the output of this UGen can
become very high for frequencies much lower than the root parameter.
// activate with mouse button play { val freq = MouseX.kr(300, 15000, 1) val mod = freq * SinOsc.ar(MouseY.kr(3, 200, 1)).madd(0.5, 1) val corr = AmpComp.ar(mod, 300) * 2 val amp = Select.ar(MouseButton.kr(lag = 0), Seq(DC.ar(1), corr)) SinOsc.ar(mod) * 0.1 * amp }
A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency.
A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency. It uses the A-weighting curve that is based on the Fletcher-Munson curve for rather low volume sounds (40 phon).
Only the freq parameter can be modulated, the other parameters are read at
initialization time only.
// activate with mouse button play { val freq = MouseX.kr(300, 15000, 1) val mod = freq * SinOsc.ar(MouseY.kr(3, 200, 1)).madd(0.5, 1) val corr = AmpCompA.ar(mod, 300) * 2 val amp = Select.ar(MouseButton.kr(lag = 0), Seq(DC.ar(1), corr)) SinOsc.ar(mod) * 0.1 * amp }
An amplitude follower UGen.
An amplitude follower UGen. Tracks and reports the peak amplitude of its input signal.
// use sound-card input to control pulse amplitude play { // use headphones to prevent feedback! Pulse.ar(90, 0.3) * Amplitude.kr(PhysicalIn.ar(0)) }
// compare with known amplitude play { val amp = MouseX.kr val in = PinkNoise.ar(amp) val ana = Amplitude.kr(amp, attack = 2, release = 2) (ana - amp).poll(2, "discrepancy") in }
A UGen that finds the largest value across the channels of its input signal, providing both the value and the index.
A UGen that finds the largest value across the channels of its input signal, providing both the value and the index.
// randomly changing array of three numbers play { val tr = Impulse.kr(1) val sig = Vector.fill(3)(TIRand.kr(0, 100, tr)) sig.zipWithIndex.foreach { case (n, i) => n.poll(tr, s"sig[$i]") } val m = ArrayMax.kr(sig) m.value.poll(tr, "max-value") m.index.poll(tr, "max-index") () }
A UGen that finds the smallest value across the channels of its input signal, providing both the value and the index.
A UGen that finds the smallest value across the channels of its input signal, providing both the value and the index.
// randomly changing array of three numbers play { val tr = Impulse.kr(1) val sig = Vector.fill(3)(TIRand.kr(0, 100, tr)) sig.zipWithIndex.foreach { case (n, i) => n.poll(tr, s"sig[$i]") } val m = ArrayMin.kr(sig) m.value.poll(tr, "min-value") m.index.poll(tr, "min-index") () }
An all pass filter UGen.
An all pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
An band pass filter UGen.
An band pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
An band stop (reject) filter UGen.
An band stop (reject) filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
A 2nd order (12db per oct roll-off) resonant high pass filter UGen.
A 2nd order (12db per oct roll-off) resonant high pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
A high shelf equalizer UGen.
A high shelf equalizer UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
A 2nd order (12db per oct roll-off) resonant low pass filter UGen.
A 2nd order (12db per oct roll-off) resonant low pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
A low shelf equalizer UGen.
A low shelf equalizer UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
A second order band pass filter UGen.
A second order band pass filter UGen.
// modulated frequency play { val in = Saw.ar(200) * 0.5 val freq = SinOsc.ar(XLine.ar(0.3, 100, 20)).madd(3600, 4000) BPF.ar(in, freq) }
// mouse controlled frequency and Q play { val in = WhiteNoise.ar(0.5) val freq = MouseX.kr(200, 10000, 1) val q = MouseY.kr(1, 100, 1) // bottom to top val flt = BPF.ar(in, freq, q.reciprocal) flt * q.sqrt // compensate for energy loss }
a special fixed band-pass filter UGen.
a special fixed band-pass filter UGen. Implements the formula :
out(i) = 0.5 * (in(i) - in(i-2))
This filter cuts out frequencies around zero Hertz and Nyquist.
// engage with mouse button play { val sig = WhiteNoise.ar(0.5) val flt = BPZ2.ar(sig) LinXFade2.ar(sig, flt, MouseButton.kr(-1, 1)) }
An parametric equalizer UGen.
An parametric equalizer UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.
Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.
A second order band reject (notch) filter UGen.
A second order band reject (notch) filter UGen.
// modulated frequency play { val in = Saw.ar(200) * 0.5 val freq = SinOsc.ar(XLine.ar(0.3, 100, 20)).madd(3600, 4000) BRF.ar(in, freq) }
// mouse controlled frequency and Q play { val in = WhiteNoise.ar(0.5) val freq = MouseX.kr(200, 10000, 1) val q = MouseY.kr(0.5, 10, 1) // bottom to top BRF.ar(in, freq, q.reciprocal) }
a special fixed band-reject filter UGen.
a special fixed band-reject filter UGen. Implements the formula :
out(i) = 0.5 * (in(i) + in(i-2))
This filter cuts out frequencies around half of the Nyquist frequency.
// engage with mouse button play { val sig = WhiteNoise.ar(0.5) val flt = BRZ2.ar(sig) LinXFade2.ar(sig, flt, MouseButton.kr(-1, 1)) }
An equal power two channel balancing UGen.
An autocorrelation based beat tracker UGen.
An autocorrelation based beat tracker UGen.
The underlying model assumes 4/4, but it should work on any isochronous beat structure, though there are biases to 100-120 bpm; a fast 7/8 may not be tracked in that sense. There are four control-rate outputs, being ticks at quarter, eighth and sixteenth level from the determined beat, and the current detected tempo. Note that the sixteenth note output won't necessarily make much sense if the music being tracked has swing; it is provided just as a convenience.
This beat tracker determines the beat, biased to the mid-tempo range by weighting functions. It does not determine the measure level, only a tactus. It is also slow reacting, using a 6 second temporal window for its autocorrelation maneuvres. Don't expect human musician level predictive tracking.
On the other hand, it is tireless, relatively general (though obviously best at transient 4/4 heavy material without much expressive tempo variation), and can form the basis of computer processing that is decidedly faster than human.
Warning: This UGen only works properly at 44.1 or 48.0 kHz.
A template matching beat tracker UGen.
A template matching beat tracker UGen. This beat tracker is based on exhaustively testing particular template patterns against feature streams; the testing takes place every 0.5 seconds. The two basic templates are a straight (groove=0) and a swung triplet (groove=1) pattern of 16th notes; this pattern is tried out at scaling factors corresponding to the tempi from 60 to 180 bpm. This is the cross-correlation method of beat tracking. A majority vote is taken on the best tempo detected, but this must be confirmed by a consistency check after a phase estimate. Such a consistency check helps to avoid wild fluctuating estimates, but is at the expense of an additional half second delay. The latency of the beat tracker with default settings is thus at least 2.5 seconds; because of block-based amortisation of calculation, it is actually around 2.8 seconds latency for a 2.0 second temporal window.
This beat tracker is designed to be flexible for user needs; you can try out different window sizes, tempo weights and combinations of features. However, there are no guarantees on stability and effectiveness, and you will need to explore such parameters for a particular situation.
The UGen has six outputs corresponding to beat-tick, eighth-tick, groove-tick, tempo, phase, and groove. Warning: it reads from input control bus instead of taking a regular control input signal as its first argument!
A two dimensional Ambisonics B-format encoder UGen for a two-channel input signal.
A two dimensional Ambisonics B-format encoder UGen for a two-channel input signal. ambisonic B-format. It places the two input channels at opposite poles of the 2D (W, X, Y) Ambisonics field. It is equivalent to:
PanB2(_, inA, azimuth, level) + PanB2(_, inB, azimuth + 1, level)// 4-channel rotation of opposite sounds play { val p = WhiteNoise.ar(0.05) // first source val q = Mix(LFSaw.ar(Seq(200, 200.37))) * 0.03 // second source // B-format encode 2 signals at opposite sides of the circle val enc = BiPanB2.ar(p, q, MouseX.kr(-1, +1)) // B-format decode to quad (front-left, front-right, rear-left, rear-right) DecodeB2.ar(4, enc.w, enc.x, enc.y) }
Binary operations are generally constructed by calling one of the methods of GEOps.
Binary operations are generally constructed by calling one of the methods of GEOps.
UnaryOpUGen
GEOps
Band Limited ImPulse generator UGen.
Band Limited ImPulse generator UGen. All harmonics have equal amplitude. This is the equivalent of 'buzz' in Music-N languages. It is capable of cross-fading during a control period block if the number of harmonics changes, avoiding audible pops.
// modulate fundamental frequency play { Blip.ar(XLine.kr(20000, 200, 6), 100) * 0.2 }
// modulate number of harmonics play { Blip.ar(200, Line.kr(1, 100, 20)) * 0.2 }
A noise generator UGen whose spectrum falls off in power by 6 dB per octave.
A noise generator UGen whose spectrum falls off in power by 6 dB per octave.
The values produced by this UGen lie between -1 and +1 , the RMS is approx.
-4.8 dB (the same as white noise).
// plain noise play { BrownNoise.ar(Seq(0.2, 0.2)) }
All pass delay line with cubic interpolation which uses a buffer for its internal memory.
All pass delay line with cubic interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
// Compare interpolation types // allocate buffer val b = Buffer.alloc(s, (0.2 * s.sampleRate).toInt.nextPowerOfTwo) // Since the allpass delay has no audible effect as a resonator on // steady state sound ... play { BufAllpassC.ar(b.id, WhiteNoise.ar(0.1), XLine.kr(0.0001, 0.01, 20), 0.2) } // ...these examples add the input to the effected sound and compare variants so that you can hear // the effect of the phase comb: play { val z = WhiteNoise.ar(0.2) z + BufAllpassN.ar(b.id, z, XLine.kr(0.0001, 0.01, 20), 0.2) } play { val z = WhiteNoise.ar(0.2) z + BufAllpassL.ar(b.id, z, XLine.kr(0.0001, 0.01, 20), 0.2) } play { val z = WhiteNoise.ar(0.2) z + BufAllpassC.ar(b.id, z, XLine.kr(0.0001, 0.01, 20), 0.2) } b.free() // after synths have been stopped
All pass delay line with linear interpolation which uses a buffer for its internal memory.
All pass delay line with linear interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
// Compare interpolation types // allocate buffer val b = Buffer.alloc(s, (0.2 * s.sampleRate).toInt.nextPowerOfTwo) // Since the allpass delay has no audible effect as a resonator on // steady state sound ... play { BufAllpassC.ar(b.id, WhiteNoise.ar(0.1), XLine.kr(0.0001, 0.01, 20), 0.2) } // ...these examples add the input to the effected sound and compare variants so that you can hear // the effect of the phase comb: play { val z = WhiteNoise.ar(0.2) z + BufAllpassN.ar(b.id, z, XLine.kr(0.0001, 0.01, 20), 0.2) } play { val z = WhiteNoise.ar(0.2) z + BufAllpassL.ar(b.id, z, XLine.kr(0.0001, 0.01, 20), 0.2) } play { val z = WhiteNoise.ar(0.2) z + BufAllpassC.ar(b.id, z, XLine.kr(0.0001, 0.01, 20), 0.2) } b.free() // after synths have been stopped
All pass delay line with no interpolation which uses a buffer for its internal memory.
All pass delay line with no interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
// Compare interpolation types // allocate buffer val b = Buffer.alloc(s, (0.2 * s.sampleRate).toInt.nextPowerOfTwo) // Since the allpass delay has no audible effect as a resonator on // steady state sound ... play { BufAllpassC.ar(b.id, WhiteNoise.ar(0.1), XLine.kr(0.0001, 0.01, 20), 0.2) } // ...these examples add the input to the effected sound and compare variants so that you can hear // the effect of the phase comb: play { val z = WhiteNoise.ar(0.2) z + BufAllpassN.ar(b.id, z, XLine.kr(0.0001, 0.01, 20), 0.2) } play { val z = WhiteNoise.ar(0.2) z + BufAllpassL.ar(b.id, z, XLine.kr(0.0001, 0.01, 20), 0.2) } play { val z = WhiteNoise.ar(0.2) z + BufAllpassC.ar(b.id, z, XLine.kr(0.0001, 0.01, 20), 0.2) } b.free() // after synths have been stopped
// Used as echo val b = Buffer.alloc(s, (0.2 * s.sampleRate).toInt.nextPowerOfTwo) // doesn't really sound different than Comb, // but it outputs the input signal immediately (inverted) and the echoes // are lower in amplitude. play { BufAllpassN.ar(b.id, Decay.ar(Dust.ar(1) * 0.5, 0.2) * WhiteNoise.ar, 0.2, 3) } b.free()
Returns the current number of channels of the buffer at the provided index.
Comb delay line with cubic interpolation which uses a buffer for its internal memory.
Comb delay line with cubic interpolation which uses a buffer for its internal memory.
// Compare interpolation // These examples compare the variants, so that you can hear the difference in interpolation // allocate buffer val b = Buffer.alloc(s, (0.01 * s.sampleRate).toInt.nextPowerOfTwo) // Comb used as a resonator. The resonant fundamental is equal to // reciprocal of the delay time. play { BufCombN.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), 0.2) } play { BufCombL.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), 0.2) } play { BufCombC.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), 0.2) } // with negative feedback play { BufCombN.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), -0.2) } play { BufCombL.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), -0.2) } play { BufCombC.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), -0.2) } b.free() // do this after the synths have ended
Comb delay line with linear interpolation which uses a buffer for its internal memory.
Comb delay line with linear interpolation which uses a buffer for its internal memory.
// Compare interpolation // These examples compare the variants, so that you can hear the difference in interpolation // allocate buffer val b = Buffer.alloc(s, (0.01 * s.sampleRate).toInt.nextPowerOfTwo) // Comb used as a resonator. The resonant fundamental is equal to // reciprocal of the delay time. play { BufCombN.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), 0.2) } play { BufCombL.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), 0.2) } play { BufCombC.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), 0.2) } // with negative feedback play { BufCombN.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), -0.2) } play { BufCombL.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), -0.2) } play { BufCombC.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), -0.2) } b.free() // do this after the synths have ended
Comb delay line with no interpolation which uses a buffer for its internal memory.
Comb delay line with no interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
// Compare interpolation // These examples compare the variants, so that you can hear the difference in interpolation // allocate buffer val b = Buffer.alloc(s, (0.01 * s.sampleRate).toInt.nextPowerOfTwo) // Comb used as a resonator. The resonant fundamental is equal to // reciprocal of the delay time. play { BufCombN.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), 0.2) } play { BufCombL.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), 0.2) } play { BufCombC.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), 0.2) } // with negative feedback play { BufCombN.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), -0.2) } play { BufCombL.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), -0.2) } play { BufCombC.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), -0.2) } b.free() // do this after the synths have ended
// Used as an echo val b = Buffer.alloc(s, (0.2 * s.sampleRate).toInt.nextPowerOfTwo) play { BufCombN.ar(b.id, Decay.ar(Dust.ar(1) * 0.5, 0.2) * WhiteNoise.ar, 0.2, 3) } b.free() // do this after the synth has ended
Simple delay line with cubic interpolation which uses a buffer for its internal memory.
Simple delay line with cubic interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
Simple delay line with linear interpolation which uses a buffer for its internal memory.
Simple delay line with linear interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
Simple delay line with no interpolation which uses a buffer for its internal memory.
Simple delay line with no interpolation which uses a buffer for its internal memory.
Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.
// Random white-noise decay // allocate buffer val b = Buffer.alloc(s, (0.2 * s.sampleRate).toInt.nextPowerOfTwo, 1) // Dust randomly triggers Decay to create an exponential // decay envelope for the WhiteNoise input source. // We apply a slight filter to the delayed signal // so it is easier to distinguish play { val z = Decay.ar(Dust.ar(1) * 0.5, 0.3) * WhiteNoise.ar LPF.ar(BufDelayN.ar(b.id, z, 0.2), 8000) + z // input is mixed with delay } b.free() // do this after the synth has ended
Returns the current duration of the buffer at the provided index.
Returns the number of allocated frames of the buffer at the provided index.
A UGen that finds the largest value in a buffer, providing both the value and the index.
A UGen that finds the largest value in a buffer, providing both the value and the index.
// simple test val b = Buffer(s) b.alloc(100) b.zero() b.set(33 -> 1.034) // verify that the 33rd value is detected... val x = play { val m = BufMax.kr(b.id) val tr = "poll".tr(1) m.value.poll(tr, "max-value") m.index.poll(tr, "max-index") () } // ...until we set a new maximum... b.set(74 -> 1.038); x.set("poll" -> 1) x.free(); b.free()
A UGen that finds the smallest value in a buffer, providing both the value and the index.
A UGen that finds the smallest value in a buffer, providing both the value and the index.
// simple test val b = Buffer(s) b.alloc(100) b.zero() b.set(33 -> -1.034) // verify that the 33rd value is detected... val x = play { val m = BufMin.kr(b.id) val tr = "poll".tr(1) m.value.poll(tr, "min-value") m.index.poll(tr, "min-index") () } // ...until we set a new minimum... b.set(74 -> -1.038); x.set("poll" -> 1) x.free(); b.free()
Returns a ratio by which the playback of the buffer at the provided index is to be scaled relative to the current sample rate of the server.
Returns a ratio by which the playback of the buffer at the provided index is to be scaled relative to the current sample rate of the server.
buffer sample rate / server sample rate
A UGen which reads the content of a buffer, using an index pointer.
A UGen which reads the content of a buffer, using an index pointer.
Warning: if the supplied bufID refers to a buffer whose number of channels
differs from numChannels , the UGen will fail silently.
An alternative to BufRd is PlayBuf . While PlayBuf plays through the
buffer by itself, BufRd only moves its read point by the index input and
therefore has no pitch input. PlayBuf uses cubic interpolation, while BufRd
has variable interpolation. PlayBuf can determine the end of the buffer and
issue a done-action.
// Write and read val b = Buffer.alloc(s, numFrames = 32768, numChannels = 1) // write into the buffer with a BufWr val y = play { val in = SinOsc.ar(LFNoise1.kr(2).madd(300, 400)) * 0.1 val rate = "rate" kr 1 BufWr.ar(in, b.id, Phasor.ar(0, BufRateScale.kr(b.id) * rate, 0, BufFrames.kr(b.id))) 0.0 // quiet } // read it with a BufRd val x = play { val rate = "rate" kr 1 BufRd.ar(1, b.id, Phasor.ar(0, BufRateScale.kr(b.id) * rate, 0, BufFrames.kr(b.id))) } y.set("rate" -> 0.5) // notice the clicks when the play head overtakes the write head! x.set("rate" -> 0.5) y.set("rate" -> 1.0)
Returns the buffer's current sample rate.
Returns the current number of allocated samples in the Buffer at the provided index.
Returns the current number of allocated samples in the Buffer at the provided index. A sample is not the same as a frame (compare with BufFrames ); a frame includes the samples in each channel of the buffer. Only for a mono buffer are samples the same as frames.
samples = frames * numChannels
A UGen that writes a signal to a buffer, using an index pointer.
A UGen that writes a signal to a buffer, using an index pointer.
Warning: if the supplied bufID refers to a buffer whose number of channels
differs from those of the input signal, the UGen will fail silently.
An alternative to BufWr is RecordBuf . While RecordBuf advances the index
into the buffer by itself, BufWr only moves its write point by the index
input, making it possible to adjust the writing speed or to access the buffer in
a non-linear way. RecordBuf can determine the end of the buffer and issue a
done-action.
// record and playback // a two second mono buffer val b = Buffer.alloc(s, numFrames = s.sampleRate.toInt * 2) val y = play { val sig = SinOsc.ar(LFNoise1.kr(2).madd(300, 400)) * 0.1 val rate = "rate" kr 1 BufWr.ar(in = sig, buf = b.id, index = Phasor.ar(speed = BufRateScale.kr(b.id) * rate, lo = 0, hi = BufFrames.kr(b.id))) 0.0 // quiet } // read it with a BufRd val x = play { val rate = "rate" kr 1 BufRd.ar(1, buf = b.id, index = Phasor.ar(speed = BufRateScale.kr(b.id) * rate, lo = 0, hi = BufFrames.kr(b.id))) } x.set("rate" -> 5) y.set("rate" -> 3) x.set("rate" -> 2)
This object was generated by sbt-buildinfo.
A UGen to test for infinity, not-a-number (NaN), and denormal numbers.
A UGen to test for infinity, not-a-number (NaN), and denormal numbers. Its output is as follows: 0 = a normal float, 1 = NaN, 2 = infinity, and 3 = a denormal. According to the post settings it will print the information to the console along with a given identifier.
This is a UGen like Ramp , but it always takes the shortest way around a
defined circle, wrapping values where appropriate.
A scalar (init-time) UGen that fills the contents of a buffer with zeroes.
A UGen that constrains a signal to a given range, by limiting values outside the range to the range margins.
A UGen that constrains a signal to a given range, by limiting values outside
the range to the range margins. This is similar to the clip2 binary operator
but permits both a lower range value lo and an upper range value hi .
Mathematically, this is equivalent to in.max(lo).min(hi).
Be aware that there seems to be an initialization bug. The following crashes,
indicating that Clip.ar outputs a zero initially:
{{ play { val bar = Integrator.ar(DC.ar(0), coeff = 0.999) val foo = Clip.ar(bar, lo = 1.0, hi = 44100.0) // .max(1.0) val sum = RunningSum.ar(DC.ar(0), length = foo) sum.poll(1, "sum") () } }}
// clip sine wave to modulate timbre play { val hi = SinOsc.ar(0.1).linexp(-1, 1, 0.01, 1.0) Clip.ar(SinOsc.ar(300), 0, hi) * 0.2 / hi }
A noise generator UGen whose values are either -1 or +1 (before being
multiplied by mul ).
A noise generator UGen whose values are either -1 or +1 (before being
multiplied by mul ). This produces the maximum energy (an RMS of 0 dB) for the
least peak to peak amplitude.
// plain noise play { ClipNoise.ar(Seq(0.2, 0.2)) }
A UGen that randomly filters an input trigger signal.
A UGen that randomly filters an input trigger signal. When a trigger arrives,
it may pass with a probability given by the prob argument.
// filter dust, probability controlled by mouse play { val p = MouseX.kr CoinGate.ar(Dust.ar(400), p) }
The argument order is different from its sclang counterpart.
Comb delay line with cubic interpolation.
Comb delay line with linear interpolation.
Comb delay line with no interpolation.
A compressor, expander, limiter, gate and ducking UGen.
A compressor, expander, limiter, gate and ducking UGen. This dynamic processor uses a hard-knee characteristic. All of the thresholds and ratios are given as direct values, not in decibels!
A UGen that reports the server's current control period in seconds.
A UGen that reports the server's current control period in seconds. This is
equivalent to the reciprocal of ControlRate
// print the control period play { ControlDur.ir.poll(0) }
A UGen that reports the server's current control rate.
A UGen that reports the server's current control rate. This is equivalent to
the reciprocal of ControlDur
// print the control rate play { ControlRate.ir.poll(0) }
// play a sine tone at control rate play { SinOsc.ar(ControlRate.ir) * 0.1 }
A UGen that performs a convolution with an continuously changing kernel.
A UGen that performs a convolution with an continuously changing kernel. If the
kernel is static or must only change occasionally, Convolution2 will be a more
CPU friendly alternative. The process introduces a delay of
frameSize - blockSize .
// sine filter play { val a = WhiteNoise.ar val b = SinOsc.ar(MouseY.kr(20, 2000, 1)) Convolution.ar(a, b, 512) * 0.01 }
A frequency-domain convolution UGen using a fixed kernel which can be updated by a trigger signal.
A frequency-domain convolution UGen using a fixed kernel which can be updated
by a trigger signal. The delay caused by the convolution when the kernel is a
dirac impulse is equal to frameSize - controlBlockSize , so for a frameSize
of 2048 and a control-block size of 64, this is 1984 sample frames.
// three example kernels // creates a buffer with `n` set values def mkBuf(n: Int, amp: => Double): Buffer = { val v = Vector.tabulate[FillValue](n) { i => (i.linlin(0, n, 0, 2048).toInt, amp) } val b = Buffer(s) b.alloc(2048, completion = b.zeroMsg(b.setMsg(v: _*))) b } val b = mkBuf(3, 1) val c = mkBuf(50, math.random) val d = mkBuf(20, 1) val x = play { val z = Impulse.ar(1) val buf = "kernel".kr(b.id) val tr = "trig" .tr Convolution2.ar(z, buf, tr, 2048) * 0.5 } // set buffer and trigger kernel actualization x.set("kernel" -> b.id, "trig" -> 1) x.set("kernel" -> c.id, "trig" -> 1) x.set("kernel" -> d.id, "trig" -> 1) x.free(); b.free(); c.free(); d.free()
A frequency-domain convolution UGen using two linearly interpolated fixed kernels.
A frequency-domain convolution UGen using two linearly interpolated fixed kernels. When a trigger is received, a linear fade will be performed from the previously used kernel (internally stored by the UGen) towards the snapshot of the current kernel content upon receiving the trigger.
The delay caused by the convolution when the kernel is a dirac impulse is equal
to frameSize - controlBlockSize , so for a frameSize of 2048 and a
control-block size of 64, this is 1984 sample frames.
Note: If a trigger is received before the previous fade is complete, the interpolation is broken and the kernel instead jumps straight to one of the two buffers.
// three example kernels def mkBuf(n: Int, amp: => Double): Buffer = { val v = Vector.tabulate[FillValue](n) { i => (i.linlin(0, n, 0, 2048).toInt, amp) } val b = Buffer(s) b.alloc(2048, completion = b.zeroMsg(b.setMsg(v: _*))) b } val b = mkBuf(3, 1) val c = mkBuf(50, math.random) val d = mkBuf(20, 1) val x = play { val z = Impulse.ar(16) val buf = "kernel".kr(b.id) val tr = "trig" .tr val dur = 4.0 // fade-time in seconds val n = 2048 val block = SampleRate.ir / n val p = dur * block // ... in periods Convolution2L.ar(z, buf, tr, 2048, p) * 0.5 } x.set("kernel" -> b.id, "trig" -> 1) x.set("kernel" -> c.id, "trig" -> 1) x.set("kernel" -> d.id, "trig" -> 1) x.free(); b.free(); c.free(); d.free()
A UGen for triggered convolution in the time domain.
A UGen for triggered convolution in the time domain.
Warning: This UGen seems currently broken (SC 3.6.3)
A noise generator UGen based on a chaotic function.
A noise generator UGen based on a chaotic function. Output values lie between zero and one. Although this is a deterministic process, it is randomly seeded.
// increasing parameter play { val chaos = Line.kr(1.0, 2.01, 15) chaos.poll(2, "chaos") Crackle.ar(Seq(chaos, chaos)) * 0.5 }
A linear-interpolating sound generator based on the difference equation:
A linear-interpolating sound generator based on the difference equation:
x[n+1] = a - b * sqrt(abs(x[n]))// vary frequency play { CuspL.ar(MouseX.kr(20, SampleRate.ir), 1.0, 1.99) * 0.3 }
// mouse-controlled parameters play { CuspL.ar(SampleRate.ir/4, MouseX.kr(0.9, 1.1, 1), MouseY.kr(1.8, 2,1)) * 0.3 }
// as a frequency control play { SinOsc.ar(CuspL.ar(40, MouseX.kr(0.9, 1.1, 1), MouseY.kr(1.8, 2, 1)) * 800 + 900) * 0.4 }
A non-interpolating sound generator based on the difference equation:
A non-interpolating sound generator based on the difference equation:
x[n+1] = a - b * sqrt(abs(x[n]))// vary frequency play { CuspN.ar(MouseX.kr(20, SampleRate.ir), 1.0, 1.99) * 0.3 }
// mouse-controlled parameters play { CuspN.ar(SampleRate.ir/4, MouseX.kr(0.9, 1.1, 1), MouseY.kr(1.8, 2, 1)) * 0.3 }
// as a frequency control play { SinOsc.ar(CuspN.ar(40, MouseX.kr(0.9, 1.1, 1), MouseY.kr(1.8, 2,1)) * 800 + 900) * 0.4 }
A UGen that creates a constant signal at a given calculation rate.
A UGen that creates a constant signal at a given calculation rate.
// create a silent audio signal play { // Note: Select.ar requires audio-rate input. // Therefore, DC can be used to wrap the otherwise // incompatible constant zero. In future versions of // ScalaCollider, this wrapping will be done // automatically, however. Select.ar(MouseButton.kr(lag = 0), Seq(DC.ar(0), SinOsc.ar * 0.2)) }
A digital filter UGen which aims at accurately modeling an analog filter.
A digital filter UGen which aims at accurately modeling an analog filter. It provides low-pass and high-pass modes, and the filter can be overdriven and will self-oscillate at high resonances.
A demand-rate UGen that reads out a buffer.
An integrator UGen with exponential decay of past values.
An integrator UGen with exponential decay of past values. This is essentially
the same as Integrator except that instead of supplying the coefficient
directly, it is calculated from a 60 dB decay time. This is the time required
for the integrator to lose 99.9 % of its value or -60dB.
Note: This should not be confused with Lag which does not overshoot due to
integration, but asymptotically follows the input signal.
A integrator UGen with controllable attack and release times.
A integrator UGen with controllable attack and release times. While Decay has
a very sharp attack and can produce clicks, Decay2 rounds off the attack by
subtracting one Decay from another. It can be seen as equivalent to
Decay.ar(in, release) - Decay.ar(in, attack)
Note: This should not be confused with LagUD which does not overshoot due to
integration, but asymptotically follows the input signal.
A two dimensional Ambisonics B-format decoding UGen.
A two dimensional Ambisonics B-format decoding UGen. It assumes a set of
speakers in a regular polygon. The output channels are in clockwise order. The
position of the first speaker is specified by the orient argument.
// 4-channel rotation of opposite sounds play { val p = WhiteNoise.ar(0.05) // first source val q = Mix(LFSaw.ar(Seq(200, 200.37))) * 0.03 // second source // B-format encode 2 signals at opposite sides of the circle val enc = PanB2.ar(p, -0.5) + PanB2.ar(q, +0.5) val Seq(w, x, y) = (0 to 2).map(enc \ _) val rot = Rotate2.ar(x, y, MouseX.kr(-1, +1)) // B-format decode to quad (front-left, front-right, rear-left, rear-right) DecodeB2.ar(4, w, rot.xr, rot.yr) }
A UGen that uses an input signal as an index into an octave repeating table of pitch classes.
A UGen that uses an input signal as an index into an octave repeating table of pitch classes. The input is truncated to an integer, and indices wrap around the table and shift octaves as they do.
// modal space where mouse x controls pitch step play { // initialize the scale buffer (Dorian) val scale = Vector(0, 2, 3.2, 5, 7, 9, 10) val buf = LocalBuf(scale.size) SetBuf(buf, scale) // base MIDI pitch val base = DegreeToKey.kr(buf, in = MouseX.kr(0, 15), octave = 12) + 72 val noise = LFNoise1.kr(Seq(3, 3)) * 0.04 // low freq stereo detuning // lead tone val lead = SinOsc.ar((base + noise).midicps) // drone 5ths val drone = RLPF.ar(LFPulse.ar(Seq(48.midicps, 55.midicps), 0.15), SinOsc.kr(0.1).madd(10, 72).midicps, 0.1) val mix = (lead + drone) * 0.1 // add some 70's euro-space-rock echo CombN.ar(mix, 0.31, 0.31, 2) + mix }
Tap a delay line from a DelTapWr UGen.
Tap a delay line from a DelTapWr UGen.
Write to a buffer for a DelTapRd UGen
Write to a buffer for a DelTapRd UGen
A UGen that delays the input by 1 audio frame or control period.
A UGen that delays the input by 1 audio frame or control period.
For audio-rate signals the delay is 1 audio frame, and for control-rate signals the delay is 1 control period.
Note: The first value output is not zero but the same as the first input
value! In this respect the UGen behaves different than DelayN .
// analog to HPZ1 play { val z = PinkNoise.ar val x = z - Delay1.ar(z) // mouse button to compare dry/wet LinXFade2.ar(z, x, MouseButton.kr(-1, 1)) }
A UGen that delays the input by 2 audio frames or control periods.
A UGen that delays the input by 2 audio frames or control periods.
For audio-rate signals the delay is 2 audio frames, and for control-rate signals the delay is 2 control periods.
Warning: the The first value output is zero, while both the second and the
third value output equal the first input value! In this respect the UGen behaves
different than DelayN .
// high-frequency comb filter play { val z = PinkNoise.ar val x = z - Delay2.ar(z) // mouse button to compare dry/wet LinXFade2.ar(z, x, MouseButton.kr(-1, 1)) }
Simple delay line with cubic interpolation.
Simple delay line with linear interpolation.
Simple delay line with no interpolation.
Simple delay line with no interpolation. The initial buffer contents is zero.
// Delayed random pulses play { // Dust randomly triggers Decay to create an exponential // decay envelope for the WhiteNoise input source val z = Decay.ar(Dust.ar(2) * 0.5, 0.3) * WhiteNoise.ar DelayN.ar(z, 0.2, 0.2) + z // input is mixed with delay via the add input }
// Recursive application play { val z = Decay2.ar(Dust.ar(1) * 0.5, 0.01, 0.1) * Saw.ar(Seq(100, 101)) * 0.5 (z /: (0 until 5)) { (zi, i) => DelayN.ar(RLPF.ar(zi, Rand(100, 3000), 0.03), 1, 1.0 / (2 << i)) + zi * 0.5 } }
A UGen which polls results from demand-rate ugens when receiving a trigger.
A UGen which polls results from demand-rate ugens when receiving a trigger.
When there is a trigger at the trig input, a value is demanded from each ugen
in the in input and output. The unit generators in the list should be
demand-rate. When there is a trigger at the reset input, the demand rate ugens
in the list are reset.
Note: By design, a reset trigger only resets the demand ugens; it does not
reset the value at Demand's output. Demand continues to hold its value until the
next value is demanded, at which point its output value will be the first
expected item in the in argument.
Note: One demand-rate ugen represents a single stream of values, so that embedding the same ugen twice calls this stream twice per demand, possibly yielding different values. To embed the same sequence twice, either make sure the ugen is demanded only once, or create two instances of the ugen.
Warning: Demand currently seems to have problems with infinite sequences.
As a workaround use a very large length instead. E.g. instead of
Dbrown(0, 1, inf) use Dbrown(0, 1, 0xFFFFFFFF) !
Warning: Demand seems to have a problem with initial triggers. For
example Demand.kr(Impulse.kr(0), 1) will have a spurious zero value output
first.
An envelope generator UGen using demand-rate inputs for the envelope segments.
An envelope generator UGen using demand-rate inputs for the envelope segments. For each parameter of the envelope (levels, durations and shapes), values are polled every time a new segment starts.
A UGen which determines the index in a buffer at which the value matches a given input signal.
A UGen which determines the index in a buffer at which the value matches a given input signal. If the input value is not found, it outputs -1.
For example, if the buffer contains values 5, 3, 2, 8, and the input signal is
3, the output will be 1. If the input is 3.001, the output will be -1. Unlike
IndexInBetween , this UGen always searches through the entire buffer until the
value is found or the end has been reached (returning -1).
A UGen which detects whether its input signal falls below a given amplitude for a given amount of time (becoming "silent").
A UGen which detects whether its input signal falls below a given amplitude for
a given amount of time (becoming "silent"). A silence is detected if the
absolute sample values of the input remain less than or equal to the amp
threshold for a consecutive amount of time given by the dur argument.
A value of 1 is output when this condition is met, and a value of 0 is
output when the condition is not met (i.e. at least one sample occurs in the
input whose absolute value is greater than amp ). Besides, when the output
changes from zero to one, the doneAction is executed (unless it is doNothing
).
A special case is the initial condition of the UGen: It will begin with an
output value of 0 (no silence detected), even if the input signal is below the
amplitude threshold. It is only after the first input sample rising above the
threshold that the actual monitoring begins and a trigger of 1 or the firing
of the done-action may occur.
A UGen to stream in a signal from an audio file.
A UGen to stream in a signal from an audio file. Continuously plays a longer audio file from disk. This requires a buffer to be preloaded with one buffer size of sound. If loop is set to 1, the file will loop.
Note: The buffer size must be a multiple of (2 * the server's block
size). See Buffer#cue for details.
A UGen which writes a signal to a sound file on disk.
A UGen which writes a signal to a sound file on disk. To achieve this efficiently, a buffer is needs to be provides which is used to buffer the incoming signal.
Note: It might be that the buffer size must be a multiple of (2 * the server's block size). We haven't currently verified this, but to be safe, you should make sure this property is met.
The signal output by the UGen represents the number of frames written.
A UGen which monitors another UGen to see when it is finished.
A UGen which monitors another UGen to see when it is finished. Some UGens, such
as PlayBuf , RecordBuf , Line , XLine , EnvGen , Linen , BufRd ,
BufWr , DbufRd , and the Buffer delay UGens set a 'done' flag when they are
finished playing. This UGen echoes that flag as an explicit output signal when
it is set to track a particular UGen. When the tracked UGen changes to done, the
output signal changes from zero to one.
A demand rate UGen printing the current output value of its input to the console when polled.
A demand-rate UGen which produces an arithmetic (linear) series.
A UGen generating random impulses with values ranging from 0 to +1 .
A UGen generating random impulses with values ranging from 0 to +1 . The
pulse duration is one sample for audio-rate and one block for control-rate
operation.
The approximate RMS energy is (density/sr).log2 * 3 - 4.8 where sr is the
sample-rate. For example, at 44.1 kHz, a density of 1000 Hz yields an RMS of
approx. -21.2 dB.
// decreasing density play { Dust.ar(XLine.kr(20000, 2, Seq(20, 20))) * 0.5 }
A UGen generating random impulses with values ranging from -1 to +1 .
A UGen which polls results from demand-rate ugens in intervals specified by a duration input.
A UGen which polls results from demand-rate ugens in intervals specified by a
duration input. A value from the level ugen is demanded and output according
to a stream of duration values. When there is a trigger at the reset input, the
level and the dur input are reset.
The argument order is different from its sclang counterpart.
An envelope generator UGen.
An envelope generator UGen. It uses a break point description in its envelope
input, typically coming from an Env object. The envelope may be re-triggered
using the gate input. Upon start and upon re-triggering, the envelope ,
levelScale , levelBias and timeScale parameters are polled and remain
constant for the duration of the envelope.
To construct a manual envelope without the use of the Env class, the format
should be as follows:
val env = Seq[GE](startLevel, numSegments, releaseNode, loopNode, targetLevel1, duration1, curveType1, curvature1, targetLevel2, duration2, curveType2, curvature2, ...)
Where the curve-type is one of Curve.step.id , Curve.lin.id ,
Curve.exp.id , etc. The curvature values are only relevant for the parametric
curve type. The releaseNode and loopNode parameters are segment indices or
the special value -99 indicating that there are no release or loop segments.
Note: The actual minimum duration of a segment is not zero, but one sample step for audio rate and one block for control rate. This may result in asynchronicity when in two envelopes of different number of levels, the envelope times add up to the same total duration. Similarly, when modulating times, the new time is only updated at the end of the current segment; this may lead to asynchronicity of two envelopes with modulated times.
// percussive one-shot
play { PinkNoise.ar(EnvGen.kr(Env.perc, doneAction = freeSelf)) }// fixed duration amplitude envelope play { val env = Env(0, Seq(0.01 -> 1, 0.5 -> 0.5, 0.02 -> 1, 0.5 -> 0)) SinOsc.ar(470) * EnvGen.kr(env, doneAction = freeSelf) }
// amplitude and frequency modulation play { val env = Env(0, Seq(0.01 -> 1, 0.5 -> 0.5, 0.02 -> 0.8, 0.5 -> 0, 0.2 -> 1.2, 0.5 -> 0)) val gate = Impulse.kr(MouseX.kr(0.2, 3), 0.5) val gen = EnvGen.kr(env, gate) SinOsc.ar(270, SinOsc.ar(gen * 473)) * gen * 0.2 }
// Dust-triggered envelope play { val c = Curve.parametric(-4) val env = Env(0, Seq((0.05,0.5,c), (0.1,0.0,c), (0.01,1.0,c), (1.0,0.9,c), (1.5,0.0,c))) val gen = EnvGen.ar(env, Dust.ar(1)) SinOsc.ar(gen * 1000 + 440) * gen * 0.1 }
// two channels play { val p = Curve.parametric(-4) def mkEnv(a: Double, b: Double) = { val env = Env(0.0, Seq((0.05,a,p), (0.1,0.0,p), (0.01,1.0,p), (1.0,b,p), (1.5,0.0,p))) EnvGen.ar(env, Dust.ar(1)) } val gen: GE = Seq(mkEnv(-0.2, -0.4), mkEnv(0.5, 0.9)) SinOsc.ar(gen * 440 + 550) * gen * 0.1 }
// control gate and done-action val x = play { var gen = EnvGen.kr(Env.adsr(), "gate".kr(0), doneAction = "done".kr(0)) SinOsc.ar(440) * gen * 0.1 } x.set("gate" -> 1) // turn on x.set("gate" -> 0) // turn off x.set("gate" -> 1) // turn on x.set("done" -> freeSelf.id, "gate" -> 0) // turn off and free
// fast triggering play { val freq = MouseX.kr(1, 100, 1) val gate = Impulse.ar(freq) val env = Env.perc(0.1, 0.9) val gen = EnvGen.ar(env, gate = gate, timeScale = freq.reciprocal) SinOsc.ar(440) * gen * 0.1 }
A scalar UGen that generates a single random decimal value, using an
exponential distribution from lo to hi .
A scalar UGen that generates a single random decimal value, using an
exponential distribution from lo to hi . Values lo and hi must both have
the same sign and be non-zero.
// random sine frequencies play { val m = Mix.fill(10)(FSinOsc.ar(ExpRand(200.0, 800.0))) m * Line.kr(0.025, 0, 4, doneAction = freeSelf) }
A non-interpolating sound generator based on the difference equations:
A non-interpolating sound generator based on the difference equations:
x[n+1] = sin(im * y[n] + fb * x[n]) y[n+1] = (a * y[n] + c) % 2pi
This uses a linear congruential function to drive the phase indexing of a sine wave. For im = 1, fb = 0 , and a = 1 a normal sine wave results.
// default initial parameters play { FBSineC.ar(SampleRate.ir/4) * 0.2 }
// increase feedback play { FBSineC.ar(SampleRate.ir, 1, Line.kr(0.01, 4, 10), 1, 0.1) * 0.2 }
// increase phase multiplier play { FBSineC.ar(SampleRate.ir, 1, 0, XLine.kr(1, 2, 10), 0.1) * 0.2 }
// modulate frequency and index multiplier play { FBSineC.ar(LFNoise2.kr(1).madd(1e4, 1e4), LFNoise2.kr(1).madd(16, 17), 1, 1.005, 0.7) * 0.2 }
// randomly modulate parameters play { FBSineC.ar( LFNoise2.kr(1).madd(1e4, 1e4), LFNoise2.kr(1).madd(32, 33), LFNoise2.kr(1) * 0.5, LFNoise2.kr(1).madd(0.05, 1.05), LFNoise2.kr(1).madd(0.3, 0.3) ) * 0.2 }
A non-interpolating sound generator based on the difference equations:
A non-interpolating sound generator based on the difference equations:
x[n+1] = sin(im * y[n] + fb * x[n]) y[n+1] = (a * y[n] + c) % 2pi
This uses a linear congruential function to drive the phase indexing of a sine wave. For im = 1, fb = 0, and a = 1 a normal sine wave results.
// default initial parameters play { FBSineL.ar(SampleRate.ir/4) * 0.2 }
// increase feedback play { FBSineL.ar(SampleRate.ir, 1, Line.kr(0.01, 4, 10), 1, 0.1) * 0.2 }
// increase phase multiplier play { FBSineL.ar(SampleRate.ir, 1, 0, XLine.kr(1, 2, 10), 0.1) * 0.2 }
// modulate frequency and index multiplier play { FBSineL.ar(LFNoise2.kr(1).madd(1e4, 1e4), LFNoise2.kr(1).madd(16, 17), 1, 1.005, 0.7) * 0.2 }
// randomly modulate parameters play { FBSineL.ar( LFNoise2.kr(1).madd(1e4, 1e4), LFNoise2.kr(1).madd(32, 33), LFNoise2.kr(1) * 0.5, LFNoise2.kr(1).madd(0.05, 1.05), LFNoise2.kr(1).madd(0.3, 0.3) ) * 0.2 }
A non-interpolating sound generator based on the difference equations:
A non-interpolating sound generator based on the difference equations:
x[n+1] = sin(im * y[n] + fb * x[n]) y[n+1] = (a * y[n] + c) % 2pi
This uses a linear congruential function to drive the phase indexing of a sine wave. For im = 1, fb = 0, and a = 1 a normal sine wave results.
// default initial parameters play { FBSineN.ar(SampleRate.ir/4) * 0.2 }
// increase feedback play { FBSineN.ar(SampleRate.ir, 1, Line.kr(0.01, 4, 10), 1, 0.1) * 0.2 }
// increase phase multiplier play { FBSineN.ar(SampleRate.ir, 1, 0, XLine.kr(1, 2, 10), 0.1) * 0.2 }
// modulate frequency and index multiplier play { FBSineN.ar(LFNoise2.kr(1).madd(1e4, 1e4), LFNoise2.kr(1).madd(16, 17), 1, 1.005, 0.7) * 0.2 }
// randomly modulate parameters play { FBSineN.ar( LFNoise2.kr(1).madd(1e4, 1e4), LFNoise2.kr(1).madd(32, 33), LFNoise2.kr(1) * 0.5, LFNoise2.kr(1).madd(0.05, 1.05), LFNoise2.kr(1).madd(0.3, 0.3) ) * 0.2 }
A UGen performing short-time forward fourier transformations.
A UGen performing short-time forward fourier transformations. In order to
properly link the spectral ugens ( PV_... ), you should begin by using the
output of each UGen (which is just the fft buffer identifier), and use that as
buffer input of the next UGen. That way, the UGen graph is correctly sorted.
E.g. IFFT(PV_...(FFT(buf, in))) .
The UGen will initially output zero until the first FFT can be performed. This
is the case after hop * fftSize . Thus for a default fft buffer size of 1024
and a hop of 0.5, and for a default control block size of 64, for the first
1024*0.5/64 = 8 control blocks the UGen will output zero. This also implies that
the first FFT in this case if performed on the first 512 samples of the in
signal (prepended by 512 zeros). In other words, the first 'full' FFT of the
input happens after fftSize/controlBlockSize cycles, no matter what hop size was
chosen.
If you use FFT for performing signal analysis and not phase vocoder effects, make sure you change the window type accordingly.
// perfect reconstruction play { // with a hop of 0.5 and forward Hann window, // we get a perfect reconstruction delayed // by the fftSize minus one control-block. // (alternatively, you can use a hop of 1.0, // and winType of 1 for both FFT and IFFT) val n = 1024 val hop = 0.5 val buf = LocalBuf(n) val in = PinkNoise.ar(0.5) val fft = FFT(buf, in, hop = hop, winType = 1) val out = IFFT.ar(fft, winType = -1) val dur = (2 * n * hop) / SampleRate.ir - ControlDur.ir val dly = DelayN.ar(in, dur, dur) out - dly }
A phase vocoder UGen that takes a buffer and prepares it to be used in FFT chains, without doing an actual FFT on a signal.
A phase vocoder UGen that takes a buffer and prepares it to be used in FFT chains, without doing an actual FFT on a signal. This is useful if you want to provide a buffer whose content had already been transformed into the Fourier domain.
A first order filter section UGen.
A first order filter section UGen. Filter coefficients are given directly rather than calculated for you. The formula is equivalent to:
out(i) = a0 * in(i) + a1 * in(i-1) + b1 * out(i-1)
// same as OnePole play { val x = LFTri.ar(0.4) * 0.99 FOS.ar(LFSaw.ar(200) * 0.1, 1 - x.abs, 0.0, x) }
// same as OneZero play { val x = LFTri.ar(0.4) * 0.99 FOS.ar(LFSaw.ar(200) * 0.1, 1 - x.abs, x, 0.0) }
A sine oscillator UGen using a fast approximation.
A sine oscillator UGen using a fast approximation. It uses a ringing filter and
is less CPU expensive than SinOsc . However, the amplitude of the wave will
vary with frequency. Generally the amplitude will go down when the frequency
rises and it will go up as if the frequency is lowered.
Warning: In the current implementation, the amplitude can blow up if the
frequency is modulated by certain alternating signals (e.g. abruptly by TRand
).
// plain oscillator play { FSinOsc.ar(441) * 0.2 }
A UGen that constrains a signal to a given range, by "folding" values outside the range.
A UGen that constrains a signal to a given range, by "folding" values outside
the range. This is similar to the fold2 binary operator but permits both a
lower range value lo and an upper range value hi .
Folding can be understood as "reflecting" around the boundaries. For example, if the upper margin is 3, then if an input value exceeds 3, the excess is negatively reflected; 3.1 becomes 2.9, 3.2 becomes 2.8, etc. until the lower margin is reached again where another reflection occurs. Likewise, if the lower margin is 1, then if an input value falls below 1, the undershoot is reflected; 0.9 becomes 1.1, 0.8 becomes 1.2, etc. until the upper margin is reached again where another reflection occurs.
// fold sawtooth wave to modulate timbre play { val hi = SinOsc.ar(0.1).linexp(-1, 1, 0.01, 1.0) Fold.ar(Saw.ar(300), 0, hi) * 0.2 / hi }
A UGen which reads a single sample value from a buffer at a given index.
A UGen which reads a single sample value from a buffer at a given index.
It uses the in argument as index into the buffer, truncating that argument to
an integer. Out-of-range index values are "folded" inside the valid range.
Folding means reflecting the excess at the valid range's boundaries.
For example, if the buffer has four samples, index 4 is wrapped to index 2 (the excess beyond the maximum index of 3 is 4 - 3 = 1, and the excess is folded so that and 3 - 1 = 2), index 5 is folded to index 1, index -1 is folded to index 1, index -2 is folded to index 2, etc.
While designed for monophonic buffers, it works with multi-channel buffers by
treating them as de-interleaved. See the Index UGen for details.
A UGen that generates a set of harmonics around a formant frequency at a given fundamental frequency.
A UGen that generates a set of harmonics around a formant frequency at a given fundamental frequency.
// modulate fundamental frequency play { Formant.ar(XLine.kr(400, 1000, 8), 2000, 800) * 0.2 }
// modulate formant frequency play { Formant.ar(200, XLine.kr(400, 4000, 8), 200) * 0.2 }
// modulate the bandwidth play { Formant.ar(400, 2000, XLine.kr(800, 8000, 8)) * 0.2 }
A FOF-like resonant filter UGen.
A FOF-like resonant filter UGen. Its impulse response is like that of a sine
wave with a Decay2 envelope over it. It is possible to control the attack and
decay times.
Formlet is equivalent to:
Ringz(in, freq, decay) - Ringz(in, freq, attack)
The great advantage to this filter over FOF (Fonction d'onde formantique) is that there is no limit to the number of overlapping grains since the grain is just the impulse response of the filter.
// modulated formant frequency play { val in = Blip.ar(SinOsc.kr(5,0).madd(20, 300), 1000) * 0.1 Formlet.ar(in, XLine.kr(1500, 700, 8), 0.005, 0.04) }
// mouse control of frequency and decay time play { val in = Blip.ar(SinOsc.kr(5,0).madd(20, 300), 1000) * 0.1 val freq = MouseY.kr(700, 2000, 1) val decay = MouseX.kr(0.01, 0.2, 1) Formlet.ar(in, freq, attack = 0.005, decay = decay) }
A UGen that, when triggered, frees a given node.
A UGen that, when triggered, frees enclosing synth.
A UGen that, when triggered, frees enclosing synth. It frees the enclosing synth when the input signal crosses from non-positive to positive.
Note that if the trigger is initially high the UGen will not react. For
example, FreeSelf.kr("foo".kr) will not work if the control is initially 1 .
A work-around is to wrap the input in this case in a Trig object:
FreeSelf.kr(Trig.kr("foo".kr)) . This is most likely a bug.
This UGen outputs its input signal for convenience.
A UGen that, when its input UGen is finished, frees enclosing synth.
A UGen that, when its input UGen is finished, frees enclosing synth. This is
essentially a shortcut for FreeSelf.kr(Done.kr(src)) , so instead of providing
a trigger signal it reads directly the done flag of an appropriate ugen (such as
Line or PlayBuf ).
This UGen outputs its input signal for convenience.
A monophonic reverb UGen.
A monophonic reverb UGen. All parameters are specified in and automatically clipped to the range 0 to 1. The UGen is stateless insofar it does not use a random number generator.
// mouse control for mix and room play { val in = Decay.ar(Impulse.ar(1), 0.25) * LFCub.ar(1200) * 0.1 val mix = MouseX.kr val room = MouseY.kr val verb = FreeVerb.ar(in, mix, room, "damp".kr(0.5)) Pan2.ar(verb) }
A stereophonic reverb UGen.
A stereophonic reverb UGen. All parameters are specified in and automatically clipped to the range 0 to 1. The UGen is stateless insofar it does not use a random number generator. However, if the same input is used for left and right channel, the output channels are different and uncorrelated. There is also some cross-feed between the two channels.
// mouse control for mix and room, random input pan play { val tr = Impulse.ar(1) val in = Decay.ar(tr, 0.25) * LFCub.ar(1200) * 0.1 val in2 = Pan2.ar(in, TRand.ar(-1, 1, tr)) val mix = MouseX.kr val room = MouseY.kr FreeVerb2.ar(in2 \ 0, in2 \ 1, mix, room, "damp".kr(0.5)) }
A frequency shifting UGen.
A frequency shifting UGen. It implements single sideband (SSB) amplitude modulation, also known as frequency shifting, but not to be confused with pitch shifting. Frequency shifting moves all the components of a signal by a fixed amount but does not preserve the original harmonic relationships.
// shift a sine frequency from 200 to 700 Hz play { val freq = Line.ar(0, 500, 5) FreqShift.ar(SinOsc.ar(200) * 0.25, freq) }
// negative frequency to shift downwards play { val freq = Line.ar(0, -500, 5) FreqShift.ar(SinOsc.ar(700) * 0.25, freq) }
A stereophonic reverb UGen.
A stereophonic reverb UGen. It is based on the GVerb LADSPA effect by Juhana Sadeharju.
Note: A CPU spike may occur when the synth is instantiated.
Warning: The UGen has a bug which results in loud noise if the room size
is increased during playback. It seems safe to start with a large room size and
decrease the value during playing. Warning: The UGen may crash the
server if roomSize becomes larger than maxRoomSize .
// mouse control for time and damping play { val tr = Impulse.ar(1) val in = Decay.ar(tr, 0.25) * LFCub.ar(1200) * 0.1 val damp = MouseX.kr val tail = MouseY.kr(1, 100, 1) GVerb.ar(in, roomSize = 20, revTime = tail, damping = damp, maxRoomSize = 20) }
A gate or hold UGen.
A gate or hold UGen. It allows the input signal value to pass when the gate
argument is positive, otherwise it holds last value.
Before the first high gate value is registered, this UGen outputs zero.
A non-interpolating sound generator based on the difference equations:
A non-interpolating sound generator based on the difference equations:
x[n+1] = 1 - y[n] + abs(x[n]) y[n+1] = x[n]
The behavior of the system is only dependent on its initial conditions. Reference: Devaney, R. L. "The Gingerbreadman." Algorithm 3, 15-16, Jan. 1992.
// default initial parameters play { GbmanN.ar(MouseX.kr(20, SampleRate.ir)) * 0.1 }
// change initial parameters play { GbmanN.ar(MouseX.kr(20, SampleRate.ir), -0.7, -2.7) * 0.1 }
// wait for it... play { GbmanN.ar(MouseX.kr(20, SampleRate.ir), 1.2, 2.0002) * 0.1 }
// as a frequency control play { SinOsc.ar(GbmanN.ar(40) * 400 + 500) * 0.4 }
A granular synthesis UGen taking sound stored in a buffer.
A granular synthesis UGen taking sound stored in a buffer. Another buffer can be used to provide an amplitude envelope. The input sound buffer must be monophonic, but output may be multi-channel, using a panorama control.
All arguments except numChannels and maxGrain are polled at grain creation
(trigger) time.
A noise generator UGen which results from flipping random bits in a word.
A noise generator UGen which results from flipping random bits in a word. The
resulting waveform looks like a sample-and-hold function with values between
-1 and +1 (before being multiplied by mul ).
This type of noise has a high RMS level relative to its peak to peak level. With approx. -4.8 dB, the RMS is the same as white noise, but the spectrum is emphasized towards lower frequencies.
// plain noise play { GrayNoise.ar(Seq(0.2, 0.2)) }
A second order high pass filter UGen.
A second order high pass filter UGen.
// modulated frequency play { val in = Saw.ar(200) * 0.5 val freq = SinOsc.ar(XLine.ar(0.3, 100, 20)).madd(3600, 4000) HPF.ar(in, freq) }
// mouse controlled frequency play { val in = WhiteNoise.ar(0.5) val freq = MouseX.kr(200, 10000, 1) HPF.ar(in, freq) }
A two point difference filter UGen.
A two point difference filter UGen. Implements the formula :
out(i) = 0.5 * (in(i) - in(i-1))
Note: HPZ1.ar(DC.ar(x)) the output will be zero, even at the beginning.
// engage with mouse button play { val sig = PinkNoise.ar val flt = HPZ1.ar(sig) LinXFade2.ar(sig, flt, MouseButton.kr(-1, 1)) }
// detect changes play { val z = LFNoise0.ar(2) val f = HPZ1.ar(z) val ch = f sig_!= 0 // input increased or decreased z.poll(ch, "now") 0 }
three point difference filter UGen.
A UGen that returns a unique output value from zero to one for each input value according to a hash function.
A UGen that returns a unique output value from zero to one for each input value according to a hash function. The same input value will always produce the same output value. The input values can have any range.
// scramble mouse motion play { SinOsc.ar( Hasher.kr(MouseX.kr(0,10)).madd(300, 500) ) * 0.2 }
// distort pulse wave play { val lag = MouseY.kr(0.001, 0.1, 1) val freq = MouseX.kr(1, 500, 1) Hasher.ar(Lag.ar(LFPulse.ar(freq), lag)) * 0.2 }
A cubic-interpolating sound generator based on the difference equation:
A cubic-interpolating sound generator based on the difference equation:
x[n+2] = 1 - a * pow(x[n+1], 2) + b * x[n]
This equation was discovered by French astronomer Michel Hénon while studying the orbits of stars in globular clusters.
// default initial parameters play { HenonC.ar(MouseX.kr(20, SampleRate.ir)) * 0.2 }
// mouse-control of parameters play { HenonC.ar(SampleRate.ir/4, MouseX.kr(1,1.4), MouseY.kr(0,0.3)) * 0.2 }
// randomly modulate parameters play { HenonC.ar( SampleRate.ir/8, LFNoise2.kr(1).madd(0.2, 1.2), LFNoise2.kr(1).madd(0.15, 0.15) ) * 0.2 }
// as a frequency control play { SinOsc.ar(HenonC.ar(40, MouseX.kr(1, 1.4), MouseY.kr(0, 0.3)) * 800 + 900) * 0.4 }
A linear-interpolating sound generator based on the difference equation:
A linear-interpolating sound generator based on the difference equation:
x[n+2] = 1 - a * pow(x[n+1], 2) + b * x[n]
This equation was discovered by French astronomer Michel Hénon while studying the orbits of stars in globular clusters.
// default initial parameters play { HenonL.ar(MouseX.kr(20, SampleRate.ir)) * 0.2 }
// mouse-control of parameters play { HenonL.ar(SampleRate.ir/4, MouseX.kr(1,1.4), MouseY.kr(0,0.3)) * 0.2 }
// randomly modulate parameters play { HenonL.ar( SampleRate.ir/8, LFNoise2.kr(1).madd(0.2, 1.2), LFNoise2.kr(1).madd(0.15, 0.15) ) * 0.2 }
// as a frequency control play { SinOsc.ar(HenonL.ar(40, MouseX.kr(1, 1.4), MouseY.kr(0, 0.3)) * 800 + 900) * 0.4 }
A non-interpolating sound generator based on the difference equation:
A non-interpolating sound generator based on the difference equation:
x[n+2] = 1 - a * pow(x[n+1], 2) + b * x[n]
This equation was discovered by French astronomer Michel Hénon while studying the orbits of stars in globular clusters.
// default initial parameters play { HenonN.ar(MouseX.kr(20, SampleRate.ir)) * 0.2 }
// mouse-control of parameters play { HenonN.ar(SampleRate.ir/4, MouseX.kr(1,1.4), MouseY.kr(0,0.3)) * 0.2 }
// randomly modulate parameters play { HenonN.ar( SampleRate.ir/8, LFNoise2.kr(1).madd(0.2, 1.2), LFNoise2.kr(1).madd(0.15, 0.15) ) * 0.2 }
// as a frequency control play { SinOsc.ar(HenonN.ar(40, MouseX.kr(1, 1.4), MouseY.kr(0, 0.3)) * 800 + 900) * 0.4 }
A Hilbert transform UGen.
A Hilbert transform UGen. This transformation produces two signals from a given input with identical frequency content, but with their respective phases shifted to be 90 degrees apart (0.5 pi radians).
The two signals output by Hilbert correspond to the real and imaginary part
of the complex transformed signal. Due to the method used (an IIR filter),
distortion occurs in the upper octave of the frequency spectrum.
The transform can be used to implemented single-side-band (SSB) modulation, but
a dedicated UGen FreqShift is already provided for this case.
// a form of envelope tracking play { val in = SinOsc.ar(440) val h = Hilbert.ar(in) val x = h.real.squared + h.imag.squared x.poll(1) // cos(x)^2 + sin(x)^2 == 1 (ideally) 0 }
Envelope generator UGen with random access index pointer into the break-point function.
Envelope generator UGen with random access index pointer into the break-point function.
Warning: The envelope must be generated using IEnv not Env . IEnv
has a completely different format. Using the wrong format ( Env ) may crash
the server.
To construct a manual envelope without the use of the IEnv class, the format
should be as follows:
val env = Seq[GE](offset, startLevel, numSegments, totalDuration, duration1, curveType1, curvature1, targetLevel1, duration2, curveType2, curvature2, targetLevel2 ...)
// mouse controls index play { import Curve._ val env = IEnv(0, Seq( (0.10, 0.6, lin), (0.02, 0.3, exp), (0.40, 1.0, parametric(-6)), (1.10, 0.0, sine))) val dur = Mix(env.segments.map(_.dur)) val gen = IEnvGen.kr(env, MouseX.kr(0, dur)) SinOsc.ar(gen * 500 + 440) * 0.2 }
A UGen performing an inverse FFT, transforming a buffer containing a spectral domain signal back into the time domain.
A UGen performing an inverse FFT, transforming a buffer containing a spectral domain signal back into the time domain.
// perfect reconstruction play { // with a hop of 0.5 and forward Hann window, // we get a perfect reconstruction delayed // by the fftSize minus one control-block. // (alternatively, you can use a hop of 1.0, // and winType of 1 for both FFT and IFFT) val n = 1024 val hop = 0.5 val buf = LocalBuf(n) val in = PinkNoise.ar(0.5) val fft = FFT(buf, in, hop = hop, winType = 1) val out = IFFT.ar(fft, winType = -1) val dur = (2 * n * hop) / SampleRate.ir - ControlDur.ir val dly = DelayN.ar(in, dur, dur) out - dly }
A scalar UGen that generates a single random integer value, using a uniform
distribution from lo to hi .
A non-band-limited generator UGen for single sample impulses.
A non-band-limited generator UGen for single sample impulses.
// modulating frequency play { Impulse.ar(XLine.kr(100, 20000, 10)) * 0.3 }
// modulating amplitude play { Impulse.kr(XLine.kr(1, 200, 10)) * SinOsc.ar(440) * 0.3 }
// modulating phase play { Impulse.ar(4, Seq(DC.kr(0), MouseX.kr(0, 1))) * 0.3 }
A UGen that reads a signal from a bus.
A UGen that reads a signal from a bus. Whether an audio- or control-bus is used depends on the rate of the UGen.
In.ar and In.kr behave differently with respect to signals left on the bus
in the previous calculation cycle (control block): In.ar can access audio
signals that were generated in the current calculation cycle by synths appearing
earlier in the node tree. It does not read signals produced by nodes in the
previous calculation cycle (i.e. synths appearing later in the node tree), the
input would instead be zero. To allow such "feedback", InFeedback can be used.
In contrast, In.kr does not distinguish between "new" and "old" data: It will
always read the most recent value found on the bus, whether it was generated
earlier in this calculation cycle, left over from the last one, or set before by
the client.
Note: The server uses the first NumOutputBuses channels to write to the
sound card, followed by another NumInputBuses to read from the sound card. For
convenience, the pseudo-UGens PhysicalOut and PhysicalIn can be used.
// cross-synth routing // allocate an internal stereo audio-bus val bus = Bus.audio(s, 2) // writes to internal bus (initially inaudible) val x = play { Out.ar(bus.index, Dust.ar(Seq(345, 345))) } // reads internal bus and makes it audible. // must be after `x` to be able to read the bus signal val y = play(target = x, addAction = addAfter) { val in = In.ar(bus.index, 2) Resonz.ar(in, 555, 0.1) * 10 } // when done, do not forget to free the bus y.free(); x.free(); bus.free()
A UGen which reads a signal from an audio bus with a current or one cycle old timestamp.
A UGen which reads a signal from an audio bus with a current or one cycle old timestamp.
Audio buses adhere to the concept of a cycle timestamp, which increases for
each audio block calculated. When the various output ugens ( Out , OffsetOut
, XOut ) write data to a bus, they mix it with any data from the current
cycle, but overwrite any data from the previous cycle. ( ReplaceOut overwrites
all data regardless.) Thus depending on node order and what synths are writing
to the bus, the data on a given bus may be from the current cycle or be one
cycle old at the time of reading.
In.ar checks the timestamp of any data it reads in and zeros any data from
the previous cycle (for use within that node; the data remains on the bus). This
is fine for audio data, as it avoids feedback, but for control data it is useful
to be able to read data from any place in the node order. For this reason
In.kr also reads data that is older than the current cycle.
In some cases one might also want to read audio from a node later in the
current node order. This can be achieved with InFeedback . It reads from the
previous cycle, and hence introduces a delay of one block size, which by
default is 64 sample frames (equal to about 1.45 ms at 44.1 kHz sample rate).
Note that no delay occurs when the bus contains a signal which has been written already in the current cycle. The delay is only introduced when no present signal exists.
// feedback frequency modulation play { val in = InFeedback.ar(0) // read output SinOsc.ar(in * 1300 + 300) * 0.4 }
// resonator val bus = Bus.audio(s) // internal feedback bus val x = play { val imp = Impulse.ar(1) val in = InFeedback.ar(bus.index) val feed = imp + in * 0.995 // must subtract block-size for correct tuning // (try removing the ControlDur to here the pitch change) val time = 440.reciprocal - ControlDur.ir val dly = DelayC.ar(feed, time, time) Out.ar(bus.index, dly) // alternate between feedback and reference pitch val comp = Seq(dly, SinOsc.ar(440) * 0.2): GE comp * LFPulse.kr(1, Seq(0.0, 0.5)) } x.free(); bus.free() // do not forget to free the bus eventually
A UGen that tests if a signal is within a given range.
A UGen that tests if two signals lie both within a given ranges.
A UGen that tests if two signals lie both within a given ranges. The two input signals can be understood as horizontal and vertical coordinates, therefore the test become one that determines whether the input is within a given "rectangle".
If x >= left and x <= right and y > top and y <= bottom , outputs 1.0,
otherwise outputs 0.0.
// detect whether mouse is in specific horizontal and vertical range play { val x = MouseX.kr; val y = MouseY.kr(1, 0) val in = InRect.kr(x = x, y = y, left = 0.4, top = 0.2, right = 0.6, bottom = 0.4) in * PinkNoise.ar(0.3) }
A UGen which generates a trigger anytime a control bus is set.
A UGen which generates a trigger anytime a control bus is set.
Any time the bus is "touched" i.e. has its value set (using "/c_set" etc.), a
single impulse trigger will be generated. Its amplitude is the value that the
bus was set to. Note that if a signal is continuously written to that bus, for
instance using Out.kr , only one initial trigger is generated once that ugen
starts writing, but no successive triggers are generated.
// envelope trigger val c = Bus.control(s) val x = play { val tr = InTrig.kr(c.index) SinOsc.ar * EnvGen.kr(Env.perc, gate = tr, levelScale = tr) } c.set(1.0) c.set(0.2) c.set(0.1) x.free(); c.free()
A UGen which reads a single sample value from a buffer at a given index.
A UGen which reads a single sample value from a buffer at a given index.
It uses the in argument as index into the buffer, truncating that argument to
an integer. Out-of-range index values are clipped to the valid range.
While designed for monophonic buffers, it works with multi-channel buffers by treating them as de-interleaved. For example, if the buffer has two frames and two channels, index 0 corresponds to frame 0, channel 0, index 1 correspond to frame 0, channel 1, index 2 corresponds to frame 1, channel 0, and index 3 corresponds to frame 1, channel 1.
A UGen which determines the (lowest) index in a buffer at which the two neighboring values contain a given input signal.
A UGen which determines the (lowest) index in a buffer at which the two neighboring values contain a given input signal. The output index is a decimal whose fractional part is suitable for linearly interpolating between the buffer slot values.
For example, if the Buffer contains values 3, 21, 25, 26 and the input signal has the value 22, then the output will be 1.25, because the value 22 is in-between the values stored at indices 1 and 2 and the linear location of 22 is one-quarter of the way along the interval between them: 21 * (1 - 0.25) + 25 * (1 - 0.75) = 22.
If the input value is smaller than the first sample, the output will be zero. If the input value is larger than any sample in the buffer, the output will be the buffer size minus one.
While designed for monophonic buffers, it works with multi-channel buffers by treating them as de-interleaved. For example, if the buffer has two frames and two channels, and the algorithm finds the frame 1 in channel 0, the reported index is 2 (frame * numChannels + channel).
IndexInBetween is the complement of the IndexL UGen.
A UGen which reads from a buffer at a given index, linearly interpolating between neighboring points.
A UGen which reads from a buffer at a given index, linearly interpolating between neighboring points.
It uses the in argument as index into the buffer. Out-of-range index values
are clipped to the valid range. If the index has a fractional part, it is used
to interpolate between the buffer index at the floor and the buffer index at the
ceiling of the index argument.
While designed for monophonic buffers, it works with multi-channel buffers by
treating them as de-interleaved. See the Index UGen for details.
A filter UGen to integrate an input signal with a leak.
A converter UGen that takes a control-rate input and produces an audio-rate output by means of linear interpolation.
A converter UGen that takes a control-rate input and produces an audio-rate output by means of linear interpolation. The current control input value is always reached in at the beginning of the subsequent control block. A special case is the initialization which begins directly at the first control input value (therefore, the first control block of the audio-rate output is is always constant.)
For example, if the block size is 64, and the first three input values are -0.5, 0.6, 0.3, then the output signal will be 65 samples of value -0.5, followed by a linear ramp of 64 samples towards 0.6, followed by a linear ramp of 64 samples to towards 0.3.
// compare control and audio rate play { val a = K2A.ar(WhiteNoise.kr(0.3)) val b = WhiteNoise.ar(0.3) val c = LFPulse.ar(1, Seq(0, 0.5)) c * Seq(a, b) }
A UGen that detects a specific keyboard stroke.
A UGen that detects a specific keyboard stroke. When the given key is not
pressed, the lo value is output, while the key is pressed the hi value is
output. If lag is greater than zero, a Lag -type operation is applied for a
smoother transition between lo and hi .
// determine codes play { val code = Phasor.kr(lo = 0, hi = 127) val k = KeyState.kr(code, lag = 0) val x = Gate.kr(code, k) val ch = x sig_!= Delay1.kr(x) // when a code change is detected, print it x.poll(ch, "code") () }
// gate sound using the 'A' key play { // on Linux, key-code 38 denotes the 'A' key SinOsc.ar(800) * KeyState.kr(38, 0, 0.1) }
A (12TET major/minor) key tracker UGen.
A (12TET major/minor) key tracker UGen. It is based on a pitch class profile of energy across FFT bins and matching this to templates for major and minor scales in all transpositions. It assumes a 440 Hz concert A reference. Output is 0-11 C major to B major, 12-23 C minor to B minor.
A UGen that randomly generates the values -1 or +1 at a rate given by the nearest integer division of the sample rate by the frequency argument.
A UGen that randomly generates the values -1 or +1 at a rate given by the
nearest integer division of the sample rate by the frequency argument. The
difference to LFClipNoise is that this UGen quantizes time to the nearest
integer division of the sample-rate, and the frequency input is only polled at
the moment a new output value is scheduled.
// generator play { LFClipNoise.ar(500) * 0.2 }
// random panning play { val pos = LFClipNoise.ar(4) Pan2.ar(PinkNoise.ar, pos) }
// modulate frequency play { LFClipNoise.ar(XLine.kr(100, 10000, 20)) * 0.2 }
A sine-like oscillator UGen with a shape made of two cubic pieces.
A sine-like oscillator UGen with a shape made of two cubic pieces. It is
smoother than LFPar .
// modulating frequency play { LFPar.ar(XLine.kr(100, 20000, 10)) * 0.1 }
// modulating amplitude play { LFPar.kr(XLine.kr(1, 200, 10)) * SinOsc.ar(440) * 0.1 }
// used as both oscillator and LFO play { LFPar.ar(LFPar.kr(LFPar.kr(0.2).madd(8,10)).madd(400,800)) * 0.1 }
A UGen that randomly generates the values -1 or +1 at a rate given by the nearest integer division of the sample rate by the frequency argument.
A UGen that randomly generates the values -1 or +1 at a rate given by the
nearest integer division of the sample rate by the frequency argument. The
difference to LFClipNoise is that this UGen does not quantize time and
recovers fast from frequency input changes.
// generator play { LFDClipNoise.ar(500) * 0.2 }
// random panning play { val pos = LFDClipNoise.ar(4) Pan2.ar(PinkNoise.ar, pos) }
// modulate frequency play { LFDClipNoise.ar(XLine.kr(100, 10000, 20)) * 0.2 }
A dynamic step noise UGen.
A dynamic step noise UGen. Like LFNoise0 , it generates abruptly changing
random values between -1 and +1 at a rate given by the freq argument, with
two differences: There is no time quantization, and it there is fast recovery
from low freq values.
In contrast, LFNoise0 , LFNoise1 , and LFNoise2 quantize to the nearest
integer division of the sample rate, and they poll the freq argument only when
scheduled, and thus seem to hang when the frequencies get very low.
If very high or very low frequencies are not needed, or fixed frequencies are
used, LFNoise0 is more efficient.
A dynamic ramp noise UGen.
A dynamic ramp noise UGen. Like LFNoise1 , it generates linearly interpolated
random values between -1 and +1 at a rate given by the freq argument, with
two differences: There is no time quantization, and it there is fast recovery
from low freq values.
In contrast, LFNoise0 , LFNoise1 , and LFNoise2 quantize to the nearest
integer division of the sample rate, and they poll the freq argument only when
scheduled, and thus seem to hang when the frequencies get very low.
If very high or very low frequencies are not needed, or fixed frequencies are
used, LFNoise1 is more efficient.
A dynamic ramp noise UGen.
A dynamic ramp noise UGen. It is similar to LFNoise2 , with three
differences: It uses cubic instead of quadratic interpolation for the random
values between -1 and +1 at a rate given by the freq argument. There is no
time quantization, and it there is fast recovery from low freq values.
In contrast, LFNoise0 , LFNoise1 , and LFNoise2 quantize to the nearest
integer division of the sample rate, and they poll the freq argument only when
scheduled, and thus seem to hang when the frequencies get very low.
// compare dynamic and non-dynamic play { val r = MouseX.kr(0.1, 1000, 1) val a = LFNoise2 .ar(r) val b = LFDNoise3.ar(r) val freq = Select.ar(MouseButton.kr(lag = 0), Seq(a, b)) SinOsc.ar(freq.madd(200, 500)) * 0.2 }
A non-band-limited gaussian function oscillator UGen.
A non-band-limited gaussian function oscillator UGen. Output ranges from
minVal to 1. It implements the formula:
f(x) = exp((x - phase).squared / (-2 * width.squared))where x is to vary in the range -1 to 1 over the period dur . minVal is
the initial value at -1. E.g. for default parameters, it is exp(-50) or
roughly zero.
// dur and width can be modulated at audio rate play { val dur = SinOsc.ar(MouseX.kr(2, 1000, 1) * Seq(1.0, 1.1)).linlin(-1, 1, 0.0006, 0.01) val width = SinOsc.ar(Seq(0.5, 0.55)).linlin(-1, 1, 0.01, 0.3) LFGauss.ar(dur, width) * 0.2 }
// several frequencies and widths combined play { val x = MouseX.kr(1, 0.07, 1) val y = MouseY.kr(1, 3) val mod = LFGauss.ar(x, (-1 to -6 by -1).map(i => y.pow(i))) val carr = SinOsc.ar((0 to 5).map(i => 200 * 1.3.pow(i))) Mix(carr * mod) * 0.1 }
// test spectrum play { val son = LeakDC.ar(LFGauss.ar(0.005, 0.2)) BPF.ar(son * 3, MouseX.kr(60, 2000, 1), 0.05) }
A step noise UGen.
A step noise UGen. It generates abruptly changing random values between -1
and +1 at a rate given by the freq argument.
The frequency is quantized to the nearest integer division of the sample rate,
and changes in frequency are only picked up at the next trigger. In contrast,
variant LFDNoise0 has precise frequency and reacts to frequency changes
instantly.
// plain noise play { LFNoise0.ar(1000) * 0.25 }
A ramp noise UGen.
A ramp noise UGen. It generates line segments whose start and end points are
chosen randomly between -1 and +1 . New breakpoints are generated at a
specified frequency.
The frequency is quantized to the nearest integer division of the sample rate,
and changes in frequency are only picked up at the next trigger. In contrast,
variant LFDNoise1 has precise frequency and reacts to frequency changes
instantly.
// plain noise play { LFNoise1.ar(1000) * 0.25 }
A quadratically interpolating noise UGen.
A quadratically interpolating noise UGen. This interpolation happens between
breakpoints chosen randomly between -1 and +1 at a specified frequency.
The frequency is quantized to the nearest integer division of the sample rate,
and changes in frequency are only picked up at the next trigger. In contrast,
variant LFDNoise3 has precise frequency and reacts to frequency changes
instantly.
Note: Due to the interpolation, the output values can occasionally extend beyond the normal range of -1 to +1, if the frequency varies in certain ways.
// plain noise play { LFNoise2.ar(1000) * 0.25 }
A sine-like oscillator UGen with a shape made of two parabolas.
A sine-like oscillator UGen with a shape made of two parabolas. It has audible odd harmonics and is non-band-limited. Its output ranges from -1 to +1.
// modulating frequency play { LFPar.ar(XLine.kr(100, 20000, 10)) * 0.1 }
// modulating amplitude play { LFPar.kr(XLine.kr(1, 200, 10)) * SinOsc.ar(440) * 0.1 }
// used as both oscillator and LFO play { LFPar.ar(LFPar.kr(LFPar.kr(0.2).madd(8,10)).madd(400,800)) * 0.1 }
A non-band-limited pulse oscillator UGen.
A non-band-limited pulse oscillator UGen. Outputs a high value of one and a low value of zero.
// modulating frequency play { LFPulse.ar(XLine.kr(1, 200, 10), 0, 0.2) * 0.1 }
// modulating amplitude play { LFPulse.kr(XLine.kr(1, 200, 10), 0, 0.2) * SinOsc.ar(440) * 0.1 }
// used as both oscillator and LFO play { LFPulse.ar(LFPulse.kr(3, 0, 0.3).madd(200, 200), 0, 0.2) * 0.1 }
A sawtooth oscillator UGen.
A sawtooth oscillator UGen. The oscillator is creating an aliased sawtooth,
that is it does not use band-limiting. For a band-limited version use Saw
instead. The signal range is -1 to +1.
// modulating frequency play { LFSaw.ar(XLine.kr(1, 200, 10)) * 0.1 }
// modulating amplitude play { LFSaw.kr(XLine.kr(1, 200, 10)) * SinOsc.ar(440) * 0.1 }
// neuer deutscher Sägezahn play { LFSaw.ar(LFSaw.kr(3).madd(200, 200)) * 0.1 }
A triangle oscillator UGen designed for low frequency control signals (being non-band-limited).
A triangle oscillator UGen designed for low frequency control signals (being non-band-limited). The output varies from -1 to 1.
With an initial phase of zero, the oscillator begins at 0, rises to 1, then falls to -1 and goes back to zero after one complete phase. With an initial phase of 1 (corresponding to 90 degrees), the oscillator begins at 1 and then falls to -1. With an initial phase of 3 (or 270 degrees), the oscillator begins at -1 and then rises to 1.
// modulating frequency play { LFTri.ar(XLine.kr(100, 20000, 10)) * 0.1 }
// modulating amplitude play { LFTri.kr(XLine.kr(1, 200, 10)) * SinOsc.ar(440) * 0.1 }
// used as both oscillator and LFO play { LFTri.ar(LFTri.kr(LFTri.kr(0.2).madd(8,10)).madd(400,800)) * 0.1 }
A second order low pass filter UGen.
A second order low pass filter UGen.
// modulated frequency play { val in = Saw.ar(200) * 0.5 val freq = SinOsc.ar(XLine.ar(0.3, 100, 20)).madd(3600, 4000) LPF.ar(in, freq) }
// mouse controlled frequency play { val in = WhiteNoise.ar(0.5) val freq = MouseX.kr(200, 10000, 1) LPF.ar(in, freq) }
two point average filter UGen.
two point average filter UGen. Implements the formula :
out(i) = 0.5 * (in(i) + in(i-1))
// engage with mouse button play { val sig = WhiteNoise.ar(0.5) val flt = LPZ1.ar(sig) LinXFade2.ar(sig, flt, MouseButton.kr(-1, 1)) }
three point average filter UGen.
An exponential lag UGen.
An exponential lag UGen. This is essentially the same as OnePole except that
instead of supplying the coefficient directly, it is calculated from a 60 dB lag
time. This is the time required for the filter to converge to within 0.01 % of a
value. This is useful for smoothing out control signals.
A cascaded exponential lag UGen.
A cascaded exponential lag UGen with separate inputs for up and down slope.
A cascaded exponential lag UGen with separate inputs for up and down slope.
Lag2UD.kr(in, up, down) is equivalent to
LagUD.kr(LagUD.kr(in, up, down), up, down) , thus resulting in a smoother
transition. This saves on CPU as you only have to calculate the decay factors
once instead of twice.
A cascaded exponential lag UGen.
A cascaded exponential lag UGen with separate inputs for up and down slope.
A cascaded exponential lag UGen with separate inputs for up and down slope.
Lag3UD.kr(in, up, down) is equivalent to
LagUD.kr(LagUD.kr(LagUD.kr(in, up, down), up, down), up, down) , thus
resulting in a smoother transition. This saves on CPU as you only have to
calculate the decay factors once instead of three times.
A UGen that reads a signal from a control bus and applies a lag filter to it.
A UGen that reads a signal from a control bus and applies a lag filter to it.
This is essentially the same as Lag.kr(In.kr(...), time) .
// portamento play { val c = Bus.control(s) c.set(30) // initial midi-pitch play { val freq = LagIn.kr(c.index, time = 1).midicps SinOsc.ar(freq) * AmpComp.kr(freq) * 0.1 } c.set(70) c.set(100) }
An exponential lag UGen with separate inputs for up and down slope.
A sample-and-hold UGen that outputs the last value before the input changed more than a threshold.
A sample-and-hold UGen that outputs the last value before the input changed more than a threshold. Change is based on the absolute of the differentiation of input signal.
// distortion play { val in = SinOsc.ar(262) val thresh = MouseX.kr(1.0e-3, 2.0, 1, lag = 1) thresh.poll(5, "thresh") LeakDC.ar(LastValue.ar(in, thresh)) * 0.1 }
A sample-and-hold UGen.
A cubic-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26.
A cubic-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26. The function is:
x[n+1] = sin(b * y[n]) + c * sin(b * x[n]) y[n+1] = sin(a * y[n]) + d * sin(a * x[n])
According to Pickover, parameters a and b should be in the range from -3 to +3, and parameters c and d should be in the range from 0.5 to 1.5. The function can, depending on the parameters given, give continuous chaotic output, converge to a single value (silence) or oscillate in a cycle (tone). NOTE: This UGen is experimental and not optimized currently, so is rather hoggish of CPU.
// default initial parameters play { LatoocarfianC.ar(MouseX.kr(20, SampleRate.ir)) * 0.2 }
// randomly modulate all parameters play { LatoocarfianC.ar( SampleRate.ir/4, LFNoise2.kr(2).madd(1.5, 1.5), LFNoise2.kr(2).madd(1.5, 1.5), LFNoise2.kr(2).madd(0.5, 1.5), LFNoise2.kr(2).madd(0.5, 1.5) ) * 0.2 }
A linear-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26.
A linear-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26. The function is:
x[n+1] = sin(b * y[n]) + c * sin(b * x[n]) y[n+1] = sin(a * y[n]) + d * sin(a * x[n])
According to Pickover, parameters a and b should be in the range from -3 to +3, and parameters c and d should be in the range from 0.5 to 1.5. The function can, depending on the parameters given, give continuous chaotic output, converge to a single value (silence) or oscillate in a cycle (tone). NOTE: This UGen is experimental and not optimized currently, so is rather hoggish of CPU.
// default initial parameters play { LatoocarfianL.ar(MouseX.kr(20, SampleRate.ir)) * 0.2 }
// randomly modulate all parameters play { LatoocarfianL.ar( SampleRate.ir/4, LFNoise2.kr(2).madd(1.5, 1.5), LFNoise2.kr(2).madd(1.5, 1.5), LFNoise2.kr(2).madd(0.5, 1.5), LFNoise2.kr(2).madd(0.5, 1.5) ) * 0.2 }
A non-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26.
A non-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26. The function is:
x[n+1] = sin(b * y[n]) + c * sin(b * x[n]) y[n+1] = sin(a * y[n]) + d * sin(a * x[n])
According to Pickover, parameters a and b should be in the range from -3 to +3, and parameters c and d should be in the range from 0.5 to 1.5. The function can, depending on the parameters given, give continuous chaotic output, converge to a single value (silence) or oscillate in a cycle (tone). NOTE: This UGen is experimental and not optimized currently, so is rather hoggish of CPU.
// default initial parameters play { LatoocarfianN.ar(MouseX.kr(20, SampleRate.ir)) * 0.2 }
// randomly modulate all parameters play { LatoocarfianN.ar( SampleRate.ir/4, LFNoise2.kr(2).madd(1.5, 1.5), LFNoise2.kr(2).madd(1.5, 1.5), LFNoise2.kr(2).madd(0.5, 1.5), LFNoise2.kr(2).madd(0.5, 1.5) ) * 0.2 }
A filter UGen to remove very low frequency content DC offset.
A filter UGen to remove very low frequency content DC offset.
// show DC with mouse-controlled coefficient play { val freq = 800 val in = LFPulse.ar(freq).madd(0.5, 0.5) val coef = MouseX.kr(0.9, 0.999) val flt = LeakDC.ar(in, coef) val dc = RunningSum.ar(flt, SampleRate.ir/freq) coef.poll(2) dc .poll(2) 0 }
A UGen that switches between two input signal depending on which is changing less.
A UGen that switches between two input signal depending on which is changing less. Change is based on the absolute of the differentiation of the respective signals.
// mouse-x versus mouse-y play { val x = MouseX.kr(lag = 1) val y = MouseY.kr(lag = 1) val c = LeastChange.kr(x, y) val isX = c sig_== x val isY = 1 - isX // if X change weaker, modulate pan position val p = LFTri.ar(c * 10 * isX) // if Y change weaker, modulate sine frequency val f = LFTri.ar(c * 10 * isY).linexp(-1, 1, 100, 4000) // report current state c.poll(5, "c") x.poll(isX, "now X") y.poll(isY, "now Y") Pan2.ar(SinOsc.ar(f) * 0.1, p) }
Limits the input amplitude to the given level.
Limits the input amplitude to the given level. Unlike Compander , this UGen
will never overshoot, but it needs to look ahead in the input signal,
introducing a delay in its output. The delay time is equal to twice the value of
the dur parameter (the buffer internally used).
// compare dry and wet play { val in = Decay2.ar( Impulse.ar(8, phase = LFSaw.kr(0.25) * 0.7), attack = 0.001, release = 0.3) * FSinOsc.ar(500) val flt = Limiter.ar(in, level = 0.4) LinXFade2.ar(in, flt, MouseButton.kr(-1, 1)) }
A cubic-interpolating sound generator based on the difference equation:
A cubic-interpolating sound generator based on the difference equation:
x[n+1] = (a * x[n] + c) % mThe output signal is automatically scaled to a range of [-1, 1].
// default initial parameters play { LinCongC.ar(MouseX.kr(20, SampleRate.ir)) * 0.2 }
// randomly modulate parameters play { LinCongC.ar( LFNoise2.kr(1.0).madd(1e4, 1e4), LFNoise2.kr(0.1).madd(0.5, 1.4), LFNoise2.kr(0.1).madd(0.1, 0.1), LFNoise2.kr(0.1) ) * 0.2 }
// as frequency control play { SinOsc.ar( LinCongC.ar( 40, LFNoise2.kr(0.1).madd(0.1, 1), LFNoise2.kr(0.1).madd(0.1, 0.1), LFNoise2.kr(0.1) ).madd(500, 600) ) * 0.4 }
A linear-interpolating sound generator based on the difference equation:
A linear-interpolating sound generator based on the difference equation:
x[n+1] = (a * x[n] + c) % mThe output signal is automatically scaled to a range of [-1, 1].
// default initial parameters play { LinCongL.ar(MouseX.kr(20, SampleRate.ir)) * 0.2 }
// randomly modulate parameters play { LinCongL.ar( LFNoise2.kr(1.0).madd(1e4, 1e4), LFNoise2.kr(0.1).madd(0.5, 1.4), LFNoise2.kr(0.1).madd(0.1, 0.1), LFNoise2.kr(0.1) ) * 0.2 }
// as frequency control play { SinOsc.ar( LinCongL.ar( 40, LFNoise2.kr(0.1).madd(0.1, 1), LFNoise2.kr(0.1).madd(0.1, 0.1), LFNoise2.kr(0.1) ).madd(500, 600) ) * 0.4 }
A non-interpolating sound generator based on the difference equation:
A non-interpolating sound generator based on the difference equation:
x[n+1] = (a * x[n] + c) % mThe output signal is automatically scaled to a range of [-1, 1].
// default initial parameters play { LinCongN.ar(MouseX.kr(20, SampleRate.ir)) * 0.2 }
// randomly modulate parameters play { LinCongN.ar( LFNoise2.kr(1.0).madd(1e4, 1e4), LFNoise2.kr(0.1).madd(0.5, 1.4), LFNoise2.kr(0.1).madd(0.1, 0.1), LFNoise2.kr(0.1) ) * 0.2 }
// as frequency control play { SinOsc.ar( LinCongN.ar( 40, LFNoise2.kr(0.1).madd(0.1, 1), LFNoise2.kr(0.1).madd(0.1, 0.1), LFNoise2.kr(0.1) ).madd(500, 600) ) * 0.4 }
A UGen which maps a linear range to an exponential range.
A UGen which maps a linear range to an exponential range. The equivalent
formula is (dstHi / dstLo).pow((in - srcLo) / (srcHi - srcLo)) * dstLo .
Note: No clipping is performed. If the input signal exceeds the input range, the output will also exceed its range.
// translate linear noise into exponential frequencies play { val mod = LFNoise2.ar(10) val lo = MouseX.kr(200, 8000, 1) val hi = MouseY.kr(200, 8000, 1) SinOsc.ar(LinExp.ar(mod, -1, 1, lo, hi)) * 0.1 }
A stereo panorama UGen based on linear amplitude control.
A scalar UGen that generates a single random decimal value between lo and
hi with a selectable skew towards either end.
A scalar UGen that generates a single random decimal value between lo and
hi with a selectable skew towards either end.
The minMax <= 0 behaves rather odd: If minMax is less than 1, the
distribution is skewed towards lo (with lo = 0 and hi = 1 , the mean is
approx. 0.33). If minMax is greater than or equal to 1, the distribution is
skewed towards hi (with lo = 0 and hi = 1 , the mean is approx 0.66).
// two clusters with opposite skew play { val z: GE = 0 to 1 map { n => Mix.fill(10)(FSinOsc.ar(LinRand(200, 800, n))) * SinOsc.ar(0.4, n * math.Pi).max(0) } z * 0.025 }
An linear two channel cross fading UGen.
A line generator UGen that moves from a start value to the end value in a given duration.
A linear ASR-type envelope generator UGen.
A linear ASR-type envelope generator UGen.
// repeated trigger play { val gen = Linen.kr(Impulse.kr(2), 0.01, 0.6, 1.0) SinOsc.ar(440) * gen * 0.1 }
// play once and end the synth play { val gen = Linen.kr(Impulse.kr(0), 0.01, 0.6, 1.0, doneAction = freeSelf) SinOsc.ar(440) * gen * 0.1 }
// play once and sustain val x = play { val gen = Linen.kr("gate".kr(1), 0.01, 0.6, 1.0, doneAction = freeSelf) SinOsc.ar(440) * gen * 0.1 } x.release(4) // release envelope with given duration
// longer gate to sustain for a given duration play { val gate = Trig.kr(1, dur = 2) val gen = Linen.kr(gate, 0.01, 0.6, 1.0, doneAction = freeSelf) SinOsc.ar(440) * gen * 0.1 }
A UGen that produces a scheduled sequences of trigger impulses.
A UGen that produces a scheduled sequences of trigger impulses. Trigger times
are provided as a list (buffer) of absolute offsets from time zero. A trigger is
output as a single control period of value 1 , after which output returns to
zero.
// trigger grains val b = Buffer(s) b.alloc(10) b.setData(Vector(1, 2, 3, 5, 8, 13, 21, 34, 55, 89).map(_ * 0.1f)) // quasi Fibonacci val x = play { val reset = "reset".tr val tr = ListTrig.kr(b.id, BufFrames.kr(b.id), reset) Timer.kr(tr).poll(tr, "timer") val env = EnvGen.ar(Env.perc(0.01, 0.1), gate = tr) SinOsc.ar(Seq(440, 460)) * env * 0.2 } x.set("reset" -> 1) // start anew x.free(); b.free()
The argument order is different from its sclang counterpart.
A UGen that produces a scheduled sequences of trigger impulses.
A UGen that produces a scheduled sequences of trigger impulses. Trigger times
are provided as a list (buffer) of relative durations between consecutive
events. A trigger is output as a single control period of value 1 , after
which output returns to zero.
// trigger grains val b = Buffer(s) b.alloc(11) b.setData(Vector(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89).map(_ * 0.1f)) // Fibonacci val x = play { val reset = "reset".tr val tr = ListTrig2.kr(b.id, BufFrames.kr(b.id), reset) Timer.kr(tr).poll(tr, "timer") val env = EnvGen.ar(Env.perc(0.01, 0.1), gate = tr) SinOsc.ar(Seq(440, 460)) * env * 0.2 } x.set("reset" -> 1) // start anew x.free(); b.free()
The argument order is different from its sclang counterpart.
A UGen that allocates a buffer local to the synth.
A UGen that allocates a buffer local to the synth.
This is convenient for example when using an FFT chain.
A UGen that reads buses that are local to the enclosing synth.
A UGen that reads buses that are local to the enclosing synth. These buses
should be written using a LocalOut ugen. They behave like regular buses, but
are more convenient for the implementation of a self contained effect that uses
a feedback processing loop.
In a synth, there can be only each one control-rate and audio-rate LocalIn /
LocalOut pair. The signal written to a LocalOut will not be read by the
LocalIn until the next control block cycle, introducing a delay of
ControlDur .
Warning: The argument has been changed numChannels: Int in version
1.15.3 to init: GE in version 1.16.0. The previous version was incompatible
with SuperCollider 3.6.x. A previous usage such as LocalIn.ar(2) to create two
channels must now be expressed as LocalIn.ar(Seq(0, 0)) !
// ping-pong delay with feedback play { val src = Decay.ar(Impulse.ar(0.3), 0.1) * WhiteNoise.ar(0.2) val in = LocalIn.ar(Seq(0, 0)) + Seq[GE](src, 0) // read feedback, add source to left chan val dly = DelayN.ar(in, 0.2, 0.2) // delay sound val att = dly * 0.8 // apply decay factor // reverse channels to give ping pong effect LocalOut.ar(Seq(att \ 1, dly \ 0)) dly }
// tank play { val tones = Mix.fill(12) { Pan2.ar( Decay2.ar(Dust.ar(0.05), 0.1, 0.5) * 0.1 * FSinOsc.ar(IRand(36,84).midicps).cubed.max(0), Rand(-1,1)) } val gen = tones + Pan2.ar(Decay2.ar(Dust.ar(0.03), 0.04, 0.3) * BrownNoise.ar, 0) val verb = Mix.fold(gen, 4) { z => AllpassN.ar(z, 0.03, Seq.fill(2)(Rand(0.005,0.02)), 1) } val in = LocalIn.ar(Seq(0, 0)) * 0.98 val flt = OnePole.ar(in, 0.5) val pan = Rotate2.ar(flt \ 0, flt \ 1, 0.23) val v1 = AllpassN.ar(pan, 0.05, Seq.fill(2)(Rand(0.01,0.05)), 2) val v2 = DelayN.ar(v1, 0.3, Seq(0.19,0.26)) val v3 = AllpassN.ar(v2 , 0.05, Seq.fill(2)(Rand(0.03,0.15)), 2) val out = LeakDC.ar(v3) val sig = gen + out LocalOut.ar(sig) sig }
// resonator play { val imp = Impulse.ar val in = LocalIn.ar val feed = imp + in * 0.995 // must subtract block-size for correct tuning // (try removing the ControlDur to here the pitch change) val time = 440.reciprocal - ControlDur.ir val dly = DelayC.ar(feed, time, time) LocalOut.ar(dly) // alternate between feedback and reference pitch val comp = Seq(dly, SinOsc.ar(440) * 0.2): GE comp * LFPulse.kr(1, Seq(0.0, 0.5)) }
A UGen that writes to buses that are local to the enclosing synth.
A UGen that writes to buses that are local to the enclosing synth. These buses
should have been defined by a LocalIn ugen. These behave like regular buses,
but are more convenient for the implementation of a self contained effect that
uses a feedback processing loop.
In a synth, there can be only each one control-rate and audio-rate LocalIn /
LocalOut pair. The signal written to a LocalOut will not be read by the
LocalIn until the next control block cycle, introducing a delay of
ControlDur .
For more examples, see LocalIn.
// ping-pong delay with feedback play { val src = Decay.ar(Impulse.ar(0.3), 0.1) * WhiteNoise.ar(0.2) val in = LocalIn.ar(Seq(0, 0)) + Seq[GE](src, 0) // read feedback, add source to left chan val dly = DelayN.ar(in, 0.2, 0.2) // delay sound val att = dly * 0.8 // apply decay factor // reverse channels to give ping pong effect LocalOut.ar(Seq(att \ 1, dly \ 0)) dly }
A UGen to store values in a buffer upon receiving a trigger.
A UGen to store values in a buffer upon receiving a trigger. When a trigger happens, the current input values are sampled and stored as the next consecutive frame of the buffer.
Storage starts at the buffer beginning and increments the write position until
the buffer is full. While the buffer is not yet full, the UGen outputs 1 ,
then it outputs 0 . The buffer position can be reset using the reset input.
Note that the UGen zeroes the buffer upon first instantiation, to ensure that out-of-date data is not confused with new data.
// fill buffer and plot on client side val b = Buffer(s) b.alloc(100) val x = play { val z = LFCub.kr(10) * EnvGen.kr(Env.linen(1, 2, 1), doneAction = freeSelf) Logger.kr(b.id, z, Impulse.kr(49), reset = 0) } // after synth has completed: b.getData(num = 100).foreach(_.plot()) x.free(); b.free()
The argument order is different from its sclang counterpart.
A noise generator UGen based on the logistic map.
A noise generator UGen based on the logistic map. Its formula is
y[n+1] = chaos * y[n] * (1.0 - y[n])
// increasing parameter play { Logistic.ar(Line.kr(3.55, 4.0, 15), 1000) * 0.5 }
A strange attractor discovered by Edward N.
A strange attractor discovered by Edward N. Lorenz while studying mathematical models of the atmosphere. The system is composed of three ordinary differential equations:
x' = s * (y - x) y' = x * (r - z) - y z' = x * y - b * z
The time step amount h determines the rate at which the ODE is evaluated. Higher values will increase the rate, but cause more instability. A safe choice is the default amount of 0.05.
// vary frequency play { LorenzL.ar(MouseX.kr(20, SampleRate.ir)) * 0.3 }
// randomly modulate parameters play { LorenzL.ar( SampleRate.ir, LFNoise0.kr(1).madd(2, 10), LFNoise0.kr(1).madd(20, 38), LFNoise0.kr(1).madd(1.5, 2) ) * 0.2 }
// as a frequency control play { SinOsc.ar(Lag.ar(LorenzL.ar(MouseX.kr(1, 200)), 3e-3) * 800 + 900) * 0.4 }
A UGen for the extraction of instantaneous loudness.
A UGen for the extraction of instantaneous loudness. A perceptual loudness function which outputs loudness in sones; this is a variant of an MP3 perceptual model, summing excitation in ERB bands. It models simple spectral and temporal masking, with equal loudness contour correction in ERB bands to obtain phons (relative dB), then a phon to sone transform. The final output is typically in the range of 0 to 64 sones, though higher values can occur with specific synthesised stimuli.
Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.
A UGen for extracting mel frequency cepstral coefficients.
A UGen for extracting mel frequency cepstral coefficients. It generates a set of MFCCs; these are obtained from a band-based frequency representation (using the Mel scale by default), and then a discrete cosine transform (DCT). The DCT is an efficient approximation for principal components analysis, so that it allows a compression, or reduction of dimensionality, of the data, in this case reducing 42 band readings to a smaller set of MFCCs. A small number of features (the coefficients) end up describing the spectrum. The MFCCs are commonly used as timbral descriptors.
The output values are somewhat normalised for the range 0.0 to 1.0, but there are no guarantees on exact conformance to this. Commonly, the first coefficient will be the highest value. The number of output channels corresponds to the number of coefficients specified. Technical note: The 0th coefficient is not generated as it consists of multiplying all bands by 1 and summing
Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.
A UGen that masks off bits in the mantissa of the floating point sample value.
A UGen that masks off bits in the mantissa of the floating point sample value. This introduces a quantization noise, but is less severe than linearly quantizing the signal.
// mouse-x controls resolution play { val bits = MouseX.kr(0, 12) MantissaMask.ar(SinOsc.ar(SinOsc.kr(0.2).madd(400, 500)) * 0.4, bits) }
A filter UGen that calculates the median of a running window over its input signal.
A filter UGen that calculates the median of a running window over its input signal. This non-linear filter can be used to reduce impulse noise from a signal.
// engage with mouse button play { val in = Saw.ar(500) * 0.1 + Dust2.ar(100) * 0.9 // signal plus noise val flt = Median.ar(in, 3) LinXFade2.ar(in, flt, MouseButton.kr(-1, 1)) }
// long filter distorts by chopping off peaks in input play { Median.ar(SinOsc.ar(1000) * 0.2, 31) }
The argument order is different from its sclang counterpart.
A single band parametric equalizer UGen.
A single band parametric equalizer UGen. It attenuates or boosts a frequency band.
// mouse controlled frequency and boost play { val in = WhiteNoise.ar(0.25) val freq = MouseX.kr(200, 10000, 1) val gain = MouseY.kr(-12, 12) // bottom to top MidEQ.ar(in, freq, rq = 0.5, gain = gain) }
Contains several helper methods to produce mixed (summed) signals.
A Moog VCF style UGen.
A Moog VCF style UGen. This is a type of resonant low pass filter.
The design of this filter is described in Federico Fontana, "Preserving the Digital Structure of the Moog VCF." In: Proceedings of the ICMC, Copenhagen 2007. Ported to SuperCollider by Dan Stowell.
// mouse controlled play { val in = WhiteNoise.ar(01.1) val freq = MouseY.kr(100, 10000, 1) val gain = MouseX.kr(0, 4) Limiter.ar(MoogFF.ar(in, freq, gain)) }
A UGen that switches between two input signal depending on which is changing more.
A UGen that switches between two input signal depending on which is changing more. Change is based on the absolute of the differentiation of the respective signals.
// mouse-x versus mouse-y play { val x = MouseX.kr(lag = 1) val y = MouseY.kr(lag = 1) val c = MostChange.kr(x, y) val isX = c sig_== x val isY = 1 - isX // if X change stronger, modulate pan position val p = LFTri.ar(c * 10 * isX) // if Y change stronger, modulate sine frequency val f = LFTri.ar(c * 10 * isY).linexp(-1, 1, 100, 4000) // report current state c.poll(5, "c") x.poll(isX, "now X") y.poll(isY, "now Y") Pan2.ar(SinOsc.ar(f) * 0.1, p) }
A UGen that outputs two different values depending on whether the mouse button is pressed.
A UGen that outputs two different values depending on whether the mouse button is pressed. This is useful for testing purposes. Mouse interaction with the regular desktop and windowing system is in no way altered by running this UGen.
// toggle sine frequency play { SinOsc.ar(MouseButton.kr(400, 440, 0.1)) * 0.1 }
A UGen that maps the horizontal screen location of the mouse to a given linear or exponential range.
A UGen that maps the horizontal screen location of the mouse to a given linear or exponential range. This is useful for testing purposes. Mouse interaction with the regular desktop and windowing system is in no way altered by running this UGen.
// control sine frequency play { val freq = MouseX.kr(100, 4000, 1) SinOsc.ar(freq) * 0.1 * AmpComp.kr(freq) }
A UGen that maps the vertical screen location of the mouse to a given linear or exponential range.
A UGen that maps the vertical screen location of the mouse to a given linear or
exponential range. The lo value corresponds to the bottom of the screen,
and the hi value corresponds to the top of the screen (not vice-versa).
This UGen is useful for testing purposes. Mouse interaction with the regular desktop and windowing system is in no way altered by running this UGen.
// control sine frequency play { val freq = MouseY.kr(100, 4000, 1) SinOsc.ar(freq) * 0.1 * AmpComp.kr(freq) }
A scalar UGen that generates a single random decimal value, averaging a given
number of samples from a uniform distribution between lo and hi .
A scalar UGen that generates a single random decimal value, averaging a given
number of samples from a uniform distribution between lo and hi .
// three clusters with different distributions play { val z = 1 to 3 map { n => Mix.fill(10)(FSinOsc.ar(NRand(200, 800, n))) * SinOsc.ar(0.4, n).max(0) } SplayAz.ar(2, z) * 0.025 }
Identifier of the node which contains the UGen.
Identifier of the node which contains the UGen.
// print the UGen value play { NodeID.ir.poll(0) }
A UGen that normalizes the input amplitude to the given level.
A UGen that normalizes the input amplitude to the given level. Unlike
Compander , this UGen will not overshoot, but it needs to look ahead in the
input signal, introducing a delay in its output. The delay time is equal to
twice the value of the dur parameter (the buffer internally used).
// compare dry and wet play { val z = Decay2.ar( Impulse.ar(8, phase = LFSaw.kr(0.25) * 0.7), attack = 0.001, release = 0.3) * FSinOsc.ar(500) val in = z * SinOsc.ar(0.05) * 0.5 val flt = Normalizer.ar(in, dur = 0.15, level = 0.4) LinXFade2.ar(in, flt, MouseButton.kr(-1, 1)) }
Number of audio buses.
Number of audio buses.
// print the UGen value play { NumAudioBuses.ir.poll(0) }
Maximum number of audio buffers.
Maximum number of audio buffers.
// print the UGen value play { NumBuffers.ir.poll(0) }
Number of control buses.
Number of control buses.
// print the UGen value play { NumControlBuses.ir.poll(0) }
Number of input buses.
Number of input buses.
// print the UGen value play { NumInputBuses.ir.poll(0) }
Number of output buses.
Number of output buses.
// print the UGen value play { NumOutputBuses.ir.poll(0) }
Number of currently running synths.
Number of currently running synths.
// print the UGen value play { NumRunningSynths.ir.poll(0) }
A helper UGen equivalent to SampleRate.ir * 0.5.
A UGen that writes a signal onto a bus, delaying the signal such that the input will begin to appear on the bus precisely when the encompassing Synth was scheduled according to its OSC bundle.
A UGen that writes a signal onto a bus, delaying the signal such that the input
will begin to appear on the bus precisely when the encompassing Synth was
scheduled according to its OSC bundle. I.e. if the synth is scheduled to be
started part way through a control cycle, OffsetOut will maintain the correct
offset by buffering the output and delaying it until the exact time that the
synth was scheduled for.
This UGen adds ("mixes") the input-signal to the existing contents of the bus.
Multi-channel input signals, for example a PanAz , are written as such to the
bus without expansion. That is, the bus index argument is used for the first
channel, the second channel will appear on bus + 1 , etc.
If you have an expanding multi-channel input, however, you have to be careful.
For example, if you have
PanAz.ar(2, SinOsc.ar(Seq(444, 555, 666)) * 0.2, Seq(-1, 0, 1)) , this results
in one output UGen carrying one channel, and another one carrying two channels.
(The way this works is consistent with SCLang). In order to get the correct
behaviour (left outputs of the PanAz summed, and right output of the PanAz
summed), wrap this expression in a Mix(...) before passing it to the output
UGen.
Note: You cannot currently achieve sample accurate scheduling in SuperCollider. This UGen is therefore more or less useless.
// compare left-right val sd = SynthDef.recv("offset-out") { val x = Impulse.ar(2) val y = SubsampleOffset.ir y.poll(0, "offset") Out .ar(0, x) OffsetOut.ar(1, x) // right channel will be delayed against left } val x = Synth(s) s ! osc.Bundle.millis(System.currentTimeMillis + 1000, x.newMsg(sd.name, s))
A one pole (IIR) filter UGen.
A one zero (FIR) filter UGen.
An onset detecting UGen for musical audio signals.
An onset detecting UGen for musical audio signals. It detects the beginning of notes/drumbeats/etc. Outputs a control-rate trigger signal which is 1 when an onset is detected, and 0 otherwise.
The onset detection should work well for a general range of monophonic and polyphonic audio signals. The onset detection is purely based on signal analysis and does not make use of any "top-down" inferences such as tempo.
There are different functions available for the analysis:
- 0 "power" -- generally OK, good for percussive input, and also very efficient - 1 "magsum" -- generally OK, good for percussive input, and also very efficient - 2 "complex" -- performs generally very well, but more CPU-intensive - 3 "rcomplex" (default) -- performs generally very well, and slightly more efficient than "complex" - 4 "phase" -- generally good, especially for tonal input, medium efficiency - 5 "wphase" -- generally very good, especially for tonal input, medium efficiency - 6 "mkl" -- generally very good, medium efficiency, pretty different from the other methods
The differences aren't large, so it is recommended you stick with the default "rcomplex" unless you find specific problems with it. Then maybe try "wphase". The "mkl" type is a bit different from the others so maybe try that too. They all have slightly different characteristics, and in tests perform at a similar quality level.
A UGen that writes a signal onto a bus.
A UGen that writes a signal onto a bus. It adds ("mixes") the input-signal to the existing contents of the bus.
Multi-channel input signals, for example a PanAz , are written as such to the
bus without expansion. That is, the bus index argument is used for the first
channel, the second channel will appear on bus + 1 , etc.
If you have an expanding multi-channel input, however, you have to be careful.
For example, if you have
PanAz.ar(2, SinOsc.ar(Seq(444, 555, 666)) * 0.2, Seq(-1, 0, 1)) , this results
in one output UGen carrying one channel, and another one carrying two channels.
(The way this works is consistent with SCLang). In order to get the correct
behaviour (left outputs of the PanAz summed, and right output of the PanAz
summed), wrap this expression in a Mix(...) before passing it to the output
UGen.
// cross-synth routing // allocate an internal stereo audio-bus val bus = Bus.audio(s, 2) // writes to internal bus (initially inaudible) val x = play { Out.ar(bus.index, Dust.ar(Seq(345, 345))) } // reads internal bus and makes it audible. // must be after `x` to be able to read the bus signal val y = play(target = x, addAction = addAfter) { val in = In.ar(bus.index, 2) Resonz.ar(in, 555, 0.1) * 10 } // when done, do not forget to free the bus y.free(); x.free(); bus.free()
A phase vocoder UGen that performs a complex addition of the two inputs.
A phase vocoder UGen that performs a complex addition of the two inputs. The
formula is (Re(A) + Re(B)) + i(Im(A) + Im(B)) .
A phase vocoder UGen that randomizes the order of the bins.
A phase vocoder UGen that randomizes the order of the bins. The trigger will select a new random ordering.
A phase vocoder UGen that stretches and shifts the spectrum.
A phase vocoder UGen that stretches and shifts the spectrum. It takes each bin, first stretches (scales) its position (bin number) with a given factor, and then adds a shift to it.
A phase vocoder UGen that combine low and high bins from two inputs.
A phase vocoder UGen that combine low and high bins from two inputs. It does so by copying low bins from one input and the high bins of the other, thus realizes a kind of "wipe" between the two input signals.
A phase vocoder UGen that clears bins above or below a cutoff point.
A UGen that applies the conformal mapping z => (z - a) / (1 - za*) to its
input FFT bins z .
A UGen that applies the conformal mapping z => (z - a) / (1 - za*) to its
input FFT bins z .
It makes a transformation of the complex plane so the output is full of phase
vocoder artifacts but may be musically interesting. One should usually keep
|a| < 1 , although bigger values may be used to produce noise. A value of
a = 0 gives back the input mostly unperturbed.
// mouse control play { val sf = Seq.fill(3)(Rand(0.1, 0.5)) val sadd = Seq(1, 1.1, 1.5, 1.78, 2.45, 6.7).map(_ * 220) val in = Mix(LFSaw.ar(SinOsc.kr(sf).madd(10, sadd)) * 0.3) val fft = FFT(LocalBuf(2048), in) val re = MouseX.kr(0.01, 2.0, 1) val im = MouseY.kr(0.01, 10.0, 1) val pv = PV_ConformalMap(fft, re, im) val out = IFFT.ar(pv) val vrb = CombN.ar(out, 0.1, 0.1, 10) Pan2.ar(out + vrb * 0.5, 0, 0.3) }
A phase vocoder UGen that converts the bins into their complex conjugate counterparts.
A phase vocoder UGen that converts the bins into their complex conjugate counterparts. The complex conjugate is equal to the input, but with reversed sign of the imaginary part.
A phase vocoder UGen that copies the spectral frames from chainA to chainB.
A phase vocoder UGen that copies the spectral frames from chainA to chainB. This allows for parallel processing of spectral data without the need for multiple FFT UGens, and to copy out data at that point in the chain for other purposes. chainA and chainB must be the same size. The output will carry further chainA, so you chan insert the ugen at the appropriate place in the signal chain.
A phase vocoder UGen that combines the magnitudes of first input and phases of the second input.
A phase vocoder UGen that combines the magnitudes of first input and phases of the second input. phases of the first input.
A phase vocoder UGen that adds a different constant random phase shift to each bin.
A phase vocoder UGen that adds a different constant random phase shift to each bin. The trigger will select a new set of random phases.
A phase vocoder UGen that performs a complex division of the two inputs.
A phase vocoder UGen that performs a complex division of the two inputs. Be
careful that chainB , the divisor, does not contain zeroes as they would
obviously blow up the division.
An FFT based onset detector UGen using a balance of two features.
An FFT based onset detector UGen using a balance of two features. It is based on work described in Hainsworth (2003), "Techniques for the Automated Analysis of Musical Audio," PhD thesis, University of Cambridge. See especially p. 128. The Hainsworth metric is a modification of the Kullback Liebler distance.
// observe detection play { val sig = Decay.ar(Dust.ar(2), 0.1) * WhiteNoise.ar(0.25) val th = MouseX.kr(0.3, 1.0, lag = 0) th.poll(HPZ1.kr(th).abs, "thresh") val h = MouseY.kr(1.0, 0.1, lag = 0) val f = 1 - h h.poll(HPZ1.kr(h).abs, "h-f") val tr = PV_HainsworthFoote.ar(FFT(LocalBuf(2048), sig), h, f, thresh = th) Seq(sig, SinOsc.ar(440) * Decay.ar(tr * 0.01, 0.1)) }
An FFT based onset detector UGen using a mix of extracted features.
An FFT based onset detector UGen using a mix of extracted features. It is based on work described in Jensen and Andersen (2003), "Real-time Beat Estimation Using Feature Extraction," in: Proceedings of the Computer Music Modeling and Retrieval Symposium.
First order derivatives of the features are taken. The threshold may need to be set low to pick up on changes.
// observe detection play { val sig = Decay.ar(Dust.ar(2), 0.1) * WhiteNoise.ar(0.25) val th = MouseX.kr(0.1, 1.0, lag = 0) th.poll(HPZ1.kr(th).abs, "thresh") val tr = PV_JensenAndersen.ar(FFT(LocalBuf(2048), sig), thresh = th) Seq(sig, SinOsc.ar(440) * Decay.ar(tr * 0.01, 0.1)) }
A phase vocoder UGen that passes only those bins whose magnitudes constitute local maxima.
A phase vocoder UGen that passes only those bins whose magnitudes constitute local maxima. Additionally, the given threshold is also used to filter out bins whose magnitude lies below this threshold.
A phase vocoder UGen that passes only those bins whose magnitudes are above a given threshold.
A phase vocoder UGen that passes only those bins whose magnitudes are below a given threshold.
A phase vocoder UGen that limits (clips) the magnitude of the bins to a given threshold.
A phase vocoder UGen that divides magnitudes of two inputs and keeps the phases of the first input.
A phase vocoder UGen that freezes the magnitudes at current levels.
A phase vocoder UGen that freezes the magnitudes at current levels. Freezing happens when the freeze input has a value of > 0.
A phase vocoder UGen that multiplies the magnitudes of two inputs and keeps the phases of the first input.
A phase vocoder UGen that multiplies the magnitudes by random noise.
A phase vocoder UGen that stretches and shifts the magnitudes of the spectrum.
A phase vocoder UGen that stretches and shifts the magnitudes of the spectrum.
This is live PV_BinShift but instead of scaling and shifting the whole complex
bins (magnitude and phase), this only operates on the magnitudes and leaves the
phases in their original bins.
A phase vocoder UGen that averages each bin's magnitude with its neighbors.
A phase vocoder UGen that squares the magnitudes and re-normalizes to previous peak.
A phase vocoder UGen that squares the magnitudes and re-normalizes to previous peak. This makes weak bins weaker.
A phase vocoder UGen that outputs the bins with the maximum magnitude of the two inputs.
A phase vocoder UGen that outputs the bins with the minimum magnitude of the two inputs.
A phase vocoder UGen that performs a complex multiplication of the two inputs.
A phase vocoder UGen that performs a complex multiplication of the two inputs.
The formula is
(Re(A) * Re(B) - Im(A) * Im(B)) + i(Im(A) * Re(B) + Re(A) * Im(B)) .
A phase vocoder UGen that shifts the phase of each bins by a given amount.
A phase vocoder UGen that shift the phase of all bins by 270 (or -90) degrees.
A phase vocoder UGen that shift the phase of all bins by 90 degrees.
A phase vocoder UGen that randomly clears out bins of the signal.
A phase vocoder UGen that randomly clears out bins of the signal. Which bins are wiped out is subject to a random choice (only the amount is specified) that remains constant between triggers.
A phase vocoder UGen that cross-fades between two input spectra by taking bins randomly from them according to a given probability.
A phase vocoder UGen that cross-fades between two input spectra by taking bins randomly from them according to a given probability.
A phase vocoder UGen that makes a series of gaps in a spectrum.
A phase vocoder UGen that makes a series of gaps in a spectrum. This is done by multiplying the spectrum with a kind of rectangle wave that goes from zero to nyquist. The high slope of the rectangle lets the input bins pass (quasi pass-band), the low slope filters them out (quasi stop-band).
A phase vocoder UGen that switches between two input spectra according to a rectangle wave.
A phase vocoder UGen that switches between two input spectra according to a
rectangle wave. This is basically identical to PV_RectComb , however during
the low slopes of the rectangle wave, instead of clearing out the bins, it
copies over the corresponding bins of the second fft input buffer.
A UGen that writes a complex input signal into an FFT buffer.
A UGen that writes a complex input signal into an FFT buffer. The input is a sequence of interleaved magnitudes and phases. It is written to an FFT buffer ready for transforming it back into time-domain audio using IFFT.
// harmonic sound with changing overtone intensities play { // create simple undulating magnitudes val m0 = FSinOsc.kr(Seq.fill(100)(ExpRand(0.1, 1))) * 0.5 + 0.5 // give them a "rolloff" to make the sound less unpleasant val m1 = m0 * Seq.tabulate(100)(_.linlin(0, 99, 1.0, 0.01).squared) // turn the bins on and off at different rates val mags = m1 * LFPulse.kr(Seq.fill(100)(2 pow IRand(-3, 5))) // ignore phase val phases: GE = Seq.fill(100)(0) // We need to create an FFT chain to feed our data in to. // The easiest way is to do an FFT on some signal which we then ignore! val buf = FFT(LocalBuf(512), DC.ar(0)) // now we can do the packing val chain = PackFFT(buf, 512, Zip(mags, phases), 0, 99, 1) val sig = IFFT.ar(chain) Pan2.ar(sig) }
A stereo panorama UGen based on equal-power amplitude control.
A four channel equal-power panorama UGen.
A four channel equal-power panorama UGen. The outputs are in order leftFront
, rightFront , leftBack , rightBack .
// mouse controlled pan position play { val x = MouseX.kr(-1, 1) val y = MouseY.kr(-1, 1) val p = Pan4.ar(PinkNoise.ar, x, y) // make a stereo mix with different timbre front and back val f = Resonz.ar(Seq(p.leftFront, p.rightFront), 4000, 0.2) * 4 val r = Resonz.ar(Seq(p.leftBack , p.rightBack ), 1500, 0.2) * 4 f + r }
An azimuth-based panorama UGen.
An azimuth-based panorama UGen. It uses vector-based-amplitude panning where
the arbitrary number of speakers is supposed to be distributed in a circle with
even spacing between them. It uses an equal-power-curve to transition between
adjacent speakers. Note the different default value for the orient
argument!
Use case: To spread an multi-channel input signal across an output bus with a
different number of channels, such that the first input channel is played on the
first output channel (no spread to adjacent channels) and the last input channel
is played to the last output channel (no spread to adjacent channels), you would
create a dedicated PanAz per input channel where the pan position is
inChanIdx * 2f / (inChannels - 1) * (outChannels - 1) / outChannels .
An Ambisonics B-format encoding UGen.
An Ambisonics B-format encoding UGen. B-format is the name for first order Ambisonics which has four channels W, X, Y, Z. By omitting the elevation control, we get a two dimensional planar encoded signal consisting only of the X and Y channels.
Note that unlike PanB2, azimuth is in radians.
A two dimensional Ambisonics B-format encoding UGen.
A two dimensional Ambisonics B-format encoding UGen. B-format is the name for first order Ambisonics which normally has four channels W, X, Y, Z. By omitting the elevation control, we get a two dimensional planar encoded signal consisting only of the W, X and Y channels.
Note that unlike PanB, azimuth is normalized between -1 and +1.
// 4-channel rotation of opposite sounds play { val p = WhiteNoise.ar(0.05) // first source val q = Mix(LFSaw.ar(Seq(200, 200.37))) * 0.03 // second source // B-format encode 2 signals at opposite sides of the circle val enc = PanB2.ar(p, -0.5) + PanB2.ar(q, +0.5) val Seq(w, x, y) = (0 to 2).map(enc \ _) val rot = Rotate2.ar(x, y, MouseX.kr(-1, +1)) // B-format decode to quad (front-left, front-right, rear-left, rear-right) DecodeB2.ar(4, w, rot.xr, rot.yr) }
A UGen for partitioned convolution.
A UGen for partitioned convolution. Its advantage over non-partitioning UGens
such as Convolution2 is that the impulse response can be arbitrarily large
amortization is used to spread processing and avoid CPU spikes.
The impulse response buffer must be specially prepared, using a /b_gen
command that transforms an existing regularly formatted buffer to a new
partitioned convolution ready buffer.
// Dan Stowell's reverb // synthesize impulse response val ir = (1f +: Vector.fill(100)(0f)) ++ (1f to 0f by -0.00002f).map { f => if (math.random < 0.5) 0f else f.pow(8) * (math.random - 0.5).signum * 0.1f } // ir.plot() // send the IR to a regular buffer val irBuf = Buffer(s) irBuf.alloc(ir.size) irBuf.setData(ir) // calculate the partitioning parameters val fftSize = 2048 val numPart = (ir.size * 2.0 / fftSize).ceil.toInt // 49 val partSize = fftSize * numPart // 100352 // create the specially formatted partitioned buffer val partBuf = Buffer(s) partBuf.alloc(partSize) // currently no predefined method for this command! s ! osc.Message("/b_gen", partBuf.id, "PreparePartConv", irBuf.id, fftSize) // now we can forget about the input buffer irBuf.free() val x = play { // trigger IR every 4 seconds val in = Impulse.ar(0.25) * 0.5 PartConv.ar(in, fftSize, partBuf.id) } // do not forget to free the buffer eventually x.free(); partBuf.free()
A UGen which pauses and resumes another node.
A UGen which pauses and resumes another node. Note that the UGen initially
assumes the node is running, that is, if gate is initially 1, this will
not resume a paused node. Instead, the gate must go to zero and back to
one to resume the node. Additionally, this UGen will only cause action if the
gate value changes, that is, if the node is paused or resumed otherwise, this
UGen will not interfere with that action, unless the gate value is adjusted.
A UGen that, when triggered, pauses enclosing synth.
A UGen that, when triggered, pauses enclosing synth. It pauses the enclosing synth when the input signal crosses from non-positive to positive.
Note that if the trigger is initially high the UGen will not react. For
example, PauseSelf.kr("foo".kr) will not work if the control is initially 1
. A work-around is to wrap the input in this case in a Trig object:
PauseSelf.kr(Trig.kr("foo".kr)) . This is most likely a bug.
This UGen outputs its input signal for convenience.
A UGen that, when its input UGen is finished, pauses enclosing synth.
A UGen that, when its input UGen is finished, pauses enclosing synth. This is
essentially a shortcut for PauseSelf.kr(Done.kr(src)) , so instead of
providing a trigger signal it reads directly the done flag of an appropriate
ugen (such as Line or PlayBuf ).
This UGen outputs its input signal for convenience.
A UGen to measure a signal's peak amplitude.
A UGen to measure a signal's peak amplitude. Technically, this UGen works like
RunningMax after the absolute value of the input signal is taken.
The UGen keeps an internal state that reflects the maximum absolute input value observed. When a trigger occurs at the reset input, it first copies the current maximum value to its output and then (quasi-simultaneously) resets its internal state to the current absolute input value. This way, the peak value seen from the outside at trigger time is the correct peak value up to that moment. See the 'illustrate timing' example to understand this timing.
// illustrate timing play { val i = Impulse.ar(0) // first impulse after 100ms val t1 = DelayN.ar(i * 1.0 , 0.100, 0.100) // one sample later val t2 = Delay1.ar(t1) * 0.5 // another sample later val t3 = Delay1.ar(t2) val p = Peak.ar(t1 + t2, t2) // at t1, peak has already seen t1 p.poll(t1, "t1") // at t2, peak still reports 1.0, while internally resetting p.poll(t2, "t2") // at t3, we observe 0.5, therefore peak did reset at t2 p.poll(t3, "t3") () }
A UGen that continually reports the peak amplitude of the signal received at the input.
A UGen that continually reports the peak amplitude of the signal received at
the input. If the absolute input level drops below the observed peak value, this
value decreases by the factor given as decay parameter (but no more than the
current absolute input level).
// mouse-controlled decay play { val in = Impulse.ar(2) val decay = MouseX.kr(0.995, 1.0001, 1).min(1.0) decay.poll(HPZ1.kr(decay).abs, "decay") val p = PeakFollower.ar(in, decay) val tr = Impulse.ar(20) val pm = RunningMax.ar(p, tr) pm.roundTo(0.001).poll(20, "peak") in }
A linear repeating ramp UGen between start and end values.
A linear repeating ramp UGen between start and end values. Using a trigger
input, it can be reset to a specific position. Upon reaching the end of its
ramp, Phasor will wrap back to its start value. Note: Since end is
defined as the wrap point, its value is never actually output.
// glissandi play { // mouse-x controls phasor speed val freq = MouseX.kr(0.2, 2, 1) // mouse button can be used to jump back val reset = MouseButton.kr(lag = 0) val p = Phasor.ar(reset, freq / SampleRate.ir) SinOsc.ar(p.linlin(0, 1, 600, 1000)) * 0.1 }
A graph element which reads from a connected sound driver input.
A graph element which reads from a connected sound driver input. This is a convenience
element for accessing physical input signals, e.g. from a microphone connected to your
audio interface. It expands to a regular In UGen offset by NumOutputBuses.ir.
For example, consider an audio interface with channels 1 to 8 being analog line inputs, channels 9 and 10 being AES/EBU and channels 11 to 18 being ADAT inputs. To read a combination of the analog and ADAT inputs, either of the following statement can be used:
PhysicalIn(Seq(0, 8), Seq(8, 8)) PhysicalIn(Seq(0, 8), Seq(8)) // numChannels wraps!
A graph element which writes to a connected sound driver output.
A graph element which writes to a connected sound driver output. This is a convenience
element for Out with the ability to provide a set of discrete indices to which
corresponding channels of the input signal are mapped, whereas multichannel expansion
with respect to the index argument of Out typically do not achieve what you expect.
For example, to flip left and right when writing a stereo signal:
// sine appears on the right channel, and noise on the left play { PhysicalOut( Seq( 1, 0 ), Seq( SinOsc.ar * LFPulse.ar(4), WhiteNoise.ar ) * 0.2 )}
A noise generator UGen whose spectrum falls off in power by 3 dB per octave.
A noise generator UGen whose spectrum falls off in power by 3 dB per octave. This gives equal power over the span of each octave. This version gives 8 octaves of pink noise.
The values produced by this UGen were observed to lie with very high
probability between approx. -0.65 and +0.81 (before being multiplied by
mul ). The RMS is approx. -16 dB.
// plain noise play { ClipNoise.ar(Seq(0.2, 0.2)) }
An autocorrelation based pitch following UGen.
An autocorrelation based pitch following UGen. It is more accurate than
ZeroCrossing , but more also more CPU costly. For most purposes the default
settings can be used and only in needs to be supplied.
The UGen has two outputs: The first output is the frequency estimate in Hertz,
the second output is a toggle hasFreq , which tells whether a pitch was found
(1) or not (0). If the clarify argument is used, hasFreq has more fine
grained information.
The pitch follower executes periodically at the rate specified by execFreq in
cps. First it detects whether the input peak to peak amplitude is above the
ampThresh . If it is not then no pitch estimation is performed, the hasFreq
output is set to zero and the freq output is held at its previous value.
Otherwise, the autocorrelation is calculated, and the first peak after the peak
around the lag of zero that is above peakThresh times the amplitude of the
peak at lag zero is reported.
// pitch-follower resynthesizing with saw tooth play { // be careful and use headphones! val in = Mix(PhysicalIn.ar(0, 2)) val amp = Amplitude.kr(in, 0.05, 0.05) val p = Pitch.kr(in, ampThresh = 0.02, median = 7) val saw = Mix(VarSaw.ar(p.freq * Seq(0.5, 1, 2), 0, LFNoise1.kr(0.3,0.1,0.1)) * amp) Mix.fold(saw, 6) { res => AllpassN.ar(res, 0.040, Rand(0, 0.040), Rand(0, 0.040), 2) } }
A time domain granular pitch shifter.
A time domain granular pitch shifter. Grains have a triangular amplitude envelope and an overlap of 4:1.
A UGen to play back samples from a buffer in memory.
A UGen to play back samples from a buffer in memory.
PlayBuf provides a kind of high-level interface to sample-playback, whereas
BufRd represents a kind of lower-level access. While BufRd has a
random-access-pointer in the form of a phase input, PlayBuf advances the phase
automatically based on a given playback speed. PlayBuf uses cubic
interpolation.
A Karplus-Strong UGen.
A UGen for printing the current output value of its input to the console.
A UGen for printing the current output value of its input to the console.
A band-limited pulse wave generator UGen, capable of pulse width modulation.
A band-limited pulse wave generator UGen, capable of pulse width modulation.
// modulate frequency play { Pulse.ar(XLine.kr(40, 4000, 6)) * 0.2 }
// modulate pulse width play { Pulse.ar(200, Line.kr(0.01, 0.99, 8)) * 0.2 }
// two pulses with different frequencies through resonant filter play { RLPF.ar(Pulse.ar(Seq(100, 250)) * 0.2, XLine.kr(8000, 400, 6), 0.05) }
A UGen that counts the number of triggers observed.
A UGen that counts the number of triggers observed.
// count mouse clicks, reset at 10 play { val tr = MouseButton.kr(lag = 0) val reset = PulseDivider.kr(tr, 10) val c = PulseCount.kr(tr, reset) c.poll(tr + Impulse.kr(0), "count") () }
A UGen that decimates trigger by outputting one impulse each time a certain number of triggers at its input have been received.
A UGen that decimates trigger by outputting one impulse each time a certain number of triggers at its input have been received.
// every two mouse-button clicks play { val in = MouseButton.kr(lag = 0) in.poll(in, "in") val out = PulseDivider.kr(in, 2, -1) out.poll(out, "out") () }
// rhythmic 1:4 pattern play { val p = Impulse.ar(8) val d = PulseDivider.ar(p, 4) val a = SinOsc.ar(1200) * Decay2.ar(p, 0.005, 0.1) * 0.3 val b = SinOsc.ar( 600) * Decay2.ar(d, 0.005, 0.5) * 0.3 Seq(a, b) }
A cubic-interpolating sound generator based on the difference equation:
A cubic-interpolating sound generator based on the difference equation:
x[n+1] = a * pow(x[n], 2) + b * x[n] + c
// default parameters play { QuadC.ar(SampleRate.ir/4) * 0.2 }
// logistic map play { // equation: x1 = -r*x0^2 + r*x0 val r = MouseX.kr(3.5441, 4) // stable range QuadC.ar(SampleRate.ir/4, -r, r, 0, 0.1) * 0.4 }
// logistic map as frequency control play { val r = MouseX.kr(3.5441, 4) // stable range SinOsc.ar(QuadC.ar(40, -r, r, 0, 0.1).madd(800, 900)) * 0.4 }
A linear-interpolating sound generator based on the difference equation:
A linear-interpolating sound generator based on the difference equation:
x[n+1] = a * pow(x[n], 2) + b * x[n] + c
// default parameters play { QuadL.ar(SampleRate.ir/4) * 0.2 }
// logistic map play { // equation: x1 = -r*x0^2 + r*x0 val r = MouseX.kr(3.5441, 4) // stable range QuadL.ar(SampleRate.ir/4, -r, r, 0, 0.1) * 0.4 }
// logistic map as frequency control play { val r = MouseX.kr(3.5441, 4) // stable range SinOsc.ar(QuadL.ar(40, -r, r, 0, 0.1).madd(800, 900)) * 0.4 }
A non-interpolating sound generator based on the difference equation:
A non-interpolating sound generator based on the difference equation:
x[n+1] = a * pow(x[n], 2) + b * x[n] + c
// default parameters play { QuadN.ar(SampleRate.ir/4) * 0.2 }
// logistic map play { // equation: x1 = -r*x0^2 + r*x0 val r = MouseX.kr(3.5441, 4) // stable range QuadN.ar(SampleRate.ir/4, -r, r, 0, 0.1) * 0.4 }
// logistic map as frequency control play { val r = MouseX.kr(3.5441, 4) // stable range SinOsc.ar(QuadN.ar(40, -r, r, 0, 0.1).madd(800, 900)) * 0.4 }
A resonant high pass filter UGen.
A resonant high pass filter UGen.
// mouse controlled frequency and Q play { val in = WhiteNoise.ar(0.5) val freq = MouseX.kr(200, 10000, 1) val q = MouseY.kr(1, 100, 1) // bottom to top val flt = RHPF.ar(in, freq, q.reciprocal) flt / q.sqrt // compensate for energy loss }
A resonant low pass filter UGen.
A resonant low pass filter UGen.
// mouse controlled frequency and Q play { val in = WhiteNoise.ar(0.5) val freq = MouseX.kr(200, 10000, 1) val q = MouseY.kr(1, 100, 1) // bottom to top val flt = RLPF.ar(in, freq, q.reciprocal) flt / q.sqrt // compensate for energy loss }
A UGen that delivers the conversion factor from frequency in Hertz to radians (normalized frequency).
A UGen that delivers the conversion factor from frequency in Hertz to radians
(normalized frequency). The relation is RadiansPerSample * sr = 2pi , thus
multiplying the UGen with a frequency between zero and nyquist (sr/2) yields the
normalized frequency between zero and pi.
// print the UGen value play { RadiansPerSample.ir.poll(0) }
A UGen which produces a linear lag (time smear) regarding and input signal.
A UGen which produces a linear lag (time smear) regarding and input signal.
Other than Lag which is a feedback filter with exponential decay, Ramp
applies a linear ramp. This is achieved by sampling the input signal at regular
intervals given by the lagTime and starting a new line segment after each
interval.
A scalar UGen that generates a single random decimal value, using a uniform
distribution from lo to hi .
A UGen that determines which random number generator is used for the enclosing synth.
A UGen that determines which random number generator is used for the enclosing synth. All synths that use the same generator reproduce the same sequence of numbers when the same seed is set again.
// button alternatingly resets left and right seed 0 to 1 map { i => play { RandID.ir(i) val x = Impulse.kr(4) val pch = TIRand.kr(40, 100, x) val b = MouseButton.kr(lag = 0) val tr = PulseDivider.kr(b, 2, i) pch.poll(x, if (i == 0) "left " else "right") RandSeed.kr(tr + Impulse.kr(0), 234) Out.ar(i, SinOsc.ar(pch.midicps) * 0.2) } }
A UGen that resets the seed of the synth's random number generator upon receiving a trigger.
A UGen that resets the seed of the synth's random number generator upon
receiving a trigger. All synths that use the same random number generator
reproduce the same sequence of numbers again. The generator can be set using the
RandID UGen.
// reset seed via mouse button play { val freq = TIRand.kr(40, 100, Impulse.kr(4)).midicps RandSeed.kr(MouseButton.kr(lag = 0) + Impulse.kr(0), 234) SinOsc.ar(freq) * 0.2 }
Records input into a Buffer.
Records input into a Buffer. If recLevel is 1.0 and preLevel is 0.0 then the new input overwrites the old data. If they are both 1.0 then the new data is added to the existing data. (Any other settings are also valid.)
// record and replay // a four second mono buffer val b = Buffer.alloc(s, s.sampleRate.toInt * 4) // record for four seconds play { val sig = Formant.ar(XLine.kr(400, 1000, 4), 2000, 800) * 0.125 RecordBuf.ar(sig, b.id, doneAction = freeSelf, loop = 0) } // play it back play { PlayBuf.ar(1, b.id, doneAction = freeSelf, loop = 0) }
A UGen that replace the contents of a bus with an input signal.
A UGen that replace the contents of a bus with an input signal. Other than
Out , the signal is not added to the previous contents of the bus but replaces
it, allowing for a simple way of an "insert" effect.
Multi-channel input signals, for example a PanAz , are written as such to the
bus without expansion. That is, the bus index argument is used for the first
channel, the second channel will appear on bus + 1 , etc.
If you have an expanding multi-channel input, however, you have to be careful.
For example, if you have
PanAz.ar(2, SinOsc.ar(Seq(444, 555, 666)) * 0.2, Seq(-1, 0, 1)) , this results
in one output UGen carrying one channel, and another one carrying two channels.
(The way this works is consistent with SCLang). In order to get the correct
behaviour (left outputs of the PanAz summed, and right output of the PanAz
summed), wrap this expression in a Mix(...) before passing it to the output
UGen.
// insert-effect val noise = play { Out.ar(0, WhiteNoise.ar(Seq(0.1, 0.1))) } val filter = play(target = noise, addAction = addAfter) { val in = In.ar(0, 2) val f = Resonz.ar(in, 444, 0.1) * 20 ReplaceOut.ar(0, f) } filter.run(false) // bypass filter.run(true ) // engage
A two pole resonant filter UGen.
A two pole resonant filter UGen. It has zeroes at z = +1 and z = -1.
Based on K. Steiglitz, "A Note on Constant-Gain Digital Resonators", Computer Music Journal, vol 18, no. 4, pp. 8-10, Winter 1994.
// modulated frequency play { val in = Saw.ar(200) * 0.5 val freq = SinOsc.ar(XLine.ar(0.3, 100, 20)).madd(3600, 4000) Resonz.ar(in, freq) }
// mouse controlled frequency and Q play { val in = WhiteNoise.ar(0.5) val freq = MouseX.kr(200, 10000, 1) val q = MouseY.kr(1, 100, 1) // bottom to top val flt = Resonz.ar(in, freq, q.reciprocal) flt * q.sqrt // compensate for energy loss }
A resonant or "ringing" filter UGen.
A resonant or "ringing" filter UGen. This is the same as Resonz , except that
instead of a Q parameter, the bandwidth is specified as a 60 dB ring decay time.
One Ringz is equivalent to one component of the Klank UGen.
// module ring time play { Ringz.ar(Impulse.ar(6) * 0.3, 2000, XLine.kr(4, 0.04, 8)) }
// modulated frequency play { val in = Saw.ar(200) * 0.02 val freq = SinOsc.ar(XLine.ar(0.3, 100, 20)).madd(2800, 4800) Ringz.ar(in, freq) }
// multiple glissandi excited by noise play { val ex = WhiteNoise.ar(0.001) Mix.fill(10) { Ringz.ar(ex, XLine.kr(ExpRand(100, 5000), ExpRand(100, 5000), 20), 0.5) } }
A UGen that can be used for rotating an ambisonic B-format sound field around an axis.
A UGen that can be used for rotating an ambisonic B-format sound field around
an axis. It uses an equal-power rotation so it also works well on stereo sounds.
It takes two audio inputs ( x , y ) and an angle control ( pos ). It
outputs again two channels, using these formulas:
xr = cos(angle) * x + sin(angle) * y yr = cos(angle) * y - sin(angle) * x
where angle = pos * Pi . This allows, for example, the use of LFSaw to
create a continuous rotation around a circle.
Note: Be careful when accessing the output channels. xr and yr are
the X and Y output channels, whereas x and y refers to the X and Y input
channel.
// 4-channel rotation of opposite sounds play { val p = WhiteNoise.ar(0.05) // first source val q = Mix(LFSaw.ar(Seq(200, 200.37))) * 0.03 // second source // B-format encode 2 signals at opposite sides of the circle val enc = PanB2.ar(p, -0.5) + PanB2.ar(q, +0.5) val Seq(w, x, y) = (0 to 2).map(enc \ _) val rot = Rotate2.ar(x, y, MouseX.kr(-1, +1)) // B-format decode to quad (front-left, front-right, rear-left, rear-right) DecodeB2.ar(4, w, rot.xr, rot.yr) }
A UGen to measure a signal's maximum value between triggers.
A UGen to measure a signal's maximum value between triggers.
The UGen keeps an internal state that reflects the maximum input value observed. When a trigger occurs at the reset input, it first copies the current maximum value to its output and then (quasi-simultaneously) resets its internal state to the current input value.
// illustrate timing play { val n = BrownNoise.ar val t = Impulse.ar(4) val r = RunningMax.ar(n, t) // value at the moment the reset // is triggered n.poll(t, "cur") // this is the maximum of the // recent two input samples // (the one during reset and // the current one), therefore // equal or slightly greater than // the 'cur' value r.poll(Delay1.ar(t), "max") () }
A UGen to measure a signal's minimum value between triggers.
A UGen to measure a signal's minimum value between triggers.
The UGen keeps an internal state that reflects the minimum input value observed. When a trigger occurs at the reset input, it first copies the current minimum value to its output and then (quasi-simultaneously) resets its internal state to the current input value.
// illustrate timing play { val n = BrownNoise.ar val t = Impulse.ar(4) val r = RunningMin.ar(n, t) // value at the moment the reset // is triggered n.poll(t, "cur") // this is the minimum of the // recent two input samples // (the one during reset and // the current one), therefore // equal or slightly less than // the 'cur' value r.poll(Delay1.ar(t), "min") () }
A UGen calculating the running sum of an input signal over a given number of samples.
A UGen calculating the running sum of an input signal over a given number of samples.
// poll waveform's DC offset play { val freq = 441 val n = SampleRate.ir / freq // mean over period of a pulse with 50% duty is 0.5 val mean = RunningSum.ar(LFPulse.ar(freq), n) / n mean.roundTo(0.01).poll(label = "mean") () }
A second order filter section (biquad) UGen.
A second order filter section (biquad) UGen. Filter coefficients are given directly rather than calculated for you. The formula is equivalent to:
out(i) = a0 * in(i) + a1 * in(i-1) + a2 * in(i-2) + b1 * out(i-1) + b2 * out(i-2)
// same as TwoPole play { val theta = MouseX.kr(0.2*math.Pi, 0.9*math.Pi) val rho = MouseY.kr(0.6, 0.98) val b1 = 2.0 * rho * theta.cos val b2 = -(rho.squared) SOS.ar(WhiteNoise.ar(Seq(0.05, 0.05)), 1.0, 0.0, 0.0, b1, b2) }
// used as control signal play { val theta = MouseX.kr(0.2*math.Pi, math.Pi) val rho = MouseY.kr(0.6, 0.99) val b1 = 2.0 * rho * theta.cos val b2 = -(rho.squared) val vib = SOS.kr(LFSaw.kr(3.16), 1.0, 0.0, 0.0, b1, b2) SinOsc.ar(vib * 200 + 600) * 0.2 }
A UGen that reports the server's current (audio) sample period in seconds.
A UGen that reports the server's current (audio) sample period in seconds. This
is equivalent to the reciprocal of SampleRate
// print the sample period play { SampleDur.ir.poll(0) }
A UGen that reports the server's current (audio) sample rate.
A UGen that reports the server's current (audio) sample rate. This is
equivalent to the reciprocal of SampleDur
// print the sample rate play { SampleRate.ir.poll(0) }
// use a fraction as oscillator frequency play { val div = MouseX.kr(512, 2, 1, 0).roundTo(1) val change = HPZ1.kr(div).abs val freq = SampleRate.ir / div freq.poll(change, label = "freq") SinOsc.ar(freq) * 0.1 }
A band-limited sawtooth wave generator UGen.
A band-limited sawtooth wave generator UGen.
// modulate frequency play { Saw.ar(XLine.kr(40, 4000, 6)) * 0.2 }
// two saws with different frequencies through resonant filter play { RLPF.ar(Saw.ar(Seq(100, 250)) * 0.2, XLine.kr(8000, 400, 6), 0.05) }
A Schmidt trigger UGen.
A Schmidt trigger UGen. Initially it outputs zero. When the input signal rises
above hi , its output switches to 1.0, which is hold until the signal falls
below lo , switching the output again to 0.0. The produces a kind of
hysteresis behavior, preventing heavy oscillations in a noisy system which might
occur with a single-threshold trigger.
A UGen which selects among a sequence of inputs, according to an index signal.
A UGen which selects among a sequence of inputs, according to an index signal.
Note that, although only one signal of the multi input is let through at a
time, still all ugens are continuously running.
A UGen which sends an sequence of values from the server to all notified clients upon receiving triggers.
A UGen which sends an sequence of values from the server to all notified
clients upon receiving triggers. The message sent is
osc.Message(<(String) msgName>, <(Int) nodeID>, <(Int) replyID>, <(Float) values>*)
.
For sending a single value, SendTrig provides an alternative.
The argument order is different from its sclang counterpart.
A UGen that sends a value from the server to all notified clients upon receiving triggers.
A UGen that sends a value from the server to all notified clients upon
receiving triggers. The message sent is
osc.Message("/tr", <(Int) nodeID>, <(Int) trigID>, <(Float) value>) .
For sending an array of values, or using an arbitrary reply command, see
SendReply .
The argument order is different from its sclang counterpart.
A scalar (init-time) UGen that overwrites contents of a buffer with given values.
A flip-flop UGen with two inputs, one (set) triggering an output of 1.0, the other (reset) triggering an output of 0.0.
A flip-flop UGen with two inputs, one (set) triggering an output of 1.0, the other (reset) triggering an output of 0.0. Subsequent triggers happening within the same input slot have no effect. If both inputs receive a trigger at the same time, the reset input takes precedence.
// mouse-button toggle play { // make sure lag is zero, otherwise the output // never falls back exactly to zero! val set = MouseButton.kr(lag = 0) val reset = Impulse.kr(1) val ff = SetResetFF.kr(set, reset) SinOsc.ar(ff.madd(400, 800)) * 0.1 }
// limit trigger rate play { // with a combination of TDelay and SetResetFF // we can build a filter that lets triggers // pass at a maximum rate. val dur = 1.0 // minimum spacing between triggers val in = Dust.ar(10) // high frequency trigger val lim = SetResetFF.ar(in, TDelay.ar(in, dur)) val time = Timer.ar(lim) time.poll(lim, "bang") () }
A waveshaping UGen.
A waveshaping UGen. Waveshaping is a the process of translating an input signal by indexing a table (buffer).
Advanced notes: wavetable format:
Signal: [a0, a1, a2...] Wavetable: [2*a0-a1, a1-a0, 2*a1-a2, a2-a1, 2*a2-a3, a3-a2...]
This strange format is not a standard linear interpolation (integer + frac), but for (integer part -1) and (1+frac)) due to some efficient maths for integer to float conversion in the underlying C code.
A sinusoidal (sine tone) oscillator UGen.
A sinusoidal (sine tone) oscillator UGen. This is the same as Osc except that
it uses a built-in interpolating sine table of 8192 entries.
Note that currently (SC 3.7.x), the first frame generated is not zero
(i.e. the value of the sine oscillation at time zero) but the value at time
1 / SampleRate.ir .
A slew rate limiter UGen.
A slew rate limiter UGen. Limits the slope of an input signal. The slope is expressed in units per second.
Since the UGen is initialized with the initial value of the input signal, some tricks must be applied to set it to an alternative start value. For example:
val in = Select.kr(ToggleFF.kr(1), Seq("start".ir, "target".kr)) Slew.kr(in) // begins at "start" and moves towards "target"
A UGen measuring the slope of signal.
A UGen measuring the slope of signal. It calculates the rate of change per second of a signal, as given by the following formula:
out(i) = (in(i) - in(i-1)) * sampleRate It thus equal to HPZ1.ar(_) * 2 * SampleRate.ir
A UGen to measure the spectral centroid.
A UGen to measure the spectral centroid. Given an FFT chain, this measures the spectral centroid, which is the weighted mean frequency, or the "centre of mass" of the spectrum. (DC is ignored.) This can be a useful indicator of the perceptual brightness of a signal.
Note that the output frequency is pretty close to the correct value when
feeding in a sine signal, but the estimate is usually too high when using for
example filtered noise. In that case, you will get better results using
SpecPcile at 50%.
Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.
A UGen to measure spectral flatness.
A UGen to measure spectral flatness. Given an FFT chain this calculates the Spectral Flatness measure, defined as a power spectrum's geometric mean divided by its arithmetic mean. This gives a measure which ranges from approx 0 for a pure sinusoid, to approx 1 for white noise.
The measure is calculated linearly. For some applications you may wish to
convert the value to a decibel scale. Note that this UGen may output NaN
when the input is zero (probably due to division by zero). In that case,
CheckBadValues can be used to prevent further problems.
Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.
A UGen to find the percentile of a signal's magnitude spectrum.
A UGen to find the percentile of a signal's magnitude spectrum. Given an FFT
chain this calculates the cumulative distribution of the frequency spectrum, and
outputs the frequency value which corresponds to the desired percentile. For
example, to find the frequency at which 90% of the spectral energy lies below
that frequency, you want the 90-percentile, which means the value of percent
should be 0.9. The 90-percentile or 95-percentile is often used as a measure of
spectral roll-off.
Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.
A graph element that spreads a sequence of input channels across a ring of output channels.
A graph element that spreads a sequence of input channels across a ring of output channels.
This works by feeding each input channel through a dedicated PanAz UGen, and mixing the
results together.
The panning position of each input channel with index ch is calculated by the formula:
val pf = 2.0 / (number-of-input-channels - 1) * (number-of-output-channels - 1) / number-of-output-channels ch * pf + center
A linear-interpolating sound generator based on the difference equations:
A linear-interpolating sound generator based on the difference equations:
x[n+1] = (x[n] + y[n+1]) % 2pi y[n+1] = (y[n] + k * sin(x[n])) % 2pi
The standard map is an area preserving map of a cylinder discovered by the plasma physicist Boris Chirikov.
// vary frequency play { StandardL.ar(MouseX.kr(20, SampleRate.ir)) * 0.3 }
// mouse-controlled parameter play { StandardL.ar(SampleRate.ir/2, MouseX.kr(0.9, 4)) * 0.3 }
// as a frequency control play { SinOsc.ar(StandardL.ar(40, MouseX.kr(0.9, 4)) * 800 + 900) * 0.4 }
A non-interpolating sound generator based on the difference equations:
A non-interpolating sound generator based on the difference equations:
x[n+1] = (x[n] + y[n+1]) % 2pi y[n+1] = (y[n] + k * sin(x[n])) % 2pi
The standard map is an area preserving map of a cylinder discovered by the plasma physicist Boris Chirikov.
// vary frequency play { StandardN.ar(MouseX.kr(20, SampleRate.ir)) * 0.3 }
// mouse-controlled parameter play { StandardN.ar(SampleRate.ir/2, MouseX.kr(0.9, 4)) * 0.3 }
// as a frequency control play { SinOsc.ar(StandardN.ar(40, MouseX.kr(0.9, 4)) * 800 + 900) * 0.4 }
A pulse counting UGen.
A pulse counting UGen. Each trigger increments a counter which is output as a
signal. The counter wraps inside the interval from lo to hi (inclusive).
That if you use a lo other than zero, you might want to adjust resetVal as
well. Stepper always starts with the value in resetVal , no matter what lo
is or whether the reset trigger is high or not.
// arpeggio play { val tr = Impulse.ar(10) val step = Stepper.ar(tr, lo = 4, hi = 16) val freq = step * 100 SinOsc.ar(freq) * AmpComp.ar(freq) * 0.1 }
A frequency domain stereo convolution UGen, capable of performing linear cross-fades between kernel updates.
A frequency domain stereo convolution UGen, capable of performing linear
cross-fades between kernel updates. When receiving a trigger, there is a linear
cross-fade between the old kernel the new buffer contents. It operates similar
to Convolution2L , however uses two buffers and outputs a stereo signal,
resulting in better CPU usage than two discrete instances of Convolution2L as
this way one FFT transformation per period is saved.
Warning: This UGen seems currently broken (SC 3.6.3)
A UGen that reports the fractional sample offset of the current Synth from its requested scheduled start.
A UGen that reports the fractional sample offset of the current Synth from its requested scheduled start.
When a synth is created from a time stamped osc-bundle, it starts calculation
at the next possible block (normally 64 samples). Using an OffsetOut UGen, one
can delay the audio so that it matches sample accurately.
For some synthesis methods, one even needs subsample accuracy.
SubsampleOffset provides the information where, within the current sample, the
synth was scheduled. It can be used to offset envelopes or resample the audio
output.
A UGen which starts a linear raise from zero each time it is triggered.
A sawtooth oscillator UGen that is hard sync'ed to a fundamental pitch.
A sawtooth oscillator UGen that is hard sync'ed to a fundamental pitch. That
is, a sawtooth waveform is produced at one frequency, sawFreq , whereas a
trigger at a another frequency, syncFreq , resets the phase of the sawtooth to
zero.
This produces an effect similar to moving formants or pulse width modulation. This is not a band limited waveform, so it may alias.
// modulate saw frequency play { SyncSaw.ar(100, Line.kr(100, 800, 12)) * 0.2 }
A UGen that converts a control-rate trigger input into an audio-rate trigger output.
A UGen that converts a control-rate trigger input into an audio-rate trigger output. A trigger occurs when a signal changes from less than or equal to zero to greater than zero. The output will have a single sample spike of the input trigger's amplitude at the beginning of the calculation block.
// up-sample control-rate impulses play { val trig = Impulse.kr(MouseX.kr(1, 100, 1)) Ringz.ar(T2A.ar(trig), 800, 0.01) * 0.4 }
A UGen that converts an audio-rate trigger input into a control-rate trigger output.
A UGen that converts an audio-rate trigger input into a control-rate trigger output. A trigger occurs when a signal changes from less than or equal to zero to greater than zero. The UGen behaves strangely in that for a rising slope input signal, it will report the maximum value seen within the calculation block, but if the slope extends to the next block, it will output that second's block maximum value again instead of waiting for a fall to <= 0.
// down-sample audio-rate dust play { val trig = T2K.kr(Dust.ar(4)) Trig.kr(trig, 0.1) * SinOsc.ar(800) * 0.1 }
A delay UGen for trigger signals.
A delay UGen for trigger signals. Other than a normal buffer delay, any new trigger arriving in the time between the previous trigger and the passing of the delay time is ignored.
A UGen which polls results from demand-rate ugens in intervals specified by a duration input, and outputs them as trigger values.
A UGen which polls results from demand-rate ugens in intervals specified by a
duration input, and outputs them as trigger values. A value from the level
ugen is demanded and output for one sample (when running at audio-rate) or one
block (when running at control-rate) according to a stream of duration values.
When there is a trigger at the reset input, the level and the dur input are
reset.
The argument order is different from its sclang counterpart.
A UGen that generates a new random decimal value each time it is triggered,
using an exponential distribution from lo to hi .
A UGen that generates a new random decimal value each time it is triggered,
using an exponential distribution from lo to hi . Values lo and hi must
both have the same sign and be non-zero.
Note: Audio-rate inputs for lo and hi are currently broken in
SuperCollider, and will therefore be converted to control-rate inputs.
// random sine frequencies, triggered by mouse button play { val tr = MouseButton.kr(lag = 0) val m = Mix.fill(10)(SinOsc.ar(TExpRand.kr(200.0, 800.0, tr))) m * Linen.kr(tr, sustain = 0.025, release = 2) }
Triggers generate grains from a buffer.
Triggers generate grains from a buffer. Each grain has a Hanning envelope
(sin2(x) for x from 0 to pi)
and is panned between two channels of multiple outputs.
Warning: Due to a bug (SC 3.6.6), this UGen does not work with LocalBuf
but requires a regular buffer.
A UGen that outputs integer random numbers when triggered.
A UGen that outputs integer random numbers when triggered. The values have a
uniform distribution from lo to hi (inclusive).
Note: Audio-rate inputs for lo and hi are currently broken in
SuperCollider, and will therefore be converted to control-rate inputs.
// random sine frequencies, triggered by mouse button play { val tr = MouseButton.kr(lag = 0) val m = Mix.fill(10)(SinOsc.ar(TIRand.kr(40, 100, tr).midicps)) m * Linen.kr(tr, sustain = 0.025, release = 2) }
A UGen that generates a new random decimal value each time it is triggered,
using a uniform distribution from lo to hi .
A UGen that generates a new random decimal value each time it is triggered,
using a uniform distribution from lo to hi .
Note: Audio-rate inputs for lo and hi are currently broken in
SuperCollider, and will therefore be converted to control-rate inputs.
// random sine frequencies, triggered by mouse button play { val tr = MouseButton.kr(lag = 0) val m = Mix.fill(10)(SinOsc.ar(TRand.kr(200.0, 800.0, tr))) m * Linen.kr(tr, sustain = 0.025, release = 2) }
A UGen providing a probability-weighted index into a sequence upon receiving a trigger.
A UGen providing a probability-weighted index into a sequence upon receiving a trigger.
When triggered, returns a random index value based the values of the channels
of the prob argument functioning as probabilities. The index is zero based,
hence goes from 0 to prob.numOutputs - 1 .
By default the sequence of probabilities should sum to 1.0, however for
convenience, this can be achieved by the ugen when the normalize flag is set
to 1 (less efficient).
A UGen that returns time since last triggered.
A UGen that returns time since last triggered. The time returned is in seconds
and is measured from the last received trigger. Note that currently it seems the
initial memory is at -1 sample, so for Impulse.ar(1) the result (at 44.1 kHz)
is 2.26757e-05, followed strangely by 1.00002, and then (as expected) 1.0.
A UGen that toggles like a flip-flop between zero and one upon receiving a trigger.
A UGen that toggles like a flip-flop between zero and one upon receiving a trigger. The flip-flop initially outputs zero and changes to one when the first trigger arrives.
// mouse-button toggle play { // make sure lag is zero, otherwise the output // never falls back exactly to zero! val tr = MouseButton.kr(lag = 0) val ff = ToggleFF.kr(tr) SinOsc.ar(ff.madd(400, 800)) * 0.1 }
A UGen which holds and outputs an input value for a given duration when triggered.
A UGen which holds and outputs an input value for a given duration when triggered.
When a trigger occurs at the input, the input value is sampled and output for the specified duration, otherwise zero is output. When a new trigger occurs while this ugens outputs 1, the hold-time is reset to the duration.
Warning: The hold-time is subject to a bug that depends on the input
signal. For example with Trig1.ar(Impulse.ar(0), 4 * SampleDur.ir) one
actually gets a high signal for five sample frames instead of four.
// hold dust spikes play { Trig.ar(Dust.ar(1), 0.2) * SinOsc.ar(800) * 0.2 }
A UGen which outputs a value of 1 for a given duration when triggered.
A UGen which outputs a value of 1 for a given duration when triggered.
When a trigger occurs at the input, a value of 1 is output for the specified duration, otherwise zero is output. When a new trigger occurs while this ugens outputs 1, the hold-time is reset to the duration.
Warning: The hold-time is subject to a bug that depends on the input
signal. For example with Trig1.ar(Impulse.ar(0), 4 * SampleDur.ir) one
actually gets a high signal for five sample frames instead of four.
// hold dust spikes play { Trig1.ar(Dust.ar(1), 0.2) * SinOsc.ar(800) * 0.2 }
A two pole filter UGen.
A two pole filter UGen. This provides lower level access to setting of pole
location. For general purposes Resonz is better.
// static frequency play { TwoPole.ar(WhiteNoise.ar(0.005), 2000, 0.95) }
// sweeping frequency play { TwoPole.ar(WhiteNoise.ar(0.005), XLine.kr(800, 8000, 8), 0.95) }
// mouse controlled frequency play { TwoPole.ar(WhiteNoise.ar(0.005), MouseX.kr(800, 8000, 1), 0.95) }
A two zero filter UGen.
Unary operations are generally constructed by calling one of the methods of GEOps.
Unary operations are generally constructed by calling one of the methods of GEOps.
GEOps @see BinaryOpUGen
A UGen for Vector Base Amplitude Panning (VBAP).
A UGen for Vector Base Amplitude Panning (VBAP). This allows for equal power panning of a source over an arbitrary array of equidistant speakers. Normally this would be a ring, a dome, or partial dome.
VBAP was created by Ville Pulkki. For more information on VBAP see http://www.acoustics.hut.fi/research/cat/vbap/ This version of VBAP for SC was ported from the ver. 0.99 PD code by Scott Wilson.
// two-dimensional val a = VBAPSetup(2, Seq(0, 45, 90, 135, 180, -135, -90, -45)) // 8 channel ring val b = Buffer.alloc(s, a.bufferData.size) b.setn(a.bufferData) val x = play { val azi = "azi".kr(0) val ele = "ele".kr(0) val spr = "spr".kr(0) VBAP.ar(8, PinkNoise.ar(0.2), b.id, azi, ele, spr) } // test them out x.set("azi" -> a.directions(1).azi) x.set("azi" -> a.directions(2).azi) x.set("azi" -> a.directions(3).azi) // ... x.set("azi" -> a.directions(7).azi) x.set("azi" -> a.directions(0).azi) // try the spread x.set("spr" -> 20) x.set("spr" -> 100) // all speakers x.free(); b.free();
A UGen to stream in a signal from an audio file with variable playback speed.
A UGen to stream in a signal from an audio file with variable playback speed. Continuously plays a longer audio file from disk. This requires a buffer to be preloaded with one buffer size of sound. If loop is set to 1, the file will loop.
Note: The buffer size must be a multiple of (2 * the server's block
size). See Buffer#cue for details.
If the speed is too high, the UGen will not execute, posting a warning.
A sawtooth-triangle oscillator UGen with variable duty.
A sawtooth-triangle oscillator UGen with variable duty. A width of zero
produces a sawtooth of falling slope, with an initial phase of zero making it
start at +1. A width of 0.5 produces a triangle wave, starting at -1 then
raising to +1, then falling again to -1. A width of 1.0 produces a sawtooth of
rising slope, starting -1.
Increasing the initial wave will increase the offset into the waveform. For example, with a phase of 0.5 and a width of 0.5, the result is a triangle waveform that starts at +1.
There is a strange anomaly for the falling sawtooth (zero width): Instead of starting directly at +1, the first sample is -1 and only from the second sample at +1 the waveform starts falling. In other words, the waveform has a delay of one sample.
// width modulation play { val freq = LFPulse.kr(3, 0, 0.3).madd(200, 200) val width = LFTri.kr(1.0).madd(0.5, 0.5) VarSaw.ar(freq, 0, width) * 0.2 }
A low frequency oscillator UGen for modelling vibrato.
A low frequency oscillator UGen for modelling vibrato. It produces a modulating frequency value in Hertz that can be used as the frequency parameter of another UGen.
By setting more extreme settings, one can get back to the timbres of FM synthesis. One can also add in some noise to the vibrato rate and vibrato size (modulation depth) to make for a more realistic motor pattern.
The vibrato output is a waveform based on a squared envelope shape with four stages marking out 0.0 to 1.0, 1.0 to 0.0, 0.0 to -1.0, and -1.0 back to 0.0. The vibrato rate determines how quickly one moves through these stages.
// constant setting play { SinOsc.ar(Vibrato.ar(DC.ar(400.0), 1, 0.02)) * 0.2 }
// beat and beatVar mouse control play { val beat = MouseX.kr(2.0, 100.0) val beatVar = MouseY.kr(0.0, 1.0) val freq = Vibrato.ar(DC.ar(400.0), beat, 0.1, 1.0, 1.0, beatVar, 0.1) SinOsc.ar(freq) * 0.2 }
A noise generator UGens whose spectrum has equal power at all frequencies.
A UGen that constrains a signal to a given range, by "wrapping" values outside the range.
A UGen that constrains a signal to a given range, by "wrapping" values outside
the range. This is similar to the wrap2 binary operator but permits both a
lower range value lo and an upper range value hi .
An input value greater than or equal to hi will be wrapped back to
(in - hi) % (hi - lo) + lo . An input value less than lo will be wrapped
back to hi - (lo - in) % (hi - lo) .
// wrap pulse wave to modulate timbre play { val hi = SinOsc.ar(0.1).linexp(-1, 1, 0.01, 1.0) Wrap.ar(Pulse.ar(300), 0, hi) * 0.2 / hi }
A UGen which reads a single sample value from a buffer at a given index.
A UGen which reads a single sample value from a buffer at a given index.
It uses the in argument as index into the buffer, truncating that argument to
an integer. Out-of-range index values are wrapped around the valid range. For
example, if the buffer has four samples, index 4 is wrapped to index 0, index 5
is wrapped to index 1, index -1 is wrapped to index 3, index -2 is wrapped to
index 2, etc.
While designed for monophonic buffers, it works with multi-channel buffers by
treating them as de-interleaved. See the Index UGen for details.
An element which writes an input signal to a bus, optionally applying a short fade-in.
An element which writes an input signal to a bus, optionally applying a short fade-in.
This is automatically added when using the play { ... } syntax. If the fade time is
given, an envelope is added with a control named "gate" which can be used to release
the synth. The bus is given by a control named "out" and defaults to zero.
An equal power two channel cross fading UGen.
An exponential curve generator UGen that moves from a start value to the end value in a given duration.
An exponential curve generator UGen that moves from a start value to the end value in a given duration.
At a given point in time 0 <= t <= dur , the output value is
start * (stop/start).pow(t/dur) .
Warning: It must be ensured that the both start is not zero and start
and end have the same sign (e.g. a start of -1 and an end of -0.001 are
valid), otherwise the UGen will output a NaN ! While in the case of end
being zero the UGen will also output zero, it is recommended to treat this case
as pathological as well.
// glissando play { SinOsc.ar(Line.kr(200, 2000, 10, freeSelf)) * 0.2 }
A UGen that cross-fades the contents of a bus with an input signal.
A UGen that cross-fades the contents of a bus with an input signal. A linear cross-fade can go from 0.0 (previous bus contents preserved, no input signal added) via 0.5 (previous signal attenuated by -6 dB, input signal attenuated by -6 dB and added) to 1.0 (contents completely replaced by input signal).
// cross-fade two synths val sin = play { Out.ar(0, SinOsc.ar(440) * 0.1) } val noise = play(target = sin, addAction = addAfter) { XOut.ar(0, PinkNoise.ar(0.1), xfade = "xfade".kr(0)) } noise.set("xfade" -> 0.5) // both signals heard noise.set("xfade" -> 1.0) // just noise noise.set("xfade" -> 0.0) // just sine
A pitch estimation UGen based on counting the zero-crossings of the input signal.
A pitch estimation UGen based on counting the zero-crossings of the input signal. This is a very crude pitch follower, but can be useful in some situations.
// reconstruct sine frequency play { val f1 = SinOsc.kr(0.2).madd(600, 700).roundTo(100) val a = SinOsc.ar(f1) * 0.1 val f2 = ZeroCrossing.ar(a) f2.poll(10, "estimation") val b = SinOsc.ar(f2) * 0.1 Seq(a, b) }
A converter UGen that takes an audio-rate input and produces a control-rate output by means of sampling. The sample is always taken at the beginning of each control-block, while all other samples of the audio-rate input within that block are ignored.
audio-rate signal to convert
T2K
K2A