diff --git a/convolution.scd b/convolution.scd index ec4fd97..fa59d99 100644 --- a/convolution.scd +++ b/convolution.scd @@ -1,3 +1,3 @@ -// var ir = Buffer.read(s, "/home/lcoogan/snd/ir/ForestScaleModel/ForestScaleModel/IR_ScaleModel/S1R1_ScaleModel.wav"); // Load an impulse response file +var ir = Buffer.read(s, "/home/lcoogan/snd/ir/ForestScaleModel/ForestScaleModel/IR_ScaleModel/S1R1_ScaleModel.wav"); // Load an impulse response file -// sig = Convolution2.ar(sig, ir, 512) * 0.5; // Apply convolution reverb with buffer size 512''' \ No newline at end of file +sig = Convolution2.ar(sig, ir, 512) * 0.5; // Apply convolution reverb with buffer size 512''' \ No newline at end of file diff --git a/granular_reverb.scd b/granular_reverb.scd index a4b491e..351f2f0 100644 --- a/granular_reverb.scd +++ b/granular_reverb.scd @@ -12,10 +12,10 @@ b = Buffer.readChannel(s, "non-oneshot-sample-path", channels:[0]); b = Buffer.readChannel(s, "/home/lcoogan/snd/live/2025-04-26.Basic_City_Brewery/trax/01-Acheinu_Kol_Beit_Israel.wav", channels:[0]); ( -b = Buffer.read(s, "/home/lcoogan/snd/live/2025-04-26.Basic_City_Brewery/trax/01-Acheinu_Kol_Beit_Israel.wav"); -b = Buffer.readChannel(s, "/home/lcoogan/snd/ardour/hebrewian_rue/export/hebrewian_rue_r1_lead.wav", channels:[0]); -b = Buffer.readChannel(s, "/home/lcoogan/snd/ardour/hebrewian_rue/export/hebrewian_rue_r1_harm.wav", channels:[0]); -b = Buffer.readChannel(s, "/home/lcoogan/snd/ardour/hebrewian_rue/export/hebrewian_rue_r1_drums.wav", channels:[0]); +// b = Buffer.read(s, "/home/lcoogan/snd/live/2025-04-26.Basic_City_Brewery/trax/01-Acheinu_Kol_Beit_Israel.wav"); +b = Buffer.readChannel(s, "/home/lcoogan/snd/ardour/hebrewian_rue/export/hebrewian_rue_r1_lead.wav", channels:[0], bufnum: 0); +b = Buffer.readChannel(s, "/home/lcoogan/snd/ardour/hebrewian_rue/export/hebrewian_rue_r1_harm.wav", channels:[0], bufnum: 1); +b = Buffer.readChannel(s, "/home/lcoogan/snd/ardour/hebrewian_rue/export/hebrewian_rue_r1_drums.wav", channels:[0], bufnum: 2); ) @@ -27,7 +27,8 @@ Buffer.readChannel(s, "/home/lcoogan/snd/live/2025-04-26.Basic_City_Brewery/craw Buffer.readChannel(s, "/home/lcoogan/snd/live/2025-04-26.Basic_City_Brewery/crawling-stems/break.wav", channels:[0], bufnum: 4); ) -b.play + +b.play; Ndef(\granulator).clear; Ndef(\granulator).ar(2); @@ -126,11 +127,27 @@ Ndef(\granulator).addSpec( \granDur, [0.0,8], \granCurve, [-10,10], \grainGate, [0,1], + \pos, [0] ).edit; +) +( +Ndef(\granulator).addSpec(\rate, [-2, 2]); +~ccMap = MIDIMap(\granulatorMap, Ndef(\granulator)); +~ccMap.map(\rate, ccNum: 1, channel: 2); // CC 1 on channel 2 → \rate +) + + +Quarks.install("ddwMIDI"); +( +CCAllocator(\granCC1, 1, 1, { |val| + var spec = Ndef(\granulator).getSpec(\rate); + var mappedVal = spec.map(val / 127); + Ndef(\granulator).set(\rate, mappedVal); +}); ) diff --git a/neo-hasidic_brainsex/13_microsound_granular_phrase_sampler.sc b/neo-hasidic_brainsex/13_microsound_granular_phrase_sampler.sc new file mode 100644 index 0000000..989ed2f --- /dev/null +++ b/neo-hasidic_brainsex/13_microsound_granular_phrase_sampler.sc @@ -0,0 +1,261 @@ +// ===================================================================== +// SuperCollider Workspace +// ===================================================================== + + +b = Buffer.readChannel(s, "/mnt/4/sound/gitarka_2/78.wav", channels:[0]); +b.play; +b.sampleRate; +b.numFrames; + + + +Ndef(\granular_reconstruct).clear; +Ndef(\granular_reconstruct).ar(2); +Ndef(\granular_reconstruct).set(\bufnum, b.bufnum); + + +( +Ndef(\granular_reconstruct, { |bufnum, overlap=2, tFreq=20| + var phasor, bufrd, gran, env; + var bufFrames = BufFrames.ir(bufnum); + var t = Impulse.ar(tFreq); + + phasor = Phasor.ar( + rate: 1.0, + start: 0.0, + end: bufFrames, + ); + + bufrd = BufRd.ar( + numChannels: 1, + bufnum: bufnum, + phase: phasor, + interpolation: 0 + ); + + gran = GrainBuf.ar( + numChannels: 1, + trigger: t, + dur: overlap / tFreq, + sndbuf: bufnum, + rate: 1, + pos: phasor / bufFrames, + interp: 0, + pan: 0, + envbufnum: -1, + maxGrains: 512, + ); + + + // bufrd + // - + gran + !2 +}).play; +) + +( +Ndef(\granular_reconstruct).addSpec( + \overlap, [0.0, 4], + \tFreq, \widefreq +).edit; +) + + + + + + + + +// env +e = Buffer.sendCollection(s, Signal.hanningWindow(1024)); +// e = Buffer.sendCollection(s, Signal.welchWindow(1024)); + + +e.plot + +( // playing it at right rate to fit duration + +var dur=0.4; +{ + PlayBuf.ar(1, e.bufnum, rate: 1 / ( dur * s.sampleRate / e.numFrames ), doneAction: 2); +}.plot(dur) + +) + + +( +SynthDef(\grain, { |out=0, bufnum, envbufnum, dur=0.1, pos=0| + var phasor, bufrd, env; + var bufFrames = BufFrames.ir(bufnum); + + phasor = Phasor.ar( + rate: 1.0, + start: pos, + end: bufFrames, + ); + + bufrd = BufRd.ar( + numChannels: 1, + bufnum: bufnum, + phase: phasor, + interpolation: 0 + ); + + env = PlayBuf.ar(1, envbufnum, rate: ( dur / BufDur.ir(envbufnum) ).reciprocal, doneAction: 2); + + bufrd = env * bufrd * 0.4; + // bufrd = env; + + // Out.ar(out, bufrd!2) + OffsetOut.ar(out, bufrd!2) +}).add; +) + + +Synth.grain(\grain, [\bufnum, b.bufnum, \envbufnum, e.bufnum, \dur, 1.2, \pos, 111111]); + + + +( +// s.latency = 0.15; +s.latency = 1024 * 6 / 44100; +Tdef(\grains, { + // var interonset = 1024 / 44100; // sec + var interonset = 0.001; // sec + inf.do { arg i; + + s.sendBundle( s.latency, + [ + 's_new', \grain, + -1, // nodeID + 1, // addAction + 1, // targetID + // synth args + \bufnum, b.bufnum, + \envbufnum, e.bufnum, + \dur, interonset * 2, + \pos, interonset * s.sampleRate * i % b.numFrames + ] + ); + + interonset.wait; + } +} ).play; +) + + + +( //envelopes +SynthDef(\grain, { |out=0, bufnum, dur=0.1, pos=0| + var phasor, bufrd, env; + var bufFrames = BufFrames.ir(bufnum); + + phasor = Phasor.ar( + trig: 0.0, + rate: 1.0, + start: pos, + end: bufFrames, + resetPos: 0.0 + ); + + bufrd = BufRd.ar( + numChannels: 1, + bufnum: bufnum, + phase: phasor, + interpolation: 0 + ); + + env = Env.linen( + attackTime: dur * 0.3, + sustainTime: dur * 0.4, + releaseTime: dur * 0.3, + level: 1.0, + // curve: \welch, + // curve: \sine, + // curve: -9, + // curve: 9 + // curve: [-5,5,0] + ); + + // env = Env.sine(dur); + // env = Env.perc(dur * 0.01, dur * 0.99); + + bufrd = EnvGen.ar( env, doneAction: 2 ) * bufrd * 0.3; + + // Out.ar(out, bufrd!2) + OffsetOut.ar(out, bufrd!2) +}).add; +) + + + + + + + + + + + + +// periodic tone + +({ +Out.ar(0, Impulse.ar(800).lag(0.005) !2); +}.play ) + +( +s.latency = 0.15; +r = Routine { + var interonset = 800.reciprocal; + loop { + s.sendBundle(s.latency, [ + // s.sendMsg( + \s_new, \grain, + s.nextNodeID, // nodeID + 1, // targetID + 1, // addAction + // synth args + \bufnum, b.bufnum, + \dur, interonset * 0.5, + \pos, 20000 + ] +); + interonset.wait; + } +}; + +SystemClock.play(r) +) + + +( // another approach (same result) +f = { + s.sendBundle(s.latency, [ + // s.sendMsg( + \s_new, \grain, + s.nextNodeID, // nodeID + 1, // targetID + 1, // addAction + // synth args + \bufnum, b.bufnum, + \dur, 200.reciprocal * 0.5, + \pos, 20000 + ] + ); +}; + +g = {arg i; SystemClock.sched(200.reciprocal * i, f)}; + +for(0, 1000, g); +) + +// on topic from James McCartney: https://medias.ircam.fr/xb090dd_supercollider-and-time + +// use NRT to get precise timings and low interonset times + + + diff --git a/neo-hasidic_brainsex/14_microsound_time_pitch_filters.sc b/neo-hasidic_brainsex/14_microsound_time_pitch_filters.sc new file mode 100644 index 0000000..ae32971 --- /dev/null +++ b/neo-hasidic_brainsex/14_microsound_time_pitch_filters.sc @@ -0,0 +1,274 @@ +// ===================================================================== +// SuperCollider Workspace +// ===================================================================== + + +b = Buffer.readChannel(s, "sound_file_path_here", channels:[0]); + +b.play; +b.plot; +b.sampleRate; +b.numFrames; + + + +( +SynthDef(\brec, { arg b; + var a, t; + a = WhiteNoise.ar; + RecordBuf.ar( + a, + bufnum: b, + run: 1, + loop:0, + doneAction: 2 + ); +}).play(args: [\b, b.bufnum]); +) + + + + + +Ndef(\granulator).clear; +Ndef(\granulator).ar(2); +Ndef(\granulator).set(\bufnum, b.bufnum); + + + + +( +Ndef(\granulator, { |bufnum, tFreq=20, overlap=2, rate=1, posRate=1| + var phasor, gran, env; + var bufFrames = BufFrames.ir(bufnum); + var t = Impulse.ar(tFreq); + + phasor = Phasor.ar( + rate: posRate * BufRateScale.kr(bufnum), + start: 0.0, + end: bufFrames, + ); + + gran = GrainBuf.ar( + numChannels: 1, + trigger: t, + dur: tFreq.reciprocal * overlap, + sndbuf: bufnum, + rate: rate, + pos: phasor / bufFrames, + // pos: Integrator.ar( K2A.ar(posRate) ) / BufFrames.ir(bufnum), // withoout phasor + interp: 2, + pan: 0, + envbufnum: -1, // Hann window + maxGrains: 512, + ); + + gran + * + 0.3 !2 + +}).play; + + + +Ndef(\granulator).addSpec( + \overlap, [0.001, 40, \exp], + \rate, [-1, 1, s.sampleRate.reciprocal], + \posRate, [0, 1, s.sampleRate.reciprocal], + // \rate, [0.9, 1, s.sampleRate.reciprocal], + // \posRate, [0.9, 1, s.sampleRate.reciprocal], + \tFreq, \widefreq, + // \delay, [0.0, 30 / s.sampleRate, 1/ s.sampleRate] + // \delay, [0.0, 0.1, 1/ s.sampleRate] +).edit; + +) + + + + + + + + +( // stereo + +// Ndef('granulator').set('tFreqMF', 3.5978835978836, 'tFreqMD', 14.074074074074, 'rate', 1.0042328042959, 'overlap', 10.664702036351, 'tFreq', 29.390328645693, 'bufnum', b.bufnum, 'posRate', 0.19576719702867); + +Ndef(\granulator, { |bufnum, tFreq=20, overlap=2, rate=1, posRate=1, +tFreqMF=0, tFreqMD=0, +rateMF=0, rateMD=0, +posRateMF=0, posRateMD=0| + + + var phasor, gran, env; + var bufFrames = BufFrames.ir(bufnum); + var t; + + var tFreqMod = { + SinOsc.ar(tFreqMF, Rand(0.0,2pi)) * tFreqMD; + }; + + var rateMod = { + SinOsc.ar(rateMF, Rand(0.0,2pi)) * rateMD; + }; + + var posRateMod = { + SinOsc.ar(posRateMF, Rand(0.0,2pi)) * posRateMD; + }; + + + tFreq = tFreq + tFreqMod.dup; + posRate = posRate + posRateMod.dup; + rate = rate + rateMod.dup; + + + t = Impulse.ar(tFreq); + + phasor = Phasor.ar( + rate: posRate * BufRateScale.kr(bufnum), + start: 0.0, + end: bufFrames, + ); + + gran = GrainBuf.ar( + numChannels: 1, + trigger: t, + dur: tFreq.reciprocal * overlap, + sndbuf: bufnum, + rate: rate, + pos: phasor / bufFrames, + interp: 2, + pan: 0, + envbufnum: -1, + maxGrains: 512, + ); + + gran * 0.5 + +}).play; + + +Ndef(\granulator).addSpec( + \overlap, [0.001, 40, \exp], + \rate, [-2, 2], + \posRate, [0, 4], + \tFreq, \widefreq, + \tFreqMF, [0.0,20], + \tFreqMD, [0.0,20], + \rateMF, [0.0,20], + \rateMD, [0.0,2], + \posRateMF, [0.0,20], + \posRateMD, [0.0,2], +).edit; + + + + +) + + + + + + +( +SynthDef(\granulator, { |bufnum, tFreq=20, overlap=2, rate=1, posRate=1, + tFreqMF=0, tFreqMD=0, + rateMF=0, rateMD=0, + posRateMF=0, posRateMD=0| + + + var phasor, gran, env; + var bufFrames = BufFrames.ir(bufnum); + var t; + + var tFreqMod = { + SinOsc.ar(tFreqMF, Rand(0.0,2pi)) * tFreqMD; + }; + + var rateMod = { + SinOsc.ar(rateMF, Rand(0.0,2pi)) * rateMD; + }; + + var posRateMod = { + SinOsc.ar(posRateMF, Rand(0.0,2pi)) * posRateMD; + }; + + + tFreq = tFreq + tFreqMod.dup; + posRate = posRate + posRateMod.dup; + rate = rate + rateMod.dup; + + + t = Impulse.ar(tFreq.lag(0.05)); + + phasor = Phasor.ar( + trig: 0.0, + rate: posRate * BufRateScale.kr(bufnum), + start: 0.0, + end: bufFrames, + resetPos: 0.0 + ); + + gran = GrainBuf.ar( + numChannels: 1, + trigger: t, + dur: tFreq.reciprocal * overlap, + sndbuf: bufnum, + rate: rate, + pos: phasor / bufFrames, + interp: 2, + pan: 0, + envbufnum: -1, + maxGrains: 512, + ); + + Out.ar(0, gran * \amp.kr(0.3)) + +}).add; +) + + + + + + + +b = Buffer.readChannel(s, "sound_file_path_here", channels:[0]); +b.play; + + +( +r = Routine({ + x = Synth(\granulator, [\amp, 0.3, 'tFreqMF', 3.5978835978836, 'tFreqMD', 14.074074074074, 'rate', 1.0042328042959, 'overlap', 10.664702036351, 'tFreq', 29.390328645693, 'bufnum', b.bufnum, 'posRate', 0.19576719702867]); + + 20.wait; + "enough waiting".postln; + + 10.do { |i| + x.set( + 'rate', 1, + 'overlap', 12, + 'tFreq', exprand(2,40.0), + 'tFreqMD', exprand(2,5.0), + 'tFreqMF', exprand(1,4.0), + 'posRate', exprand(0.01,0.4), + \rateMD, 0.001, + \rateMF, 0.1, + \posRateMD, 0.4, + \posRateMF, 3 +); + + i.postln; + + ( 2.pow(rrand(-2,2)) * 10 ).wait; + } +}); + +r.randSeed = 1234; +r.play + +) + + diff --git a/neo-hasidic_brainsex/15_microsound_granular_reverb.sc b/neo-hasidic_brainsex/15_microsound_granular_reverb.sc new file mode 100644 index 0000000..4bdfcbe --- /dev/null +++ b/neo-hasidic_brainsex/15_microsound_granular_reverb.sc @@ -0,0 +1,644 @@ +// ===================================================================== +// SuperCollider Workspace +// ===================================================================== + + +b = Buffer.readChannel(s, "non-oneshot-sample-path", channels:[0]); + +b = Buffer.readChannel(s, "one-shot-sample-path", channels:[0]); + +b.play + +Ndef(\granulator).clear; +Ndef(\granulator).ar(2); +Ndef(\granulator).set(\bufnum, b.bufnum); + + + + +( // one-shot reverb + +Ndef(\granulator, { |bufnum, tFreq=20, overlap=2, rate=1, tFreqMF=0, tFreqMD=0, +rateMF=0, rateMD=0, posRateMD=0, posRateMF=0, granDur=4| + + + var samplePhasor, phasor, gran, env, bufrd; + var bufFrames = BufFrames.ir(bufnum); + var t; + + var tFreqMod = { + SinOsc.ar(tFreqMF, Rand(0.0,2pi)) * tFreqMD; + }; + + var rateMod = { + SinOsc.ar(rateMF, Rand(0.0,2pi)) * rateMD; + }; + + + var posRateMod = { + SinOsc.ar(posRateMF, Rand(0.0,2pi)) * posRateMD; + }; + + + + var playTrig = Impulse.ar(\playTrFr.kr(0.5)); + + tFreq = tFreq + tFreqMod.dup; + rate = rate + rateMod.dup; + + + t = Impulse.ar(tFreq); + // t = In.ar(somebus); + + samplePhasor = EnvGen.ar(Env([0, 0, bufFrames], [0, bufFrames / SampleRate.ir], curve: 0), gate: playTrig); + phasor = EnvGen.ar(Env([0, 0, 1], [0, granDur], curve: 0), gate: playTrig); + + + bufrd = BufRd.ar( + numChannels: 1, + bufnum: bufnum, + phase: samplePhasor, + interpolation: 4 + ); + + bufrd = LeakDC.ar(bufrd); + + gran = GrainBufJ.ar( + numChannels: 1, + trigger: t, + dur: tFreq.reciprocal * overlap, + sndbuf: bufnum, + rate: rate, + // pos: phasor + WhiteNoise.ar(posRateMD!2), + pos: phasor + posRateMod.dup, + interp: 2, + pan: 0, + envbufnum: -1, + maxGrains: 512, + loop: 0 + ) * EnvGen.ar(Env.perc(0.001, granDur * \grainGate.kr(1), curve: \granCurve.kr(-4)), gate: playTrig); + + + Mix([ + bufrd * \dry.kr(1.0), + gran * \wet.kr(0.5) + ]) + + // DetectSilence.ar(gran, doneAction: 2); // in case we lauch it without trigger Ugens (with Synth etc) + +}); + + +Ndef(\granulator).addSpec( + \overlap, [0.001, 40, \exp], + \rate, [-2, 2], + \posRate, [0, 4], + \tFreq, \widefreq, + \tFreqMF, [0.0,80], + \tFreqMD, [0.0,20], + \rateMF, [0.0,80], + \rateMD, [0.0,2], + \posRateMF, [0.0,80], + \posRateMD, [0.0,2], + \dry, [0.0,1], + \wet, [0.0,1], + \playTrFr, [0.0,1], + \granDur, [0.0,8], + \granCurve, [-10,10], + \grainGate, [0,1], +).edit; + + + + +) + + + + +// tFreq modulation + little rate mod +Ndef('granulator').set('wet', 0.20634920634921, 'tFreq', 68.049596318246, 'posRateMF', 0.0, 'posRateMD', 0.0, 'rateMF', 40.21164021164, 'tFreqMF', 22.857142857143, 'tFreqMD', 18.835978835979, 'playTrFr', 0.24867724867725, 'granDur', 6.3915343915344, 'rateMD', 0.031746031746032, 'overlap', 27.015519604492, 'bufnum', b.bufnum, 'dry', 0.8994708994709, 'posRate', 1.0); + + +// rate modulation only +Ndef('granulator').set('wet', 0.49206349206349, 'tFreq', 68.049596318246, 'posRateMF', 0.0, 'posRateMD', 0.0, 'rateMF', 29.62962962963, 'tFreqMF', 0.0, 'tFreqMD', 0.0, 'playTrFr', 0.24867724867725, 'granDur', 6.8994708994709, 'rateMD', 0.052910052910053, 'overlap', 27.015519604492, 'bufnum', b.bufnum, 'dry', 0.82010582010582, 'posRate', 1.0); + + +// posRate mod only +Ndef('granulator').set('wet', 0.49, 'tFreq', 82.597877312021, 'posRateMF', 21.164021164021, 'posRateMD', 0.1481481486212, 'rateMF', 0.0, 'tFreqMF', 0.0, 'tFreqMD', 0.0, 'granDur', 1.1428571428571, 'playTrFr', 0.53439153439153, 'rateMD', 0.0, 'overlap', 14.580370622763, 'bufnum', b.bufnum, 'dry', 0.8); + +// all parameters at once +Ndef('granulator').set('wet', 0.53968253968254, 'tFreq', 56.063759866166, 'posRateMF', 0.0, 'rateMF', 20.31746031746, 'tFreqMF', 42.328042328042, 'tFreqMD', 7.6190476190476, 'playTrFr', 0.24867724867725, 'granDur', 0.8042328042328, 'rateMD', 0.031746031746032, 'overlap', 7.4400230051039, 'posRate', 1.0, 'bufnum', b.bufnum, 'dry', 0.77777777777778); + +// unnatural +Ndef('granulator').set('wet', 0.85714285714286, 'tFreq', 56.063759866166, 'posRateMF', 0.0, 'rateMF', 20.31746031746, 'tFreqMF', 42.328042328042, 'tFreqMD', 7.6190476190476, 'playTrFr', 0.24867724867725, 'granDur', 2.3703703703704, 'rateMD', 0.031746031746032, 'overlap', 21.58814020418, 'posRate', 1.0, 'bufnum', b.bufnum, 'dry', 0.77777777777778); + + + + +// on musical phrase sample +Ndef('granulator').set('wet', 0.1957671957672, 'rate', 1.0, 'tFreq', 82.597877312021, 'posRateMF', 0.0, 'posRateMD', 0.0, 'rateMF', 20.31746031746, 'tFreqMF', 0.0, 'tFreqMD', 0.0, 'playTrFr', 0.24867724867725, 'granDur', 5.4603174603175, 'rateMD', 0.0042328039805094, 'overlap', 12.323100555167, 'posRate', 1.0, 'bufnum', b.bufnum, 'dry', 0.84126984126984); + + +Ndef('granulator').set('granCurve', -0.79365079365079, 'wet', 0.48148148148148, 'rate', 1.0, 'tFreq', 82.597877312021, 'posRateMF', 7.1957671957672, 'posRateMD', 0.010582010582011, 'rateMF', 20.31746031746, 'tFreqMF', 53.333333333333, 'tFreqMD', 10.05291005291, 'playTrFr', 0.24867724867725, 'granDur', 5.4603174603175, 'rateMD', 0.010582010582011, 'overlap', 12.323100555167, 'grainGate', 1.0, 'bufnum', 311, 'dry', 0.84126984126984, 'posRate', 1.0); + + +( // triggered Env.new +{ + [ + EnvGen.kr(Env(levels: [0, 0.1, 0.2, 0.3], times: [0.1, 0.1, 0.1], curve: 8), gate: Impulse.kr(3)), + EnvGen.kr(Env(levels: [0, 0.0, 0.2, 0.3], times: [0.0, 0.1, 0.1], curve: 8), gate: Impulse.kr(3)) + ] +}.plot(duration: 1); +) + + + + + + + + + + + + + + +//////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////// +////////////////////// GrainBuf as effect ////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////// + + + + + +( +Ndef('alik_input_granulate_0').addSpec( + // \recLevel, [0,1], + // \preLevel, [0,1], + \feedback, [-2.0,2], + \inAmp, \inAmp, + \wet, \bipolar, + + \inputAmp, [0,30], + + \tFreqMF, [0,200], + \tFreqMD, [0,200], + \offsetMF, \widefreq, + \offsetMD, [0.0,1], + \rateMF, \widefreq, + \rateMD, [0.0,1], + \offset, [0.0,1], + \rate, \bipolar, + \tFreq, [1,22050, \exp], + \overlap, [0.01,512.0, \exp], + \grHpf, \freq, + \grLpf, \freq, + \wet, [0.0,1], + \dry, [0.0,1], + \outAmp, [0.0,4], +) +) + + + + + + + +Ndef('alik_input_granulate_0').clear +Ndef('alik_input_granulate_0').ar(2) +Ndef('alik_input_granulate_0').edit + + + + + + + +( +Ndef('alik_input_granulate_0', {| + inAmp=1, outAmp=1, overlap=2, tFreq=20, tFreqMF=0, tFreqMD=0, + rate=1, rateMF=0, rateMD=0, + offset = 0, offsetMF=0, offsetMD=0 + | + + + var input; + var gDur, readPos, signal, writePos, grained, balance; + + var t, bufFrames, bufRateScale; + var buf, bufdur; + + + + + var tFreqMod = { + SinOsc.ar(tFreqMF, Rand(0.0,2pi)) * tFreqMD; + }; + + var rateMod = { + SinOsc.ar(rateMF, Rand(0.0,2pi)).range(rateMD.neg, rateMD); + // SinOsc.ar(rateMF, Rand(0.0,2pi)).range(0, rateMD); + }; + + var offsetMod = { + SinOsc.ar(offsetMF, Rand(0.0,2pi)).range(0, offsetMD); + // LFDNoise3.ar(offsetMF).range(0,offsetMD(0.0)) + }; + + + tFreq = tFreq + tFreqMod.dup; + rate = rate - rateMod.dup; + + + bufFrames = 2**16; + buf = {LocalBuf(bufFrames).clear}!2; + bufdur = BufDur.ir(buf); + + + writePos = Phasor.ar( end: bufFrames ); + + + t = Impulse.ar(tFreq); + + + readPos = + writePos + - 64 // looks like a controlblocksize ------ why? + / bufFrames + - offset + - offsetMod.dup; + + // readPos = readPos.clip( 0, bufFrames - 64 / bufFrames ); + + readPos = Wrap.ar(readPos, 0, 1); + + + + + ( + offset * bufFrames + 64 / SampleRate.ir + ).poll(10, \delaytime); + + + + + grained = GrainBufJ.ar( + numChannels:1, + loop: 1, + trigger:t, + dur: overlap / tFreq, + sndbuf: buf, + rate: rate, + pos: readPos, + interp: 4, + pan: 0, + envbufnum:-1 + ); + + + grained = HPF.ar( grained, \grHpf.kr(40) ); + grained = LPF.ar( grained, \grLpf.kr(15000) ); + + + + + input = SoundIn.ar([0,1]) * inAmp; + + // writing granulated + input back to grain buffer + buf.do { |b i| + + BufWr.ar(grained[i] * \feedback.kr(0.3) + input[i], b, writePos) + + // RecordBuf has an option to overdub, might be of any use for big mess + // RecordBuf.ar( + // grained[i] * \feedback.kr(0.3) + input[i], + // b, + // recLevel: \recLevel.kr(1), + // preLevel: \preLevel.kr(0), + // ); + + }; + signal = Mix([ + grained * \wet.kr(1), + input * \dry.kr(1) + ]) * outAmp; + + + + // signal.tanh + signal + + + +}).play + +) + + + + + +// good on piano (and cheap) +Ndef('alik_input_granulate_0').set('offset', 0.031746031746032, 'tFreqMD', 0.0, 'wet', 0.4973544973545, 'rateMF', 19.782824080247, 'outAmp', 1, 'rate', 1.0, 'grLpf', 14393.713460023, 'offsetMF', 93.986276007881, 'inAmp', 1, 'tFreqMF', 25.092540737125, 'grHpf', 92.831776672256, 'tFreq', 26.59633942062, 'overlap', 5.304141781977, 'rateMD', 0.0, 'offsetMD', 0.10582010582011, 'dry', 1.0, 'feedback', 0.44444444444445); + + +// flies around piano +Ndef('alik_input_granulate_0').set('offset', 0.042328042328042, 'tFreqMD', 0.0, 'wet', 0.079365079365079, 'rateMF', 19.782824080247, 'outAmp', 1, 'rate', 1.0, 'grLpf', 8319.1243261437, 'offsetMF', 8.0769777651696, 'inAmp', 1, 'tFreqMF', 0.21943273553761, 'grHpf', 92.831776672256, 'tFreq', 395.23259800231, 'overlap', 102.70706933049, 'rateMD', 0.0, 'offsetMD', 0.5978835978836, 'dry', 1.0, 'feedback', 0.084656084656086); + + +// drum room +Ndef('alik_input_granulate_0').set('offset', 0.031746031746032, 'wet', 0.15343915343915, 'rate', 1.0, 'tFreq', 58.821600133219, 'grLpf', 11144.529591014, 'inAmp', 1, 'offsetMF', 4245.0550792034, 'offsetMD', 0.037037037037037, 'rateMF', 0.0, 'tFreqMF', 20.10582010582, 'grHpf', 89.385349076664, 'tFreqMD', 0.0, 'outAmp', 1, 'overlap', 9.7726573922977, 'dry', 1.0, 'feedback', 0.13756613756614); + + +// cheap +Ndef('alik_input_granulate_0').set('offset', 0.031746031746032, 'wet', 0.16402116402116, 'rate', 1.0, 'tFreq', 337.21723538924, 'grLpf', 11144.529591014, 'inAmp', 1, 'offsetMF', 100.25642627688, 'offsetMD', 0.083068783439341, 'rateMF', 0.0, 'tFreqMF', 83.597883597884, 'grHpf', 89.385349076664, 'tFreqMD', 93.121693121693, 'outAmp', 1, 'overlap', 9.7726573922977, 'dry', 1.0, 'feedback', 0.43386243386244); + +Ndef('alik_input_granulate_0').set('offset', 0.010582010582011, 'wet', 0.10582010582011, 'rate', 1.0, 'tFreq', 120.0, 'grLpf', 11144.529591014, 'inAmp', 1, 'offsetMF', 43.300320303739, 'offsetMD', 0.22063492100548, 'rateMF', 0.37037037037037, 'tFreqMF', 105.82010582011, 'grHpf', 89.385349076664, 'tFreqMD', 0.0, 'rateMD', 0.0063492061284487, 'outAmp', 1, 'overlap', 15.46489059164, 'dry', 1.0, 'feedback', 0.30687830687831); + +Ndef('alik_input_granulate_0').set('offset', 0.026455026455026, 'wet', 0.16402116402116, 'offsetMD', 0.037037037037037, 'rate', 1.0, 'grLpf', 11144.529591014, 'tFreq', 123.38739758059, 'inAmp', 1, 'rateMF', 0.14732846585601, 'tFreqMF', 83.597883597884, 'tFreqMD', 93.121693121693, 'grHpf', 89.385349076664, 'rateMD', 0.48148148148148, 'outAmp', 1, 'overlap', 9.7726573922977, 'offsetMF', 100.25642627688, 'dry', 1.0, 'feedback', 0.43386243386244); + +// expensive + +Ndef('alik_input_granulate_0').set('outAmp', 1, 'inAmp', 1, 'offset', 0.0052910052910053, 'offsetMF', 8637.9141790185, 'tFreq', 2799.9461420941, 'offsetMD', 0.22751322751323, 'feedback', 0.052910052910052, 'rate', 1.0, 'overlap', 136.83090472716, 'grHpf', 89.385349076664, 'grLpf', 11144.529591014, 'dry', 1.0, 'wet', 0.042328042328042); + + + + + + + + + + + + + + +( +g = SynthDef('alik_input_granulate_0', {| + inAmp=1, outAmp=1, overlap=2, tFreq=20, tFreqMF=0, tFreqMD=0, + rate=1, rateMF=0, rateMD=0, + offset = 0, offsetMF=0, offsetMD=0 + | + + + var input; + var gDur, readPos, signal, writePos, grained, balance; + + var t, bufFrames, bufRateScale; + var buf, bufdur; + + + + + var tFreqMod = { + SinOsc.ar(tFreqMF, Rand(0.0,2pi)) * tFreqMD; + }; + + var rateMod = { + SinOsc.ar(rateMF, Rand(0.0,2pi)).range(0, rateMD); + }; + + var offsetMod = { + SinOsc.ar(offsetMF, Rand(0.0,2pi)).range(0, offsetMD); + }; + + + tFreq = tFreq + tFreqMod.dup; + rate = rate - rateMod.dup; + + + bufFrames = 2**16; + buf = {LocalBuf(bufFrames).clear}!2; + bufdur = BufDur.ir(buf); + + + writePos = Phasor.ar( end: bufFrames ); + + + t = Impulse.ar(tFreq); + + + readPos = + writePos + - 64 // looks like a controlblocksize ------ why? + / bufFrames + - offset + - offsetMod.dup; + + // readPos = readPos.clip( 0, bufFrames - 64 / bufFrames ); + + readPos = Wrap.ar(readPos, 0, 1); + + ( + offset * bufFrames + 64 / SampleRate.ir + ).poll(1, \delaytime); + + + + + grained = GrainBufJ.ar( + numChannels:1, + loop: 1, + trigger:t, + dur: overlap.lag(5) / tFreq, + sndbuf: buf, + rate: rate, + pos: readPos, + interp: 4, + pan: 0, + envbufnum:-1 + ); + + + grained = HPF.ar( grained, \grHpf.kr(40) ); + grained = LPF.ar( grained, \grLpf.kr(15000) ); + + + + + input = In.ar(\inBus.kr,2) * inAmp; + + // writing granulated + input back to grain buffer + buf.do { |b i| + + BufWr.ar(grained[i] * \feedback.kr(0.3) + input[i], b, writePos) + + }; + + signal = Mix([ + grained * \wet.kr(1).lag(3), + input * \dry.kr(1) + ]) * outAmp; + + + + Out.ar(0, + signal.tanh + ) + + + +}).add; + + + +SynthDef(\sin_pulsar, { |out=0| + var a,b,c,d,e,f, f_ ,t,lev, formantA, formantB, overlapA, overlapB; + lev = \lev.kr(0.3); + f = \freq.kr(440); + f_ = f.clip(50, 1500); + + formantA = \formantA.kr(2); + formantB = \formantB.kr(6); + overlapA = \overlapA.ar(2); + overlapB = \overlapB.kr(2); + + e = EnvGen.kr( + Env.perc( + attackTime: ( f_.linlin( 50, 1500, 0.1, 0.02) ), + releaseTime: Rand(1,7) + ), + gate: \gate.kr(1) + ); + + e = e * PinkNoise.ar(1!2).range( 0.1, 1 ).lag(0.02) ; + + a = GrainSin.ar( + numChannels: 1, + trigger: Impulse.ar(f), + // dur: overlapA * ( 1.05 - e.pow(0.5) ) + dur: overlapA * ( 0.05 + e.pow(0.5) ) + * SinOsc.ar(e * 2, {Rand(0, 6.28)}.dup).range(0.87,1.15) + / f, + freq: f * + ( formantA * SinOsc.ar(3 * e, {Rand(0, 6.28)}.dup).range(0.9,1.1) ), + pan: PinkNoise.ar(0.5!2), + ); + + + b = GrainSin.ar( + numChannels: 1, + trigger: Impulse.ar(f) + Rand(-1,1), + // dur: overlapB * ( 1.05 - e.pow(0.5) ) + dur: overlapB * ( 0.05 + e.pow(0.5) ) + *SinOsc.ar(e * 1, {Rand(0, 6.28)}.dup).range(0.87,1.15) + / f, + freq: f * + ( formantB * SinOsc.ar(e * 3, {Rand(0, 6.28)}.dup).range(0.9,Rand(1,1.5)) ), + pan: PinkNoise.ar(0.5!2), + ); + + + c = GrainSin.ar( + numChannels: 1, + trigger: Impulse.ar(f), + // dur: Rand(0.5,2) * ( 0.05 + e.pow(0.5) ) + dur: 1.5 * ( 0.05 + e.pow(0.5) ) + *SinOsc.ar(e * 1.5, {Rand(0, 6.28)}.dup).range(0.87,1.15) + / f, + freq: f + * SinOsc.ar(e * 2, {Rand(0, 6.28)}.dup).range(0.9,Rand(1,1.5)) + , + pan: PinkNoise.ar(0.5!2), + ); + + c = Mix([ + a * ( lev * e ).pow(f_.linlin( 50, 1500, 1.1, 2.5)), + b * ( lev * 0.8 * e ).pow(f_.linlin( 50, 1500, 0.85, 4.5)), + c * ( lev * e ).pow(0.7) + ]); + + + c = LeakDC.ar(c); + + + DetectSilence.ar(c, doneAction: 2); + Out.ar(out, c ) +}).add; + +) + + + +~reverbBus = Bus.audio(s, 2); + + + +( + +Routine({ + thisThread.randSeed = 1234; + // thisThread.randSeed = 2341567; + // thisThread.randSeed = 4315627; + // thisThread.randSeed = 1716434; + // thisThread.randSeed = 2205318; + Pbind( + \instrument, \sin_pulsar, + \dur, Pseq( 2.pow((-4..1).scramble), inf ), + \legato, Pfunc({rrand(0.01,1)}), + \degree, Pseq([0,2,5,6,8,11].scramble, inf), + \octave, Pstutter(3, Pseq([3,4,5], inf) ), + // \lev, Pstutter(6, Pseq([ 0.2, 1, 1.2 ].scramble, inf)), + \lev, Pshuf(( 1..10 ) * 0.01, inf), + \overlapA, Pseq(2.pow([-1,0,1,2]), inf), + \overlapB, Pseq(2.pow([-1,0,1].scramble), inf), + + \formantA, Pseq([1,2,3], inf), + // \formantA, 4, + \formantB, Pseq([3,4,5,6,7].scramble, inf), + // \formantB, 16, + \out, ~reverbBus + // \outBus, 0 + ).play; + + + + + x = Synth( 'alik_input_granulate_0', + addAction: \addToTail, + args: [ + \inBus, ~reverbBus, + 'offset', 0.042328042328042, 'tFreqMD', 0.0, 'wet', 0, 'rateMF', 19.782824080247, 'outAmp', 1, 'rate', 1.0, 'grLpf', 8319.1243261437, 'offsetMF', 8.0769777651696, 'inAmp', 1, 'tFreqMF', 0.21943273553761, 'grHpf', 92.831776672256, 'tFreq', 395.23259800231, 'overlap', 102.70706933049, 'rateMD', 0.0, 'offsetMD', 0.5978835978836, 'dry', 1.0, 'feedback', 0.084656084656086 + ]); + + 8.wait; + + 10.do { |i| + i.postln; + x.set( + 'overlap', 5, + 'tFreq', 26.59633942062, + 'tFreqMD', exprand(1.0,55), + 'tFreqMF', 25.092540737125, + 'rate', 1.0, + 'rateMF', exprand(3,55), + 'rateMD', rand(0.005), + 'offset', exprand(0.05,0.7), + 'offsetMF', 93.986276007881, + 'offsetMD', exprand(0.01,0.4), + 'grHpf', 92.831776672256, + 'grLpf', 14393.713460023, + 'feedback', 0.4, + 'dry', 1 - exprand(0.1,0.6), + 'wet', 0.7, + ); + + 8.wait; + + }; + + x.set('offset', 0.026455026455026, 'wet', 0.16402116402116, 'offsetMD', 0.037037037037037, 'rate', 1.0, 'grLpf', 11144.529591014, 'tFreq', 123.38739758059, 'inAmp', 1, 'rateMF', 0.14732846585601, 'tFreqMF', 83.597883597884, 'tFreqMD', 93.121693121693, 'grHpf', 89.385349076664, 'rateMD', 0.48148148148148, 'outAmp', 1, 'overlap', 9.7726573922977, 'offsetMF', 100.25642627688, 'dry', 1.0, 'feedback', 0.43386243386244); + + +}).play +) + + + diff --git a/neo-hasidic_brainsex/25_microsound_granular_compressor.sc b/neo-hasidic_brainsex/25_microsound_granular_compressor.sc new file mode 100644 index 0000000..f04746d --- /dev/null +++ b/neo-hasidic_brainsex/25_microsound_granular_compressor.sc @@ -0,0 +1,364 @@ +Ndef( \compressor).clear; +Ndef( \compressor).ar(2); + +( + +Ndef( \compressor, { + var local; + var attack = \attack.kr(0.01); + var release = \release.kr(0.1); + var dry, drywet, in, t, o, r, c, e, lookahead; + var kneelag; + var bias; + + t = \threshold.kr(-6); + + dry = SoundIn.ar([0,1]); + + in = dry * \trim.kr(0).dbamp; + + e = in.mean; + + e = HPF.ar( e, \hpf.kr(50) ); + + e = EnvDetect.ar(e, attack, release); // smooth abs values + + // how much we are over by + o = e.ampdb.excess(t); + + // scale the excess value by ratio + r = \ratio.kr(4); + c = ( max(o, 0.0) ) * (r.reciprocal - 1); + + kneelag = attack * \knee.kr(0.0); + + c = c.lag( kneelag ); + c = c.dbamp; + + lookahead = \lookahead.kr(0); + in = DelayC.ar( in, 0.5, lookahead.lag(0.4) ); // lookahead + in = in * c; + in = in * \gain.kr(0).dbamp; + bias = K2A.ar(\bias.kr(0.0)); + + in = Select.ar( \saturate.kr(1), [in, (in + bias).softclip - bias] ); + in = LeakDC.ar(in); + + drywet = \dry_wet.kr(1); + Mix([ + in * drywet, + DelayC.ar( dry * (1 - drywet), 0.5, lookahead.lag(0.4) ) + ]) + + +} ).play; + + +( +Spec.add(\attack, [0.0000001,0.1, \exp]); +Spec.add(\release, [0.0000001,0.4, \exp]); +Spec.add(\threshold, [0,-120]); +Spec.add(\trim, [0,60]); +Spec.add(\gain, [-40,40]); +Spec.add(\ratio, [1,20, \exp]); +Spec.add(\dry_wet, [0,1]); +Spec.add(\hpf, [10, 1000]); +Spec.add(\knee, [0.0, 10]); +Spec.add(\lookahead, [0.0,1]); +Spec.add(\saturate, \switch); +Spec.add(\bias, [0.0, 1.0]); +); + + +Ndef('compressor').set('threshold', -58.604651162791, 'saturate', 0.0, 'lookahead', 0.037037037037037, 'gain', 34.448135843484, 'release', 0.053953680737862, 'bias', 0.0, 'dry_wet', 1.0, 'knee', 1.0077519379845); + + + +Ndef( \compressor).edit; + +) + + + + + + + +//// Analysis plots --begin + +({ +EnvDetect.ar(SinOsc.ar, 0.01,0.01); +}.plot(1)) + +({ +EnvDetect.ar(SinOsc.ar, 0.01,0.01).ampdb; +}.plot(1)) + +({ +max( EnvDetect.ar(SinOsc.ar, 0.01,0.01).ampdb.excess(-10), 0); + +}.plot(1)) + +({ +var r = 2; +max( EnvDetect.ar(SinOsc.ar, 0.01,0.01).ampdb.excess(-10), 0) * (r.reciprocal - 1); +}.plot(1)) + +({ +var r = 10; +var db = max( EnvDetect.ar(SinOsc.ar, 0.01,0.01).ampdb.excess(-10), 0) * (r.reciprocal - 1); +db.dbamp +}.plot(1)) + +///// Analysis plots --end + + + + + +Ndef(\analysis).clear; +Ndef(\analysis).ar(1); + + + +( +Ndef(\analysis, { + + var input, in, e, thresh, c, attack, release, kneelag; + input = SoundIn.ar([0,1]); + + + attack = \attack.kr(0.01); + release = \release.kr(0.1); + thresh = \threshold.kr(-6); + in = input * \trim.kr(0).dbamp; + + e = in.mean; + + e = HPF.ar( e, \hpf.kr(50) ); + + e = EnvDetect.ar(e, attack, release); + + // how much we are over by + o = e.ampdb.excess(thresh); + + // scale the excess value by ratio + r = \ratio.kr(4); + c = ( max(o, 0.0) ) * (r.reciprocal - 1); + + kneelag = attack * \knee.kr(0.0); + + c = c.lag( kneelag ); + c = c.dbamp; + + +}); + +Ndef('analysis').set('threshold', -58.6, 'release', 0.05, 'knee', 1.01); + +Ndef(\analysis).edit; +) + + +Ndef( \comp).clear; +Ndef( \comp).ar(2); + + +( + +Ndef( \comp, { + var dry, in, c, lookahead; + var bias; + var gain = \gain.kr(0).dbamp; + dry = SoundIn.ar([0,1]); + + in = dry; + + c = Ndef(\analysis).ar; + + lookahead = \lookahead.kr(0); + in = DelayC.ar( in, 0.5, lookahead); // lookahead + in = in * c; + in = in * gain; + bias = K2A.ar(\bias.kr(0.0)); + + in = Select.ar( \saturate.kr(1), [in, (in + bias).softclip - bias] ); + in = LeakDC.ar(in); + + Mix([ + in * \wet.kr(1), + DelayC.ar( dry * gain * \dry.kr(1), 0.5, lookahead ) + ]) + + +} ).play; + +Ndef('comp').set('gain', 33.0, 'lookahead', 0.015503875968992, 'dry', 0.0); + +Ndef( \comp).edit; + + +) + + + + + + + + + + + + + +Ndef(\granular_comp).clear +Ndef(\granular_comp).ar(2) + + + + +( +Ndef('granular_comp').addSpec( + \lookahead, [0.0,1], + + \saturate, \switch, + \lpf, [0.0, 0.2], + \inAmp, \inAmp, + \wet, \bipolar, + \inputAmp, [0,30], + \lookahead, [0.0,4100], + \rate, [0,1], + \tFreq, [1,22050, \exp], + \overlap, [0.01,512.0, \exp], + \hpf, \freq, + \wet, [0.0,1], + \dry, [0.0,1], + \gain, [0.0,40], +) +) + + + +( +( +Ndef('granular_comp', {| + inAmp=1, gain=0, lookahead = 0, tFreq=20, overlap=2, rate=1, lpf=0 + | + + + var input; + var readPos, signal, writePos, grained, balance; + + var t, bufFrames; + var buf, bufdur; + + var sc; + + + + bufFrames = 2**16; + buf = {LocalBuf(bufFrames).clear}!2; + bufdur = BufDur.ir(buf); + + + writePos = Phasor.ar( + 0, + rate, + 0, + bufFrames + ); + + + input = SoundIn.ar([0,1]) * inAmp; + // writing input to grain buffer + buf.do { |b i| BufWr.ar( input[i], b, writePos) + }; + + + t = Impulse.ar(tFreq); + + + readPos = Wrap.ar( + writePos - 64 - lookahead / bufFrames, + 0, + 1 + ); + + + sc = Ndef(\analysis).ar; + + grained = GrainBufJ.ar( + numChannels:1, + loop: 1, + trigger:t, + // dur: overlap / tFreq, + dur: sc * overlap / tFreq, + sndbuf: buf, + rate: rate - lpf, + pos:readPos, + interp: 4, + // grainAmp: sc, + pan: 0, + envbufnum:-1 + ); + + + grained = HPF.ar( grained, \hpf.kr(40) ); + + + signal = Mix([ + LeakDC.ar( grained ) * \wet.kr(1), + DelayC.ar( + input, + 0.5, + (64 + lookahead / SampleRate.ir ) + ) * \dry.kr(0) + ]) * gain.dbamp; + + + + signal.tanh + + + +}).play; + + + + + +Ndef('granular_comp').edit + +) + +) + + + + + + + + + + + +( // using overlap + +Ndef('analysis').set('threshold', -58.6, 'ratio', 4.0, 'release', 0.095152954811494, 'knee', 1.01); + +Ndef('granular_comp').set('lookahead', 2288.3720930233, 'wet', 0.96124031007752, 'rate', 1.0, 'tFreq', 5054.5412673637, 'lpf', 0.024338624338624, 'inAmp', 0.7751938, 'gain', 1.0542635658915, 'overlap', 337.20506220588, 'dry', 0.0); +) + + + + +( // lofi +Ndef('granular_comp').set('lookahead', 127.13178294574, 'wet', 0.66666666666667, 'rate', 0.2, 'tFreq', 4328.5464121672, 0.7751938, 'overlap', 157.82885262499, 'gain', 1.3643410852713, 'dry', 0.0); +Ndef('analysis').set('threshold', -58.6, 'ratio', 1.7870536713698, 'release', 0.068293378346003, 'attack', 0.0055486335881451, 'knee', 1.01); +) + + + + diff --git a/neo-hasidic_brainsex/01-Acheinu_Kol_Beit_Israel.scd b/neo-hasidic_brainsex/old/01-Acheinu_Kol_Beit_Israel.scd similarity index 100% rename from neo-hasidic_brainsex/01-Acheinu_Kol_Beit_Israel.scd rename to neo-hasidic_brainsex/old/01-Acheinu_Kol_Beit_Israel.scd diff --git a/neo-hasidic_brainsex/02-Cantor_Mordechai_Hershman_Baruch_Hashem_Bayom.scd b/neo-hasidic_brainsex/old/02-Cantor_Mordechai_Hershman_Baruch_Hashem_Bayom.scd similarity index 100% rename from neo-hasidic_brainsex/02-Cantor_Mordechai_Hershman_Baruch_Hashem_Bayom.scd rename to neo-hasidic_brainsex/old/02-Cantor_Mordechai_Hershman_Baruch_Hashem_Bayom.scd diff --git a/neo-hasidic_brainsex/03-Cantor_Samual_Malavsky_Shomea_Kol_Bichios.scd b/neo-hasidic_brainsex/old/03-Cantor_Samual_Malavsky_Shomea_Kol_Bichios.scd similarity index 100% rename from neo-hasidic_brainsex/03-Cantor_Samual_Malavsky_Shomea_Kol_Bichios.scd rename to neo-hasidic_brainsex/old/03-Cantor_Samual_Malavsky_Shomea_Kol_Bichios.scd diff --git a/neo-hasidic_brainsex/04-Cantor_Samuel_Malavsky_Zechor.scd b/neo-hasidic_brainsex/old/04-Cantor_Samuel_Malavsky_Zechor.scd similarity index 100% rename from neo-hasidic_brainsex/04-Cantor_Samuel_Malavsky_Zechor.scd rename to neo-hasidic_brainsex/old/04-Cantor_Samuel_Malavsky_Zechor.scd diff --git a/neo-hasidic_brainsex/05-Cantor_Zavel_Kwartin_Ribono_Shel_Olam.scd b/neo-hasidic_brainsex/old/05-Cantor_Zavel_Kwartin_Ribono_Shel_Olam.scd similarity index 100% rename from neo-hasidic_brainsex/05-Cantor_Zavel_Kwartin_Ribono_Shel_Olam.scd rename to neo-hasidic_brainsex/old/05-Cantor_Zavel_Kwartin_Ribono_Shel_Olam.scd diff --git a/neo-hasidic_brainsex/06-Cantor_Zevulun_Zavel_Kwartin_sings_Tiher.scd b/neo-hasidic_brainsex/old/06-Cantor_Zevulun_Zavel_Kwartin_sings_Tiher.scd similarity index 100% rename from neo-hasidic_brainsex/06-Cantor_Zevulun_Zavel_Kwartin_sings_Tiher.scd rename to neo-hasidic_brainsex/old/06-Cantor_Zevulun_Zavel_Kwartin_sings_Tiher.scd diff --git a/neo-hasidic_brainsex/07-Izak_Algazi_Efendi_Kamti_Be_ashmoret.scd b/neo-hasidic_brainsex/old/07-Izak_Algazi_Efendi_Kamti_Be_ashmoret.scd similarity index 100% rename from neo-hasidic_brainsex/07-Izak_Algazi_Efendi_Kamti_Be_ashmoret.scd rename to neo-hasidic_brainsex/old/07-Izak_Algazi_Efendi_Kamti_Be_ashmoret.scd diff --git a/neo-hasidic_brainsex/old/almost.scd b/neo-hasidic_brainsex/old/almost.scd new file mode 100644 index 0000000..832483f --- /dev/null +++ b/neo-hasidic_brainsex/old/almost.scd @@ -0,0 +1,142 @@ +b = Buffer.read(s, "/home/lcoogan/snd/live/2025-04-26.Basic_City_Brewery/trax/01-Cantor_Samual_Malavsky_Shomea_Kol_Bichios.wav"); + +MIDIClient.init; +MIDIIn.connectAll; + + + + +( +// PV_BrickWall (CC 0-3) +SynthDef(\pv_brickwall, { |amp = 0.5, mod1 = 10, mod2 = 0.1, mod3 = 0| + var sig = PlayBuf.ar(1, b, BufRateScale.kr(b), loop: 1); + var chain = FFT(LocalBuf(2048), sig); + chain = PV_BrickWall(chain, SinOsc.ar(mod1) + SinOsc.kr(mod2)); + sig = IFFT(chain.dup); + sig = Splay.ar(sig, mod3); + // sig = FreeVerb.ar(sig, mod3, mod3); + sig = CombL.ar(sig, mod3, mod3, mod3); + Out.ar(0, sig * amp); +}).add; +) + +( +~midiControlMap = ( + 00: \amp, + 01: \mod1, + 02: \mod2, + 03: \mod3 +); + +// Your synth +~synth = Synth(\pv_brickwall, [\bufnum, b]); + +// Connect MIDI CCs on channel 2 (0-based index, so channel 2 = 1) +~midiControlMap.keysValuesDo { |cc, param| + MIDIFunc.cc({ |val, num, chan, src| + if (chan == 2) { // MIDI channel 2 + var mappedVal; + + mappedVal = case + { param == \amp } { val.linlin(0, 127, 0.0, 1.0) } + { param == \mod1 } { val.linlin(0, 127, 1.0, 20.0) } + { param == \mod2 } {val.linlin(0, 127, 1.0, 20.0) } + { param == \mod3} { val.linlin(0, 127, 0.0, 1.0) } + { val / 127 }; // default fallback + + ~synth.set(param, mappedVal); + ("CC" ++ cc ++ " (" ++ param ++ ") → " ++ mappedVal).postln; + } + }, cc); +}; +) + +( + +( +// PV_MagSmear (CC 16-19) +SynthDef(\pv_pv_magsmear, { |amp = 0.5, mod1 = 0, mod2 = 0, mod3 = 0| + var sig = PlayBuf.ar(1, b, BufRateScale.kr(b), loop: 1); + var chain = FFT(LocalBuf(1024), sig); + chain = PV_MagSmear(chain, mod1); + Out.ar(0, IFFT(chain).dup * amp); +}).add; +) + +( +~midiControlMap = ( + 04: \amp, + 05: \mod1, +); + +// Your synth +~synth = Synth(\pv_pv_magsmear, [\bufnum, b]); + +// Connect MIDI CCs on channel 2 (0-based index, so channel 2 = 1) +~midiControlMap.keysValuesDo { |cc, param| + MIDIFunc.cc({ |val, num, chan, src| + if (chan == 2) { // MIDI channel 2 + var mappedVal; + + mappedVal = case + { param == \amp } { val.linlin(0, 127, 0.0, 1.0) } + { param == \mod1 } { val.linlin(0, 127, 0.0, 40.0) } + { val / 127 }; // default fallback + + ~synth.set(param, mappedVal); + ("CC" ++ cc ++ " (" ++ param ++ ") → " ++ mappedVal).postln; + } + }, cc); +}; +) + + + + + +( +// PV_Freeze (CC 4-7) +SynthDef(\pv_freeze, { |amp = 0.5, mod1 = 10, mod2 = 0, mod3 = 0| + var sig = PlayBuf.ar(1, b, BufRateScale.kr(b), loop: 1); + var chain = FFT(LocalBuf(1024), sig); + chain = PV_Freeze(chain, SinOsc.kr(mod1) > 0.5); + Out.ar(0, IFFT(chain).dup * amp); +}).add; +) + +( +// PV_MagGate (CC 8-11) +SynthDef(\pv_pv_maggate, { |amp = 0.5, mod1 = 50, mod2 = 0.5, mod3 = 0| + var sig = PlayBuf.ar(1, b, BufRateScale.kr(b), loop: 1); + var chain = FFT(LocalBuf(1024), sig); + chain = PV_MagGate(chain, mod1, mod2); + Out.ar(0, IFFT(chain).dup * amp); +}).add; +) + +( +// PV_MagShift (CC 12-15) +SynthDef(\pv_pv_magshift, { |amp = 0.5, mod1 = 0, mod2 = 0, mod3 = 0| + var sig = PlayBuf.ar(1, b, BufRateScale.kr(b), loop: 1); + var chain = FFT(LocalBuf(1024), sig); + chain = PV_MagShift(chain, 1, mod1); + Out.ar(0, IFFT(chain).dup * amp); +}).add; +) + + + + + + + +( +// PV_RectComb (CC 20-23) +SynthDef(\pv_pv_rectcomb, { |amp = 0.5, mod1 = 0, mod2 = 0, mod3 = 0.2| + var sig = PlayBuf.ar(1, b, BufRateScale.kr(b), loop: 1); + var chain = FFT(LocalBuf(2048), sig); + chain = PV_RectComb(chain, mod1, mod2, mod3); + Out.ar(0, IFFT(chain).dup * amp); +}).add; +) + diff --git a/neo-hasidic_brainsex/old/final.scd b/neo-hasidic_brainsex/old/final.scd new file mode 100644 index 0000000..e5b928a --- /dev/null +++ b/neo-hasidic_brainsex/old/final.scd @@ -0,0 +1,96 @@ +b = Buffer.read(s, "/home/lcoogan/snd/live/2025-04-26.Basic_City_Brewery/trax/01-Cantor_Samual_Malavsky_Shomea_Kol_Bichios.wav"); +b = Buffer.read(s, "/home/lcoogan/snd/live/2025-04-26.Basic_City_Brewery/trax/06-Cantor_Zevulun_Zavel_Kwartin_sings_Tiher.wav"); +b = Buffer.read(s, "/home/lcoogan/Music/Musicians/My Bloody Valentine/Loveless/05 When You Sleep.opus"); + + +( +// PV_BrickWall +SynthDef(\pv_pv_brickwall, { + var sig = PlayBuf.ar(1, b, BufRateScale.kr(b), loop: 1); + var chain = FFT(LocalBuf(2048), sig); + chain = PV_BrickWall(chain, SinOsc.ar(10.1) + SinOsc.kr(0.1)); // 10 and 0.1 ar the inputs + Out.ar(0, IFFT(chain).dup * 0.5); +}).add; +) + +// To play: +x = Synth(\pv_pv_brickwall); // yes + + + +// Interesting resonance +( +// PV_Freeze +SynthDef(\pv_pv_freeze, { + var sig = PlayBuf.ar(1, b, BufRateScale.kr(b), loop: 1); + var chain = FFT(LocalBuf(1024), sig); + chain = PV_Freeze(chain, MouseY.kr > 0.5); // 0.5 is the input + Out.ar(0, IFFT(chain).dup * 0.5); +}).add; +) + +// To play: +x = Synth(\pv_pv_freeze); // yes + + + + +( +// PV_MagGate +SynthDef(\pv_pv_maggate, { + var sig = PlayBuf.ar(1, b, BufRateScale.kr(b), loop: 1); + var chain = FFT(LocalBuf(1024), sig); + chain = PV_MagGate(chain, MouseX.kr(0,100), MouseY.kr(0, 1)); + Out.ar(0, IFFT(chain).dup * 0.5); +}).add; +) + +// To play: +x = Synth(\pv_pv_maggate); // yes + + + +( +// PV_MagShift +SynthDef(\pv_pv_magshift, { + var sig = PlayBuf.ar(1, b, BufRateScale.kr(b), loop: 1); + var chain = FFT(LocalBuf(1024), sig); + chain = PV_MagShift(chain, 1, MouseX.kr(-128, 128) ); + Out.ar(0, IFFT(chain).dup * 0.5); +}).add; +) + +// To play: +x = Synth(\pv_pv_magshift); // yes + + + +( +// PV_MagSmear +SynthDef(\pv_pv_magsmear, { + var sig = PlayBuf.ar(1, b, BufRateScale.kr(b), loop: 1); + var chain = FFT(LocalBuf(1024), sig); + chain = PV_MagSmear(chain, MouseX.kr(0, 100)); + Out.ar(0, IFFT(chain).dup * 0.5); +}).add; +) + +// To play: +x = Synth(\pv_pv_magsmear); // yes + + + + +( +// PV_RectComb +SynthDef(\pv_pv_rectcomb, { + var sig = PlayBuf.ar(1, b, BufRateScale.kr(b), loop: 1); + var chain = FFT(LocalBuf(2048), sig); + chain = PV_RectComb(chain, MouseX.kr(0, 32), MouseY.kr, 0.2); + Out.ar(0, IFFT(chain).dup * 0.5); +}).add; +) + +// To play: +x = Synth(\pv_pv_rectcomb); // yes + diff --git a/neo-hasidic_brainsex/near.scd b/neo-hasidic_brainsex/old/near.scd similarity index 60% rename from neo-hasidic_brainsex/near.scd rename to neo-hasidic_brainsex/old/near.scd index 8c232c9..2f76296 100644 --- a/neo-hasidic_brainsex/near.scd +++ b/neo-hasidic_brainsex/old/near.scd @@ -1,21 +1,23 @@ b = Buffer.read(s, "/home/lcoogan/snd/live/2025-04-26.Basic_City_Brewery/trax/01-Cantor_Samual_Malavsky_Shomea_Kol_Bichios.wav"); +b.play; ( // PV_BrickWall (CC 0-3) -SynthDef(\pv_brickwall, { |amp = 0.5, mod1 = 10, mod2 = 0.1, mod3 = 0| +SynthDef(\pv_brickwall, { |amp = 0.5, mod1 = 10, mod2 = 0.1, mod3, mod4, mod5| var sig = PlayBuf.ar(1, b, BufRateScale.kr(b), loop: 1); var chain = FFT(LocalBuf(2048), sig); chain = PV_BrickWall(chain, SinOsc.ar(mod1) + SinOsc.kr(mod2)); + chain = PV_RectComb(chain, mod3, mod4, mod5); sig = IFFT(chain.dup); - sig = Splay.ar(sig, mod3); - sig = CombL.ar(sig, mod3, mod3, mod3); + /*sig = Splay.ar(sig, mod3); + sig = CombL.ar(sig, mod3, mod3, mod3);*/ Out.ar(0, sig * amp); }).add; -) -( + + // PV_RectComb (CC 20-23) SynthDef(\pv_rectcomb, { |amp = 0.5, mod1 = 0, mod2 = 0, mod3 = 0.2| var sig = PlayBuf.ar(1, b, BufRateScale.kr(b), loop: 1); @@ -23,9 +25,9 @@ SynthDef(\pv_rectcomb, { |amp = 0.5, mod1 = 0, mod2 = 0, mod3 = 0.2| chain = PV_RectComb(chain, mod1, mod2, mod3); Out.ar(0, IFFT(chain).dup * amp); }).add; -) -( + + // PV_MagSmear (CC 16-19) SynthDef(\pv_magsmear, { |amp = 0.5, mod1 = 0| var sig = PlayBuf.ar(1, b, BufRateScale.kr(b), loop: 1); @@ -33,9 +35,9 @@ SynthDef(\pv_magsmear, { |amp = 0.5, mod1 = 0| chain = PV_MagSmear(chain, mod1); Out.ar(0, IFFT(chain).dup * amp); }).add; -) -( + + // PV_Freeze (CC 4-7) SynthDef(\pv_freeze, { |amp = 0.5, mod1 = 10| var sig = PlayBuf.ar(1, b, BufRateScale.kr(b), loop: 1); @@ -43,9 +45,9 @@ SynthDef(\pv_freeze, { |amp = 0.5, mod1 = 10| chain = PV_Freeze(chain, SinOsc.kr(mod1) > 0.5); Out.ar(0, IFFT(chain).dup * amp); }).add; -) -( + + // PV_MagGate (CC 8-11) SynthDef(\pv_maggate, { |amp = 0.5, mod1 = 50, mod2 = 0.5, mod3 = 0| var sig = PlayBuf.ar(1, b, BufRateScale.kr(b), loop: 1); @@ -54,15 +56,15 @@ SynthDef(\pv_maggate, { |amp = 0.5, mod1 = 50, mod2 = 0.5, mod3 = 0| chain = PV_MagShift(chain, 1, mod3); Out.ar(0, IFFT(chain).dup * amp); }).add; -) -( + + // PV_MagShift (CC 12-15) SynthDef(\pv_magshift, { |amp = 0.5, mod1 = 0| var sig = PlayBuf.ar(1, b, BufRateScale.kr(b), loop: 1); var chain = FFT(LocalBuf(1024), sig); Out.ar(0, IFFT(chain).dup * amp); -}).play; +}).add; ) @@ -78,8 +80,11 @@ SynthDef(\pv_magshift, { |amp = 0.5, mod1 = 0| 00: \amp, 01: \mod1, 02: \mod2, - 03: \mod3 + 03: \mod3, + 04: \mod4, + 05: \mod5 ); + ~midiControlMap_RectComb = ( 04: \amp, 05: \mod1, @@ -100,21 +105,27 @@ SynthDef(\pv_magshift, { |amp = 0.5, mod1 = 0| 14: \mod2, 15: \mod3 ); - -// Your pv_brickwall synth -( -~synth_BrickWall = Synth(\pv_brickwall, [\bufnum, b]); -~synth_MagSmear = Synth(\pv_magsmear, [\bufnum, b]); -~synth_RectComb = Synth(\pv_rectcomb, [\bufnum, b]); -~synth_MagGate = Synth(\pv_maggate, [\bufnum, b]); ) +// // Your pv_brickwall synth +// (11 +// ~synth_BrickWall = Synth(\pv_brickwall, [\bufnum, b]); +// ~synth_MagSmear = Synth(\pv_magsmear, [\bufnum, b]); +// ~synth_RectComb = Synth(\pv_rectcomb, [\bufnum, b]); +// ~synth_MagGate = Synth(\pv_maggate, [\bufnum, b]); +// ) +// +// ~synth_BrickWall = Synth(\pv_brickwall, [\bufnum, b]); + -/*s.bind { +( +s.bind { ~synth_BrickWall = Synth(\pv_brickwall, [\bufnum, b]); - ~synth_MagSmear = Synth(\pv_pv_magsmear, [\bufnum, b]); // Check name + ~synth_MagSmear = Synth(\pv_magsmear, [\bufnum, b]); // Check name ~synth_RectComb = Synth(\pv_rectcomb, [\bufnum, b]); // Make sure this SynthDef exists -};*/ + ~synth_MagGate = Synth(\pv_maggate, [\bufnum, b]); +}; +) @@ -129,6 +140,8 @@ SynthDef(\pv_magshift, { |amp = 0.5, mod1 = 0| { param == \mod1 } { val.linlin(0, 127, 1.0, 20.0) } { param == \mod2 } { val.linlin(0, 127, 1.0, 20.0) } { param == \mod3} { val.linlin(0, 127, 0.0, 1.0) } + /* { param == \mod4} { val.linlin(0, 127, 0.0, 1.0) } + { param == \mod5} { val.linlin(0, 127, 0.0, 1.0) }*/ { val / 127 }; // default fallback ~synth_BrickWall.set(param, mappedVal); ("CC" ++ cc ++ " (" ++ param ++ ") → " ++ mappedVal).postln; @@ -137,51 +150,51 @@ SynthDef(\pv_magshift, { |amp = 0.5, mod1 = 0| }; -// Connect MIDI CCs for pv_brickwall - ~midiControlMap_RectComb.keysValuesDo { |cc, param| - MIDIFunc.cc({ |val, num, chan, src| - if (chan == 2) { // MIDI channel 2 - var mappedVal; - mappedVal = case - { param == \amp } { val.linlin(0, 127, 0.0, 1.0) } - { param == \mod1 } { val.linlin(0, 127, 1.0, 20.0) } - { param == \mod2 } { val.linlin(0, 127, 1.0, 20.0) } - { param == \mod3} { val.linlin(0, 127, 0.0, 1.0) } - { val / 127 }; // default fallback - ~synth_RectComb.set(param, mappedVal); - ("CC" ++ cc ++ " (" ++ param ++ ") → " ++ mappedVal).postln; - } - }, cc); +// // Connect MIDI CCs for pv_brickwall +~midiControlMap_RectComb.keysValuesDo { |cc, param| + MIDIFunc.cc({ |val, num, chan, src| + if (chan == 2) { // MIDI channel 2 + var mappedVal; + mappedVal = case + { param == \amp } { val.linlin(0, 127, 0.0, 1.0) } + { param == \mod1 } { val.linlin(0, 127, 1.0, 20.0) } + { param == \mod2 } { val.linlin(0, 127, 1.0, 20.0) } + { param == \mod3} { val.linlin(0, 127, 0.0, 1.0) } + { val / 127 }; // default fallback + ~synth_RectComb.set(param, mappedVal); + ("CC" ++ cc ++ " (" ++ param ++ ") → " ++ mappedVal).postln; + } + }, cc); }; // Connect MIDI CCs for pv_pv_magsmear ~midiControlMap_MagSmear.keysValuesDo { |cc, param| - MIDIFunc.cc({ |val, num, chan, src| - if (chan == 2) { // MIDI channel 2 - var mappedVal; - mappedVal = case - { param == \amp } { val.linlin(0, 127, 0.0, 1.0) } - { param == \mod1 } { val.linlin(0, 127, 0.0, 40.0) } - { val / 127 }; // default fallback - ~synth_MagSmear.set(param, mappedVal); - ("CC" ++ cc ++ " (" ++ param ++ ") → " ++ mappedVal).postln; - } - }, cc); + MIDIFunc.cc({ |val, num, chan, src| + if (chan == 2) { // MIDI channel 2 + var mappedVal; + mappedVal = case + { param == \amp } { val.linlin(0, 127, 0.0, 1.0) } + { param == \mod1 } { val.linlin(0, 127, 0.0, 40.0) } + { val / 127 }; // default fallback + ~synth_MagSmear.set(param, mappedVal); + ("CC" ++ cc ++ " (" ++ param ++ ") → " ++ mappedVal).postln; + } + }, cc); }; ~midiControlMap_MagGate.keysValuesDo { |cc, param| - MIDIFunc.cc({ |val, num, chan, src| - if (chan == 2) { // MIDI channel 2 - var mappedVal; - mappedVal = case - { param == \amp } { val.linlin(0, 127, 0.0, 1.0) } - { param == \mod1 } { val.linlin(0, 127, 0.0, 40.0) } - { val / 127 }; // default fallback - ~synth_MagGate.set(param, mappedVal); - ("CC" ++ cc ++ " (" ++ param ++ ") → " ++ mappedVal).postln; - } - }, cc); + MIDIFunc.cc({ |val, num, chan, src| + if (chan == 2) { // MIDI channel 2 + var mappedVal; + mappedVal = case + { param == \amp } { val.linlin(0, 127, 0.0, 1.0) } + { param == \mod1 } { val.linlin(0, 127, 0.0, 40.0) } + { val / 127 }; // default fallback + ~synth_MagGate.set(param, mappedVal); + ("CC" ++ cc ++ " (" ++ param ++ ") → " ++ mappedVal).postln; + } + }, cc); }; ) diff --git a/neo-hasidic_brainsex/revised spectral.scd b/neo-hasidic_brainsex/old/revised spectral.scd similarity index 100% rename from neo-hasidic_brainsex/revised spectral.scd rename to neo-hasidic_brainsex/old/revised spectral.scd