de.sciss.synth.ugen

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.

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.

All pass delay line with cubic interpolation.

All pass delay line with cubic interpolation.

All pass delay line with linear interpolation.

All pass delay line with linear interpolation.

All pass delay line with no interpolation.

All pass delay line with no interpolation.

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.

===Examples===

// activate with mouse button
play {
 val freq = MouseX.kr(300, 15000, 1)
 val mod  = freq * SinOsc.ar(MouseY.kr(3, 200, 1)).mulAdd(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.

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.

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.

===Examples===

// activate with mouse button
play {
 val freq = MouseX.kr(300, 15000, 1)
 val mod  = freq * SinOsc.ar(MouseY.kr(3, 200, 1)).mulAdd(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
}

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.

An amplitude follower UGen. Tracks and reports the peak amplitude of its input signal.

===Examples===

// 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
}

An amplitude follower UGen. Tracks and reports the peak amplitude of its input signal.

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 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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.

===Examples===

// modulated frequency
play {
 val in   = Saw.ar(200) * 0.5
 val freq = SinOsc.ar(XLine.ar(0.3, 100, 20)).mulAdd(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 second order 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.

===Examples===

// engage with mouse button
play {
 val sig = WhiteNoise.ar(0.5)
 val flt = BPZ2.ar(sig)
 LinXFade2.ar(sig, flt, MouseButton.kr(-1, 1))
}

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.

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.

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.

===Examples===

// modulated frequency
play {
 val in   = Saw.ar(200) * 0.5
 val freq = SinOsc.ar(XLine.ar(0.3, 100, 20)).mulAdd(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 second order band reject (notch) 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.

===Examples===

// engage with mouse button
play {
 val sig = WhiteNoise.ar(0.5)
 val flt = BRZ2.ar(sig)
 LinXFade2.ar(sig, flt, MouseButton.kr(-1, 1))
}

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.

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.

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.

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.

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. 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 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. 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)

===Examples===

// 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)
}

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)

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.

===Examples===

// 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 }

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.

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).

===Examples===

// plain noise
play { BrownNoise.ar(Seq(0.2, 0.2)) }

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).

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.

===Examples===

// 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 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.

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.

===Examples===

// 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.

'''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.

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.

===Examples===

// 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()

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.

Returns the current number of channels of the buffer at the provided index.

===Examples===

// channels of local buffer
play {
 val buf = LocalBuf(1024, 2)
 BufChannels.ir(buf).poll(0) // reports 2
}

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.

===Examples===

// 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 cubic interpolation which uses a buffer for its internal memory.

Comb delay line with linear interpolation which uses a buffer for its internal memory.

===Examples===

// 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 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.

===Examples===

// 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

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.

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 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.

'''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.

'''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.

'''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.

===Examples===

// 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

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.

Returns the current duration of the buffer at the provided index.

===Examples===

// duration of local buffer
play {
 val buf = LocalBuf(SampleRate.ir * 1.5, 2)
 BufDur.ir(buf).poll(0) // reports 1.5
}

Returns the current duration of the buffer at the provided index.

Returns the number of allocated frames of the buffer at the provided index.

===Examples===

// frames of local buffer
play {
 val buf = LocalBuf(1024, 2)
 BufFrames.ir(buf).poll(0) // reports 1024
}

Returns the number of allocated frames of the buffer at the provided index.

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

===Examples===

// rate scale of local buffer
play {
 val buf = LocalBuf(1024)
 BufRateScale.ir(buf).poll(0) // reports 1.0 because buffer rate matches server rate
}

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.

Warning: if the supplied buf 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.

===Examples===

// 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).mulAdd(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)

A UGen which reads the content of a buffer, using an index pointer.

Warning: if the supplied buf 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.

Returns the buffer's current sample rate.

===Examples===

// rate of local buffer
play {
 val buf = LocalBuf(1024)
 BufSampleRate.ir(buf).poll(0) // matches server sample rate
}

Returns the buffer's current sample rate.

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

===Examples===

// samples of local buffer
play {
 val buf = LocalBuf(1024, 2)
 BufSamples.ir(buf).poll(0) // 2 * 1024 = 2048
}

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.

Warning: if the supplied buf 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.

===Examples===

// 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).mulAdd(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)

A UGen that writes a signal to a buffer, using an index pointer.

Warning: if the supplied buf 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.

A graph element that produces an integer sequence from zero until the number-of-channels of the input element.

===Examples===

// cross-faded select
play {
 val sines: GE = Seq.fill(4)(SinOsc.ar(ExpRand(200, 2000)))
 val index   = MouseX.kr(lo = 0, hi = NumChannels(sines) - 1)
 val indices = ChannelIndices(sines)
 indices.poll(0, "indices")
 val select  = 1 - (indices absdif index).min(1)
 val sig     = Mix(sines * select)
 sig * 0.2
}

A helper graph element that selects a particular range of output channel of another element. The range is specified with integers and thus cannot be determined at graph expansion time. If this is desired, the Select UGen can be used.

Usually the graph element operator out along with a standard Scala Range argument can be used instead of explicitly writing ChannelRangeProxy. Thus elem out (0 until 4) selects the first four channels and is equivalent to ChannelRangeProxy(elem, from = 0, until = 4, step = 1).

Behind the scene, ChannelProxy instances are created, thus ChannelRangeProxy(x, a, b) is the same as (a until b).map(ChannelProxy(x, _)): GE.

Because ScalaCollider allows late-expanding graph elements, we have no direct way to get some array of a UGen's outputs.

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.

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.

A scalar (init-time) UGen that fills the contents of a buffer with zeroes.

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. 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") () } }}

===Examples===

// 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 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") () } }}

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.

===Examples===

// plain noise
play { ClipNoise.ar(Seq(0.2, 0.2)) }

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.

A UGen that randomly filters an input trigger signal. When a trigger arrives, it may pass with a probability given by the prob argument.

===Examples===

// filter dust, probability controlled by mouse
play {
 val p = MouseX.kr
 CoinGate.ar(Dust.ar(400), p)
}

A UGen that randomly filters an input trigger signal. When a trigger arrives, it may pass with a probability given by the prob argument.

Comb delay line with cubic interpolation.

Comb delay line with cubic interpolation.

Comb delay line with linear interpolation.

Comb delay line with linear interpolation.

Comb delay line with no interpolation.

Comb delay line with no interpolation.

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 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. This is equivalent to the reciprocal of ControlRate

===Examples===

// print the control period
play { ControlDur.ir.poll(0) }

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. This is equivalent to the reciprocal of ControlDur

===Examples===

// 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 reports the server's current control rate. This is equivalent to the reciprocal of ControlDur

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 .

===Examples===

// sine filter
play {
 val a = WhiteNoise.ar
 val b = SinOsc.ar(MouseY.kr(20, 2000, 1))
 Convolution.ar(a, b, 512) * 0.01
}

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 .

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.

===Examples===

// 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 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.

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.

===Examples===

// 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 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.

A UGen for triggered convolution in the time domain.

'''Warning: This UGen seems currently broken (SC 3.6.3)'''

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. Output values lie between zero and one. Although this is a deterministic process, it is randomly seeded.

===Examples===

// increasing parameter
play {
 val chaos = Line.kr(1.0, 2.01, 15)
 chaos.poll(2, "chaos")
 Crackle.ar(Seq(chaos, chaos)) * 0.5
}

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 linear-interpolating sound generator based on the difference equation:

x[n+1] = a - b * sqrt(abs(x[n]))

===Examples===

// 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 linear-interpolating sound generator based on the difference equation:

x[n+1] = a - b * sqrt(abs(x[n]))

A non-interpolating sound generator based on the difference equation:

x[n+1] = a - b * sqrt(abs(x[n]))

===Examples===

// 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 non-interpolating sound generator based on the difference equation:

x[n+1] = a - b * sqrt(abs(x[n]))

A UGen that creates a constant signal at a given calculation rate.

===Examples===

// 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 UGen that creates a constant signal at a given calculation rate.

A demand-rate UGen that produces random decimal numbers, analogous to a Brownian motion.

===Examples===

// random frequency
play {
 val in = Dbrown(lo = 0, hi = 15, step = 1)
 val tr = Impulse.kr(5)
 val v  = Demand.kr(tr, in)
 v.poll(tr)
 val f  = v * 30 + 300
 SinOsc.ar(f) * 0.1
}

A demand-rate UGen that produces random decimal numbers, analogous to a Brownian motion.

A demand-rate UGen that reads out a buffer. All inputs can be either demand UGens or any other UGens.

A demand-rate UGen that reads out a buffer. All inputs can be either demand UGens or any other UGens.

A demand-rate UGen that outputs values from the child demand stream until the sum of those values reaches or exceeds a given total. The last value will be truncated so that the sum of Dconst 's output values will match the total exactly.

A demand-rate UGen that outputs values from the child demand stream until the sum of those values reaches or exceeds a given total. The last value will be truncated so that the sum of Dconst 's output values will match the total exactly.

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.

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. 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 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. 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.

===Examples===

// 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 out _)
 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 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.

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.

===Examples===

// 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).mulAdd(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
}

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.

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.

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 .

