Buffer Granulation different approaches to buffer granulation with gui examples
Part of: miSCellaneous
See also: VarGui, VarGui shortcut builds, PLx suite
As with many things in SC work can be done by language or server. Speaking about granulation in general this mainly concerns the control of single grains, their rate, timing, length and other parameters. Regarding buffer granulation specifically this task can e.g. be taken over by ugens like TGrains and GrainBuf, the latter additionally accepting a grain envelope arg. The SC plugin distribution contains further variations (see BhobUGens, JoshUGens). By using granulation ugens in a SynthDef granular textures can be produced with a single Synth. Alternatively SynthDefs for single grains can be defined with PlayBuf or BufRd in order to control the whole buffer granulation process from language side, using Patterns, Tasks or Routines. What is the best way? To a large extent this is a question of personal preference. Regarding CPU performance granulation ugens have an advantage, whereas e.g. pattern-driven granulation allows concise control over the sequencing of granulation parameters in a clear syntax. If pattern-driven granulation is becoming CPU-critical you might want to consider the event type \grain, a lightweight variant of default type \note (see comment in the source file Event.sc). For granulation with Tasks see example 3 in VarGui.
Also hybrid strategies are possible, e.g. language controlled setting of a single granulation Synth or involving extra control synths in a language-driven granulation process, further options are Pspawner / Pspawn and Wavesets. VarGui can be used to integrate these setups in single GUIs. Together with this file (miSCellaneous v0.7) I reinvented a color grouping option that overrides automatic color grouping (VarGui, Ex. 7). The latter is based on the logical structure of ordinary and array controls, synths and environments. This is useful for VarGuis up to a medium number of controls per Synth / Pattern / Task and also for a large number of such items, but it doesn't handle cases well where there are many controls per item. Not barely an aestetic detail, it is much more convenient for experimenting to group all sliders of a Synth that, say, have to do with a bandpass filter, within one color.
Types of variables
In general interpreter variables are prefered in examples below, wherever possible. If evaluated with example code only their values are passed and further changing of used variables doesn't affect already generated gui instances. On the contrary repeated evaluation of an interpreter variable, e.g. from a Pfunc, is unsafe - variable's value could change while gui has not yet been closed - so in concerned examples values are passed to the event definition, in Ex. 2c a variable is declared for the same reason.
The use of environmental variables is following the way VarGui is handling them. Per default every EventStreamPlayer derived from a passed Pattern is run in a separate newly generated Environment, where variables are being set and Streams from Pfuncs and PLx patterns are reading from. See Event patterns and Functions, PLx suite and VarGui.
WARNING:
1.) Be careful with amplitudes, especially with buffers you haven't granulated before !
Also keep in mind that a granular cloud moving through a buffer can suddenly become louder and other controls than amp (e.g. buffer position, trigger rate, bandpass parameters) can cause a raise of amplitude too.
2.) I haven't used below setups for live performances. Although all of them work stable for me as they are, in general hangs can occasionally happen with pattern-driven setups. Often this can be tracked down to sequences of extremely short event durations (and/or long grain durations). Where this can happen as a side-effect, thresholds can be built in, e.g. example 2d (Wavesets) has a parameter maxTrigRate.
Another possible source of hangs is careless deep nesting of Patterns where mistakes can easily occur. Starting with clear Pattern structures is recommended - and if more complications are involved: testing without sound first, after saving your patch, might be a good idea.
NOTE:
All examples below expect mono buffers. Buffer paths refering to the included sample suppose that you have moved miSCellaneous lib into the user extensions directory directly (not into a subfolder), if not so or you have moved the sample file somewhere else you'd have to change paths accordingly, also in case of an install in system extensions, then use Platform.systemExtensionDir.
Windows 7: While other parts of miSCellaneous lib are running fine I was unable to allocate buffers with the SC 3.5.4 windows binary (August 2012). I don't know yet if this is a general issue, watch out for discussions on the mailing list and further SC releases.
Credits
Thanks for contributions and inspirations by SCers Alberto de Campo (Wavesets), James Harkins (Patterns), Ron Kuivila (Pspawner), Sergio Luque (stochastic distributions), Josh Parmenter (granulation plugins), Bhob Rainey (granulation plugins).
References
[1] de Campo, Alberto. "Microsound" In: Wilson, S., Cottle, D. and Collins, N. (eds). 2011.
The SuperCollider Book. Cambridge, MA: MIT Press, 463-504.
[2] Luque, Sergio (2006). Stochastic Synthesis, Origins and Extensions. Institute of Sonology, Royal Conservatory, The Netherlands.
[3] Roads, Curtis (2001). Microsound. Cambridge, MA: MIT Press.
[4] Wishart, Trevor (1994). Audible Design. York: Orpheus The Pantomime Ltd.
[5] Xenakis, Iannis (1992). Formalized Music. Hillsdale, NY: Pendragon Press, 2nd Revised edition.
1.) Granulation with Ugens
Example 1a: Basic buffer granulation Synth
(
s = Server.local;
Server.default = s;
s.boot;
)
// basic SynthDef suited for pitch-shift and time-stretch
// buffer position given relatively (posLo and posHi between 0 and 1)
// posDev: maximum amount of deviation from (moving) grain center position
// posDev = 0 can lead to comb filter effects (which may be nice sometimes)
// passing control specs as metadata allows for VarGui shortcut build method sVarGui
// metadata specs can be overwritten by arg ctrReplace
// alternatively control specs may be passed as synthCtr arg to a build with VarGui( ... )
(
SynthDef(\gran_1a, { arg out = 0, bufNum = 0, posLo = 0.0, posHi = 1.0,
posRate = 1, posDev = 0.01, trigRate = 100, granDur = 0.1, rate = 1.0,
panMax = 1, amp = 0.1, interp = 4;
var trig, pan, pos, bufDur, bufDurSection, posDif;
posDif = posHi - posLo;
bufDur = BufDur.kr(bufNum);
bufDurSection = bufDur * posDif;
trig = Impulse.kr(trigRate);
pos = posLo * bufDur +
(Phasor.ar(0, BufRateScale.kr(bufNum) * posRate / SampleRate.ir, posLo * bufDur, posHi * bufDur) +
(TRand.kr(-0.5 * posDev, 0.5 * posDev, trig) * bufDur)).mod(bufDurSection);
pan = Demand.kr(trig, 0, Dseq([panMax, panMax.neg],inf) * 0.999);
Out.ar(out, TGrains.ar(2, trig, bufNum, rate, pos, granDur, pan, amp, interp));
}, metadata: (
specs: (
posLo: [0.01, 0.99, \lin, 0.01, 0],
posHi: [0.01, 0.99, \lin, 0.01, 1],
posRate: [0.1, 2, \lin, 0.01, 1],
posDev: [0, 0.2, 5, 0, 0.01],
granDur: [0.01, 0.3, \lin, 0.01, 0.1],
trigRate: [1, 200, \lin, 0.01, 100],
rate: [0.1, 2, \lin, 0.01, 1],
panMax: [0.0, 1, \lin, 0.005, 0.8],
amp: [0.0, 0.5, \lin, 0.005, 0.25]
)
)
).add;
b = Buffer.read(s, Platform.userExtensionDir +/+ "miSCellaneous" +/+ "Sounds" +/+ "kitchen_sounds_1.wav");
// maybe you need to use Platform.systemExtensionDir instead
)
// start from GUI
\gran_1a.sVarGui([\bufNum, b.bufnum]).gui;
Example 1b: More deviations
// In example 1a only a deviation from the grain center position was implemented.
// With additional deviation controls a greater plasticity of sound can be achieved,
// here deviations are added for trigRate (LFO with oscillation freq and deviation max),
// grain duration and rate (TRand, equally weighted random deviation with given max).
// Deviations intervals could be defined alternatively,
// e.g. (1/(1+maxDev), 1+maxDev) with 0 < maxDev
// instead of (1-maxDev, 1+mexDev) with 0 < maxDev < 1
// posRate control range is widened by inventing two controls for
// mantissa and exponent, so posRate = 1 for init param pair
// posRateE = 0 and posRateM = 1
(
SynthDef(\gran_1b, { arg out = 0, bufNum = 0, posLo = 0.0, posHi = 1.0,
posRateE = 0, posRateM = 1, posDev = 0.01, trigRate = 100, trigRateDev = 0,
trigRateOsc = 1, granDur = 0.1, granDurDev = 0, rate = 1.0, rateDev = 0,
panMax = 1, amp = 0.1, interp = 4;
var trig, pan, pos, bufDur, bufDurSection, posDif, posRate;
posDif = posHi - posLo;
bufDur = BufDur.kr(bufNum);
bufDurSection = bufDur * posDif;
trig = Impulse.kr(LFDNoise3.kr(trigRateOsc, trigRate * trigRateDev, trigRate));
posRate = 10 ** posRateE * posRateM;
pos = posLo * bufDur +
(Phasor.ar(0, BufRateScale.kr(bufNum) * posRate / SampleRate.ir, posLo * bufDur, posHi * bufDur) +
(TRand.kr(-0.5, 0.5, trig) * posDev * bufDur)).mod(bufDurSection);
pan = Demand.kr(trig, 0, Dseq([panMax, panMax.neg],inf) * 0.999);
Out.ar(out, TGrains.ar(2, trig, bufNum, rate * (TRand.kr(-1, 1.0, trig) * rateDev + 1), pos,
granDur * (TRand.kr(-1, 1.0, trig) * granDurDev + 1), pan, amp, interp));
}, metadata: (
specs: (
posLo: [0.01, 0.99, \lin, 0.01, 0],
posHi: [0.01, 0.99, \lin, 0.01, 1],
posRateE: [-3, 4, \lin, 1, 0],
posRateM: [0.1, 10, \exp, 0.01, 1],
posDev: [0, 0.2, 5, 0, 0.05],
trigRate: [1, 200, \lin, 0.01, 100],
trigRateDev: [0.0, 1, \lin, 0.01, 0],
trigRateOsc: [0.1, 2, \lin, 0.01, 3],
granDur: [0.01, 0.3, \lin, 0.01, 0.1],
granDurDev: [0.0, 0.95, \lin, 0.01, 0],
rate: [0.1, 2, \lin, 0.01, 1],
rateDev: [0.0, 0.99, \linear, 0.01, 0.05],
panMax: [0.0, 1, \lin, 0.005, 0.8],
amp: [0.0, 0.5, \lin, 0.005, 0.25]
)
)
).add;
b = Buffer.read(s, Platform.userExtensionDir +/+ "miSCellaneous" +/+ "Sounds" +/+ "kitchen_sounds_1.wav");
// maybe you need to use Platform.systemExtensionDir instead
)
// start from GUI
// use color grouping for better overview
\gran_1b.sVarGui([\bufNum, b.bufnum]).gui(synthColorGroups: (0..14).clumps([1,5,3,2,2,1,1]) )
2.) Granulation driven by language
Example 2a: Basic buffer granulation Pbind
// Control parameters like in 1a, but implemented with a SynthDef for
// playing single grains and an appropriate Pbind,
// OffsetOut used for exact timing.
(
SynthDef(\gran_2a, { |out = 0, pos = 0, sndBuf = 0, windowBuf = 1, granDur = 0.1,
rate = 1, loop = 1, panMax = 0, amp = 1|
var window, src;
src = PlayBuf.ar(1, sndBuf, BufRateScale.kr(sndBuf) * rate,
1, round(pos * BufFrames.kr(sndBuf)), loop, 2);
window = BufRd.ar(1, windowBuf,
EnvGen.ar(Env([0, BufFrames.kr(windowBuf)], [granDur]),
doneAction: 2), loop, 4);
OffsetOut.ar(out, Pan2.ar(src, panMax, amp) * window);
}).add;
b = Buffer.read(s, Platform.userExtensionDir +/+ "miSCellaneous" +/+ "Sounds" +/+ "kitchen_sounds_1.wav");
// maybe you need to use Platform.systemExtensionDir instead
w = Buffer.sendCollection(s, Signal.hanningWindow(1024));
)
// Determining the correct buffer position depending on
// posRate, posLo and posHi needs a little calculation.
// In 1a this was done inside the ugen by a Phasor.
// See Ex. 3b, 3c for doing position movement with a separate Synth.
// PL placeholder patterns used, could also be Pfunc { ~ ... }
(
p = Pbind(
\instrument, \gran_2a,
\sndBuf, b,
\windowBuf, w,
\dur, 1 / PL(\trigRate),
\granDur, PL(\granDur),
\time, Ptime(),
\pos, Pfunc { |e|
var relTime = ~posRate * e.time / e.sndBuf.duration, relDif;
relDif = ~posHi - ~posLo;
relTime + rand2(~posDev) % relDif + ~posLo;
},
\rate, PL(\rate),
\amp, PL(\amp),
\panMax, PLseq([-1,1]) * PL(\panMax),
\out, 0
);
VarGui([
\posLo, [0.0, 0.99, \lin, 0.01, 0],
\posHi, [0.0, 0.99, \lin, 0.01, 1],
\posRate, [0.1, 2, \lin, 0.01, 1],
\posDev, [0, 0.2, 5, 0, 0.01],
\trigRate, [1, 200, \lin, 0.01, 120],
\granDur, [0.01, 0.3, \lin, 0.005, 0.06],
\rate, [0.1, 3, \lin, 0.01, 1],
\panMax, [0.0, 1, \lin, 0.0, 0.8],
\amp, [0.0, 1, \lin, 0.01, 0.25]
], stream: p
).gui(varColorGroups: (0..8).clumps([4,1,1,1,1,1]))
)
Example 2b: Switching between stochastic distributions
// Extended basic SynthDef from Ex.2a with bandpass filter
(
SynthDef(\gran_2b, { |out = 0, pos = 0, sndBuf = 0, windowBuf = 1, granDur = 0.1,
rate = 1, loop = 1, panMax = 0, amp = 1, bpFreq = 500, bpRQ = 0.5, bpWet = 1|
var window, granSrc, src;
granSrc = PlayBuf.ar(1, sndBuf, BufRateScale.kr(sndBuf) * rate,
1, round(pos * BufFrames.kr(sndBuf)), loop, 2);
window = BufRd.ar(1, windowBuf,
EnvGen.ar(Env([0, BufFrames.kr(windowBuf)], [granDur]),
doneAction: 2), loop, 4);
// do amplitude compensation, estimation like in Wavesets example by Alberto de Campo
src = (BPF.ar(granSrc, bpFreq, bpRQ, mul: (bpRQ ** -1) * (400 / bpFreq ** 0.5)) *
bpWet + (granSrc * (1 - bpWet)));
OffsetOut.ar(out, Pan2.ar(src, panMax, amp) * window);
}).add;
b = Buffer.read(s, Platform.userExtensionDir +/+ "miSCellaneous" +/+ "Sounds" +/+ "kitchen_sounds_1.wav");
// maybe you need to use Platform.systemExtensionDir instead
w = Buffer.sendCollection(s, Signal.hanningWindow(1024));
)
// random types
// 0: low value
// 1: low or high value, evenly distributed
// 2: evenly distributed
// 3: linear decrease from mean value
// 4: exponential distribution
// 5: beta distribution, default parameter 0.3 centers value at the borders
// 6: brownian movement (of first order)
// 7: brownian movement of second order (stepsize itself generated by brownian movement)
// A second order brownian movement much more tends to get stuck at the
// borders than a normal (first order) brownian movement
// E.g. see Sergio Luque's presentation of Xenakis's stochastic synthesis:
// "Stochastic Synthesis, Origins and Extensions", pp 25-28
// http://sergioluque.com
// Function that generates an array of PLx patterns
// of different random types (see PLx suite).
// These placeholders can refer to environmental variables
// to be set by the VarGui interface later on.
(
d = { |keyLo, keyHi, betaProb = 0.3, brownStepFac = 0.01,
brown2Ratio = 1, brown2StepFac = 0.01|
// keyLo and keyHi must be Symbols,
// other args may be Symbols
var patLo, patHi, patDif;
// avoid lo-hi reversing with Pbrown
patLo = min(PL(keyLo), PL(keyHi));
patHi = max(PL(keyLo), PL(keyHi));
patDif = patHi - patLo;
[
PL(keyLo),
Pfunc { currentEnvironment[[keyLo, keyHi].choose] },
PLwhite(keyLo, keyHi),
PLmeanrand(keyLo, keyHi),
PLexprand(keyLo, keyHi),
PLbeta(keyLo, keyHi, betaProb, betaProb),
PLbrown(patLo, patHi, patDif * PL(brownStepFac)),
PLbrown(patLo, patHi,
PLbrown(
patDif.neg * PL(brown2Ratio) / 2,
patDif * PL(brown2Ratio) / 2,
patDif * PL(brown2Ratio) * PL(brown2StepFac)
)
)
]
};
)
// trigrate, granDur, rate and bpFreq are
// chosen between bounds according to the
// random distribution type notated with suffix D
// single grains are filtered with a bandpass
// amount of effect controlled with bpWet
(
p = Pbind(
\instrument, \gran_2b,
\sndBuf, b,
\windowBuf, w,
\dur, 1 / PLswitch1(d.(\trigRateLo, \trigRateHi), \trigRateD),
\granDur, PLswitch1(d.(\granDurLo, \granDurHi), \granDurD),
\time, Ptime(),
\posRate, PL(\posRate),
\pos, Pfunc { |e|
var relTime = ~posRate * e.time / e.sndBuf.duration, relDif;
relDif = ~posHi - ~posLo;
relTime + rand2(~posDev) % relDif + ~posLo;
},
\rate, PLswitch1(d.(\rateLo, \rateHi), \rateD),
\bpFreq, PLswitch1(d.(\bpFreqLo, \bpFreqHi), \bpFreqD),
\bpRQ, PL(\bpRQ),
\bpWet, PL(\bpWet),
\amp, PL(\amp),
\panMax, PLseq([-1,1]) * PL(\panMax),
\out, 0
);
VarGui([
\posLo, [0.0, 0.99, \lin, 0.01, 0.21],
\posHi, [0.0, 0.99, \lin, 0.01, 0.47],
\posRate, [0.1, 2, \lin, 0.01, 0.2],
\posDev, [0, 0.2, 5, 0, 0.002],
\trigRateLo, [1, 200, \lin, 0.01, 21],
\trigRateHi, [1, 200, \lin, 0.01, 155],
\trigRateD, [0, 7, \lin, 1, 6],
\granDurLo, [0.01, 0.6, \exp, 0.0, 0.037],
\granDurHi, [0.01, 0.6, \exp, 0.0, 0.4],
\granDurD, [0, 7, \lin, 1, 6],
\rateLo, [0.1, 3, \lin, 0.01, 1.09],
\rateHi, [0.1, 3, \lin, 0.01, 1.63],
\rateD, [0, 7, \lin, 1, 1],
\bpFreqLo, [50, 10000, \exp, 0.1, 54],
\bpFreqHi, [50, 10000, \exp, 0.1,8275],
\bpFreqD, [0, 7, \lin, 1, 1],
\bpRQ, [0.01, 0.99, \lin, 0.0, 0.07],
\bpWet, [0.0, 1, \linear, 0.0, 0.23],
\panMax, [0.0, 1, \lin, 0.0, 0.85],
\amp, [0.0, 1, \lin, 0.01, 0.25]
], stream: p
).gui(varColorGroups: (0..19).clumps([4,3,3,3,5,1,1]))
)
Example 2c: Generating granular phrases with Pspawner
// This example needs SynthDef \gran_2b and Function d to be taken from Ex. 2b
(
b = Buffer.read(s, Platform.userExtensionDir +/+ "miSCellaneous" +/+ "Sounds" +/+ "kitchen_sounds_1.wav");
// maybe you need to use Platform.systemExtensionDir instead
w = Buffer.sendCollection(s, Signal.hanningWindow(1024));
)
// A simple form of Pspawner is used to generate phrases.
// Phrase length params are taken a bit roughly as sustain and
// rest times also depend on randomly varying grain lengths.
// spSustain controls medium sustain time (without grain length overhead)
// spLegato controls medium legato factor (disregarding reduction by grain length overhead)
// spDev is causing separate random deviation of spSustain and spLegato
// between 1/(1+spDev) and 1+spDev
// random distribution switching is restricted here to
// types 6 and 7 (random walks of first and second order)
// to force individual sound qualities of phrases.
(
// declare var here as pattern is repeatedly evaluated from within the Pspawner,
// interpreter variable would be unsafe if running examples in parallel
var p = Pbind(
\instrument, \gran_2b,
\sndBuf, b,
\windowBuf, w,
\dur, 1 / PLswitch1(d.(\trigRateLo, \trigRateHi), \trigRateD),
\granDur, PLswitch1(d.(\granDurLo, \granDurHi), \granDurD),
\time, Ptime(),
\posRate, PL(\posRate),
// random timeOffset added with each spawning
\pos, Pfunc { |e|
var relTime = ~posRate * e.time / e.sndBuf.duration + e.timeOffset, relDif;
relDif = ~posHi - ~posLo;
relTime + rand2(~posDev) % relDif + ~posLo;
},
\rate, PLswitch1(d.(\rateLo, \rateHi), \rateD),
\bpFreq, PLswitch1(d.(\bpFreqLo, \bpFreqHi), \bpFreqD),
\bpRQ, PL(\bpRQ),
\bpWet, PL(\bpWet),
\amp, PL(\amp),
\panMax, PLseq([-1,1]) * PL(\panMax),
\out, 0
);
q = Pspawner({ |sp|
var randomizer = { |x| var y = rand(x); 0.5.coin.if { 1 + y }{ 1 / (1 + y) } },
sus, legato, delta;
loop {
sus = ~spSustain * randomizer.(~spDev);
legato = ~spLegato * randomizer.(~spDev);
// take random offset for each phrase
sp.par(Pfindur(sus, Psetpre(\timeOffset, 5.0.rand, p)));
delta = sus / (~spLegato * randomizer.(~spDev));
sp.wait(delta)
}
});
VarGui([
\posLo, [0.0, 0.99, \lin, 0.01, 0.16],
\posHi, [0.0, 0.99, \lin, 0.01, 0.41],
\posRate, [0.1, 2, \lin, 0.01, 1.4],
\posDev, [0, 0.2, 5, 0, 0.0017],
\trigRateLo, [1, 200, \lin, 0.01, 70],
\trigRateHi, [1, 200, \lin, 0.01, 150],
\trigRateD, [6, 7, \lin, 1, 7],
\granDurLo, [0.01, 0.6, \exp, 0.0, 0.02],
\granDurHi, [0.01, 0.6, \exp, 0.0, 0.11],
\granDurD, [6, 7, \lin, 1, 6],
\rateLo, [0.1, 3, \lin, 0.01, 0.2],
\rateHi, [0.1, 3, \lin, 0.01, 1.86],
\rateD, [6, 7, \lin, 1, 7],
\bpFreqLo, [50, 10000, \exp, 0.1, 67],
\bpFreqHi, [50, 10000, \exp, 0.1, 5885],
\bpFreqD, [6, 7, \lin, 1, 6],
\bpRQ, [0.01, 0.99, \lin, 0.0, 0.17],
\bpWet, [0.0, 1, \linear, 0.0, 0.38],
\spSustain, [0.2, 2, \linear, 0.0, 0.884],
\spLegato, [0.6, 1.2, \linear, 0.0, 0.996],
\spDev, [0.0, 1, \linear, 0.0, 0.41],
\panMax, [0.0, 1, \lin, 0.0, 0.85],
\amp, [0.0, 1, \lin, 0.01, 0.35]
], stream: q
).gui(varColorGroups: (0..22).clumps([4,3,3,3,5,3,1,1]) )
)
Example 2d: Wave sets
// For this example you need Alberto de Campo's Wavesets class
// (Quark extension, implementation following definitions of Trevor Wishart)
// and the Function d from Ex. 2b
// the wave set player synth optionally adds a BPF applied to the signal,
// amount can be controlled with bpWet
// attack and release time > 0 for smoothening
(
SynthDef(\wsPlayer, { arg out = 0, buf = 0, start = 0, length = 441,
rate = 1, att = 0.03, rel = 0.03, wvDur = 1, panMax = 0, amp = 0.2,
delayL = 0.0, delayR = 0.0, bpFreq = 500, bpRQ = 0.5, bpWet = 1;
var phasor, env, granSrc, src, attEff, relEff, sus;
phasor = Phasor.ar(0, BufRateScale.ir(buf) * rate, 0, length) + start;
attEff = min(att, wvDur/2);
relEff = min(rel, wvDur/2);
sus = wvDur - attEff - relEff;
env = EnvGen.ar(Env([0, 1, 1, 0], [attEff, sus, relEff], \sine), doneAction: 2);
granSrc = BufRd.ar(1, buf, phasor);
src = (BPF.ar(granSrc, bpFreq, bpRQ, mul: (bpRQ ** -1) * (400 / bpFreq ** 0.5)) *
bpWet + (granSrc * (1 - bpWet)));
OffsetOut.ar(out, Pan2.ar(src, panMax, amp) * env);
}).add;
a = Platform.userExtensionDir +/+ "miSCellaneous" +/+ "Sounds" +/+ "kitchen_sounds_1.wav";
// maybe you need to use Platform.systemExtensionDir instead
b = Buffer.read(s, a);
w = Wavesets.from(a);
// relative positions of zero crossings
x = w.fracXings.drop(-1) / w.numFrames;
)
// Note that trigRate / event duration is not controlled directly in this setup,
// it's derived from wave set length (may vary) and legato factor.
// For short wave sets and a low legato value durs could become so short that
// a sudden mass of grains could cause hangs.
// To avoid this a parameter maxTrigRate is invented.
// As wavesets start at distinguished positions in the buffer and
// - together with legato - durations are determined,
// an additionally given position rate in general cannot result in a "correct"
// looping through the buffer, there will be a deviation.
// Here two types of approximation can be choosen with posType:
// Type 0 takes the waveset nearest to the calculated exact position.
// Type 1 linearly maps positions to wave set indices.
// As wave sets are of different length the latter is a rough heuristic
// accelerating buffer parts with relatively low frequencies.
(
p = Pbind(
\instrument, \wsPlayer,
// refering to interpreter variables within Pfuncs
// when running several examples in parallel is unsafe,
// so pass them here, then access from within the event
\b, b,
\w, w,
\x, x,
\time, Ptime(),
\posLo, PL(\posLo),
\posHi, PL(\posHi),
\posRate, PL(\posRate),
\pos, Pfunc { |e| (e.time * e.posRate / e.b.duration) %
(e.posHi - e.posLo) + e.posLo },
// Estimation of ws index from relative position, see explanation above,
// indexIn might be a bottleneck with large buffers,
// also a more rough estimation of ws index could be used:
// \startWs, Pfunc { |e| e.pos.linlin(0, 1, 0, e.w.xings.size - 2).round.asInteger }
\startWs, Pfunc { |e|
(~posType == 0).if {
e.x.indexIn(e.pos)
}{
e.pos.linlin(e.posLo, e.posHi, e.x.indexIn(e.posLo), e.x.indexIn(e.posHi))
.round.asInteger
}
},
\numWs, PLswitch1(d.(\numWsLo, \numWsHi), \numWsD),
\repeats, PLswitch1(d.(\repeatsLo, \repeatsHi), \repeatsD),
\bpFreq, PLswitch1(d.(\bpFreqLo, \bpFreqHi), \bpFreqD),
\bpRQ, PL(\bpRQ),
\bpWet, PL(\bpWet),
\rate, PLswitch1(d.(\rateLo, \rateHi), \rateD),
\data, Pfunc { |e| e.w.frameFor(e.startWs, e.numWs) },
\buf, b.bufnum,
\start, Pkey(\data).collect(_[0]), // startFrame
\length, Pkey(\data).collect(_[1]), // length (frameNum)
\wvDur, Pkey(\data).collect(_[2]) * Pkey(\repeats), // sustain time
\calculatedDur, Pkey(\wvDur) / PLswitch1(d.(\legatoLo, \legatoHi), \legatoD),
\dur, Pfunc { |e| max(e.calculatedDur, 1 / ~maxTrigRate) },
\panMax, PLseq([-1,1]) * PL(\panMax),
\amp, PL(\amp),
\out, 0
);
VarGui([
\posLo, [0, 1, \lin, 0.0, 0.15],
\posHi, [0, 1, \lin, 0.0, 0.45],
\posRate, [0.0, 2, \lin, 0.01, 0.25],
\posType, [0, 1, \lin, 1, 0],
\numWsLo, [1, 100, \lin, 1, 5],
\numWsHi, [1, 100, \lin, 1, 23],
\numWsD, [0, 7, \lin, 1, 6],
\repeatsLo, [1, 4, \lin, 1, 1],
\repeatsHi, [1, 4, \lin, 1, 2],
\repeatsD, [0, 7, \lin, 1, 6],
\maxTrigRate, [1, 250, \lin, 1, 200],
\bpFreqLo, [50, 10000, \exp, 0.1, 67],
\bpFreqHi, [50, 10000, \exp, 0.1, 9600],
\bpFreqD, [0, 7, \lin, 1, 7],
\bpRQ, [0.01, 0.99, \lin, 0.005, 0.22],
\bpWet, [0.0, 1, \lin, 0.005, 0.0],
\rateLo, [0.05, 2, \lin, 0.0, 0.32],
\rateHi, [0.05, 2, \lin, 0.0, 1.3],
\rateD, [0, 7, \lin, 1, 7],
\att, [0.0, 0.05, \lin, 0.001, 0.001],
\rel, [0.0, 0.05, \lin, 0.001, 0.001],
\panMax, [0.0, 1, \lin, 0, 0.8],
\legatoLo, [0.3, 25, \exp, 0, 0.4],
\legatoHi, [0.3, 25, \exp, 0, 5.5],
\legatoD, [0, 7, \lin, 1, 7],
\amp, [0.0, 2.0, \lin, 0.0, 0.7]
],
stream: p
).gui(varColorGroups: (0..25).clumps([4,3,3,1,5,3,2,1,3,1]))
)
3.) Hybrid Implementations
Example 3a: Granulation with ugen plus step sequencing
// Here the trigger for the TGrains ugen comes from a Pbind
// which also generates rates like a step sequencer
(
SynthDef(\gran_3a, { arg out = 0, posLo = 0.0, posHi = 1.0,
posRate = 1, posDev = 0.01, bufNum = 0, t_trig = 0,
granDur = 0.1, t_rate = 1.0, rateDev = 0,
panMax = 1, amp = 0.1, interp = 4;
var pan, pos, bufDur, bufDurSection, posDif;
posDif = posHi - posLo;
bufDur = BufDur.kr(bufNum);
bufDurSection = bufDur * posDif;
pos = posLo * bufDur +
(Phasor.ar(0, BufRateScale.kr(bufNum) * posRate / SampleRate.ir, posLo * bufDur, posHi * bufDur) +
(TRand.kr(-0.5, 0.5, t_trig) * posDev * bufDur)).mod(bufDurSection);
pan = Demand.kr(t_trig, 0, Dseq([panMax, panMax.neg], inf) * 0.999);
Out.ar(out, TGrains.ar(2, t_trig, bufNum, t_rate, pos, granDur, pan, amp, interp));
}, metadata: (
specs: (
posLo: [0.01, 0.99, \lin, 0.01, 0.2],
posHi: [0.01, 0.99, \lin, 0.01, 0.75],
posRate: [0.1, 2, \lin, 0.01, 1],
posDev: [0, 0.2, 5, 0, 0.01],
panMax: [0.0, 1, \lin, 0.005, 0.8],
amp: [0.0, 1, \lin, 0.005, 0.5]
)
)
).add;
b = Buffer.read(s, Platform.userExtensionDir +/+ "miSCellaneous" +/+ "Sounds" +/+ "kitchen_sounds_1.wav");
// maybe you need to use Platform.systemExtensionDir instead
)
// As the setting Pbind needs to know the Synth's nodeID
// the Synth has to be started explicitely and passed to the VarGui later on
// (VarGui takes Synths as well as SynthDefs, passing a SynthDef is recommended in general).
// The Synth starts silently as t_trig defaults to 0.
(
x = Synth(\gran_3a, [\bufNum, b]).register;
p = Pbind(
\type, \set,
\id, x,
\args, [\t_trig, \t_rate, \granDur],
\dur, PL(\dur),
\granDur, Pkey(\dur) * PL(\legato),
\t_trig, 1,
\t_rate, PLseq(\midi).midiratio
);
)
// Do start and pause with the Pbind (EventStreamPlayer) player.
// If you stop the Synth you cannot resume audio with a new Synth
// as the EventStreamPlayer has lost the correct nodeID
// (however the Synth can be paused and resumed).
(
VarGui(varCtr: [
\dur, [0.01, 0.1, \lin, 0, 0.05],
\legato, [0.3, 3, \lin, 0, 2],
\midi, [-12, 12, \lin, 1, 1] ! 8
], synth: x, stream: p
).gui;
)
Example 3b: Using external control synths
// Example needs SynthDef from Ex. 2a
// Also with language-driven granulation
// controls can be delegated to separate Synths,
// which output to control busses.
// Control inputs of single synths can read from
// these busses (comfortably use aBus.asMap in the Pbind)
// or synths can read from busses with In.kr (needs extra definition).
// A nearby parameter to determine with a separate synth is grain position
(
SynthDef(\bufPhasor, { |out = 0, sndBuf = 0, posRate = 1, posLo = 0, posHi = 1, posDev = 0.01|
var pos, posDif;
posDif = posHi - posLo;
pos = Phasor.ar(1, posRate * BufRateScale.kr(sndBuf) / BufFrames.kr(sndBuf), 0, posDif)
+ WhiteNoise.kr(posDev / 2) % posDif + posLo;
Out.kr(out, A2K.kr(pos));
}
).add;
b = Buffer.read(s, Platform.userExtensionDir +/+ "miSCellaneous" +/+ "Sounds" +/+ "kitchen_sounds_1.wav");
// maybe you need to use Platform.systemExtensionDir instead
w = Buffer.sendCollection(s, Signal.hanningWindow(1024));
c = Bus.control(s,1);
)
// in GUI start EventStreamPlayer and bufPhasor Synth
(
p = Pbind(
\instrument, \gran_2a,
\sndBuf, b,
\windowBuf, w,
\dur, 1 / PL(\trigRate),
\granDur, PL(\granDur),
\pos, c.asMap,
\rate, PL(\rate),
\amp, PL(\amp),
\panMax, PLseq([-1,1]) * PL(\panMax),
\out, 0
);
VarGui([
\trigRate, [1, 200, \lin, 0.01, 50],
\granDur, [0.01, 0.3, \lin, 0.005, 0.12],
\rate, [0.1, 3, \lin, 0.01, 1],
\panMax, [0.0, 1, \lin, 0.0, 0.8],
\amp, [0.0, 1, \lin, 0.01, 0.3]
],[
\out, c.index,
\sndBuf, b.bufnum,
\posLo, [0, 1, \linear, 0.005, 0],
\posHi, [0, 1, \linear, 0.005, 1],
\posRate, [0.1, 2, \linear, 0.01, 1],
\posDev, [0, 0.2, 5, 0, 0.01]
],
p, \bufPhasor
).gui(sliderPriority: \synth, playerPriority: \synth);
)
Example 3c: Switching between ugens of external control synths
// Example needs SynthDef from Ex. 2a
// external control synth for position as in 3a, but with
// different types of movement to select
(
SynthDef(\bufPosLFO, { |out = 0, lfoType = 0, freq = 1, posLo = 0, posHi = 1, posDev = 0.01|
var pos, posDif;
posDif = posHi - posLo;
pos = WhiteNoise.kr(posDev / 2) + Select.kr(lfoType,
[LFDNoise0, LFDNoise1, LFDNoise3].collect(_.kr(freq, posDif))) % posDif + posLo;
Out.kr(out, pos);
}).add;
b = Buffer.read(s, Platform.userExtensionDir +/+ "miSCellaneous" +/+ "Sounds" +/+ "kitchen_sounds_1.wav");
// maybe you need to use Platform.systemExtensionDir instead
w = Buffer.sendCollection(s, Signal.hanningWindow(1024));
c = Bus.control(s,1);
)
// added parallel grains
// in GUI start bufPhasor Synth before or together with EventStreamPlayer
// buffer position movement can be forward and backward
// lfoType 0: LFDNoise0 (jumps)
// lfoType 1: LFDNoise1 (linear interpolation)
// lfoType 2: LFDNoise3 (cubic interpolation, smooth, useful in many control contexts)
(
p = Pbind(
\instrument, \gran_2a,
\sndBuf, b,
\windowBuf, w,
\dur, 1 / PL(\trigRate),
\granDur, PL(\granDur),
\pos, c.asMap,
\rate, PL(\rate) * PL(\midiAdd).midiratio,
\amp, PL(\amp),
\panMax, PLseq([-1,1]) * PL(\panMax),
\out, 0
);
VarGui([
\trigRate, [1, 200, \lin, 0.01, 80],
\granDur, [0.01, 0.3, \lin, 0.005, 0.195],
\rate, [0.1, 1.5, \lin, 0.01, 0.6],
\midiAdd, [-5, 0].collect([-12, 12, \lin, 1, _]),
\panMax, [0.0, 1, \lin, 0.0, 0.95],
\amp, [0.0, 1, \lin, 0.01, 0.15]
],[
\out, c.index,
\posLo, [0, 1, \linear, 0.005, 0.15],
\posHi, [0, 1, \linear, 0.005, 0.43],
\posDev, [0, 0.2, 5, 0, 0.0],
\freq, [0.01, 2, \lin, 0, 0.96],
\lfoType, [0, 2, \lin, 1, 2]
],
p, \bufPosLFO
).gui(sliderPriority: \synth, playerPriority: \synth);
)
4.) Extensions of Setups
.) Changing ranges and scaling
This concerns all control parameters in question. E.g. the layering of long grains (> 200 ms) in connection with small rates of position changes (posRate) often has interesting effects. One may want to drop the term granulation in that case, though it's the same structure of synthesis. For such parameters with a very large coefficient boundHi / boundLo one may take exponential scaling, and if this is not fine enough you can invent a control pair of mantissa and exponent (as for posRate in Ex. 1b).
.) Parameter linkage
On the one hand a logical restriction, on the other hand it can make sense from a musical / perceptional point of view. E.g. shortening of grains could be linked with a raise of rate (as low frequencies might fail to unfold in short grains). Anyway parameter linkage is reducing complexity - it's a trade-off between simplicity of the interface and exclusion of certain constellations which should be considered from case to case.
.) Inventing and extending controls and LFO changes dependant on specific buffers and parameter sets
Say one has started playing around with a certain buffer and a general granulation patch. A parameter set that gives an interesting sound may react in a very interesting way on a change of a single parameter e.g., trigger rate. Then it may be an option to build in a control or a LFO specifically designed for that parameter - LFO is meant here in a general sense, it could be a LFO in a Synth, a dedicated LFO synth or defined by a rapidly sequencing Pattern.
.) Iterated granulation
Granulation of buffers themselves resulting from buffer granulation can give interesting effects.
.) Spatialization
For the sake of ease and comparison a L/R-switch per grain with one panning parameter was used in the examples above. Needless to say that spatial scattering of grains remains a large field of experimentation. Generally spoken spatialization can be part of the synthesis process or carried through independently afterwards, but also a combination of both approaches is feasible.
.) Effects
Effect processing can be applied to all or single grains in a language-driven granulation setup. There can be one or more effects, serial or in parallel, defined outside or inside the Synth playing the buffer, as with the BPF in Ex 2b - 2d. In these examples the bandpass is applied in general, but also a sequencing of effects can be done. And even in the case of just one effect (e.g. reverb) a decent sequencing of Fx- / noFx-events can sound very interesting. It may become challenging from an implementational point of view for chains of effects on single grains, but sequencing not more than one effect per grain can be done straightly: continously running effect synths read from different busses and events with different out values cause the player synths to output to these busses. A different approach, CPU-saving, is the use of Patterns that handle node ordering and bussing themselves (Pfx, Pbus).