===Examples===

// 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 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 .

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 .

===Examples===

// 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))
}

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 .

Simple delay line with cubic interpolation.

Simple delay line with cubic interpolation.

Simple delay line with linear interpolation.

Simple delay line with linear interpolation.

Simple delay line with no interpolation. The initial buffer contents is zero.

===Examples===

// 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
 }
}

Simple delay line with no interpolation. The initial buffer contents is zero.

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.

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. For each parameter of the envelope (levels, durations and shapes), values are polled every time a new segment starts.

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. 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 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 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 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 demand-rate UGen that produces a geometric series. Each value is calculated as

x[t] = x[t-1] * grow

With x[0] given as argument start.

===Examples===

// increasing frequency
play {
 val in = Dgeom(1, 1.2, 15)
 val tr = Impulse.kr(5)
 val v  = Demand.kr(tr, in)
 v.poll(tr)
 val f  = v * 30 + 300
 SinOsc.ar(f) * 0.1
}

A demand-rate UGen that produces a geometric series. Each value is calculated as

x[t] = x[t-1] * grow

With x[0] given as argument start.

A demand-rate UGen that produces random integer numbers, analogous to a Brownian motion, or the drunk object in Max.

'''Note''': The length parameter seems currently broken.

===Examples===

// random frequency
play {
 val in = Dibrown(lo = 0, hi = 15, step = 2)
 val tr = Impulse.kr(5)
 val v  = Demand.kr(tr, in)
 v.poll(tr)
 val f  = (v + 62).midiCps
 SinOsc.ar(f) * 0.1
}

A demand-rate UGen that produces random integer numbers, analogous to a Brownian motion, or the drunk object in Max.

'''Note''': The length parameter seems currently broken.