Radio Bursts ad alta energia, generati da una vecchia macchinetta del caffè di origine araba, si manifestano come rumore e segnali audio, e scatenano un'alterazione magnetica dagli effetti imprevedibili;



(
{
var trigger, fund, flashInst;
flashInst = Array.fill(7,
{
trigger = Dust.kr(2)*PinkNoise.ar(1);
fund = rrand(100, 137);
Pan2.ar(
Mix.ar(
Array.fill(7,
{arg counter;
var partial;
partial = counter + 3;
//HenonC.ar(fund*partial).atan *
DPW3Tri.ar(fund*partial).atan *
EnvGen.kr(Env.adsr(0.01, 0, 0.1, 7.0),
trigger, 1/partial) *AY.ar(713)* max(0, LFNoise1.kr(rrand(37.0, 73.0)))
})
)*0.2,
1.0.rand2)
});
Mix.ar(flashInst)*0.6
}.play
)




"Questo mondo è solo un sogno creato dall'esercito delle farfalle? E del quale anche loro fanno parte? Oppure le farfalle sono vere, e questo è stato soltanto un incubo da cui non riesco a svegliarmi?"



(
{
var trigger, fund;
trigger = Dust.kr(3/7);
fund = rrand(100, 137);
Mix.ar(
Array.fill(17,
{arg counter;
var partial;
partial = counter + 1;
Pan2.ar(
Saw.ar(fund*partial) *
EnvGen.kr(Env.adsr(0, 0, 1.0, 5.0),
trigger, 1/partial
) * max(0, LFNoise1.kr(rrand(37.0, 73.0))), 1.0.rand2)
})
)*0.5 //overall volume
}.play
)




"Era molto tozzo e panciuto, la sua testa era più simile a un rospo mostruoso di una divinità, e tutto il suo corpo era coperto con un’ imitazione di pelliccia, dandogli in qualche modo una vaga somiglianza sia a un pipistrello che a un bradipo. Le sue palpebre assonnate erano mezzo abbassate sugli occhi globulari; e la punta di una lingua strana spiccava dalla sua grassa bocca."

s.quit;
s.options.memSize = 65536;  // e.g., could be different for you
s.boot;

(
SynthDef(\thecroaking, {|out, sig, gate=1, freq=440|
 // doneAction: 2 rilascia la synth quando EvnGen ha finito
    sig = (AY.ar(freq)*0.7+AY.ar(freq/3+Rand(1,7))*0.7)
*EnvGen.kr(Env.asr(0.1, 0.3, 0.7), gate, doneAction:2);
    sig = sig*Blip.ar(freq/2)*1.3;
    sig = RLPF.ar(sig,SinOsc.kr(0.3, 0, 200, 500), 0.1);
    sig = FreeVerb.ar(sig, 0.5, 0.5, 0.5);
    Out.ar(out, sig);

}).add;
)

(
Pbind(
    \instrument, \thecroaking,
    \freq, Pseq([113,73,Prand([137, 173, 713],1)], inf),
    \legato, Pseq([1.7, 0.3], inf),
    \dur, Prand([0.2, 0.4, 0.8], inf),
    \out, Pseq([1, 0], inf)
).play;
)



«Che cosa sia, Dio solo lo sa. In termini di materia suppongo che la cosa sia un gas, ma obbediente a leggi che non sono quelle del nostro cosmo; non è il frutto dei pianeti o dei soli che splendono nei telescopi […] non è un soffio dei cieli di cui i nostri astronomi misurano i moti e le dimensioni […] era soltanto un colore venuto dallo spazio, messaggero spaventoso degli informi reami dell’infinito, al di là della natura che conosciamo.»

rielaborazione di
http://sccode.org/1-4QT

(
    var durata;

    {
        SynthDef(\TheColourOutofSpace, {|durata = 317|
            //Sines
            var discesa = Line.kr(337, 137, durata);
            var salita = Line.kr(137, 317, durata);
            var signals = SinOsc.ar(discesa) * SinOsc.ar(salita);
            //Filter
            var filterLineLFO = SinOsc.ar(0.3);
            var filterLine = Line.kr(137, 7137, durata, doneAction: 2) * filterLineLFO;
            var filtLFO = SinOsc.kr(0.3).range(73, filterLine);
            var filter = BMoog.ar(signals, filtLFO, 0.7, 1).acos * 0.7;
            //Comb
            var comb = CombL.ar(filter, 1, 0.3, 1);
            var mix1 = (comb + GVerb.ar(filter)) * 0.1;
            mix1 = (CombL.ar(mix1, 1, 1, 7) * 0.3) + mix1;
            mix1 = HPF.ar(mix1, 17) * 0.7;
            Out.ar(0, mix1);
        }).add;

        s.sync;

        durata = 317; Synth(\TheColourOutofSpace, [\durata, durata]);
    }.fork
)




È la mancanza di contatto visivo a farci diventare più idioti, al punto che i piloti delle decappottabili danno meno in escandescenze. Chiusi nell'auto, spiegano gli psicologi, regrediamo all'infanzia e reagiamo gridando, o con quel surrogato dell'urto che è il clacson.

(
SynthDef(\madtraffic, {|out, sig, gate=1, freq=440|
 // doneAction: 2 rilascia la synth quando EvnGen ha finito
    sig = (Blip.ar(freq)*0.7+Blip.ar(freq/2+Rand(1,12))*0.7)
*EnvGen.kr(Env.asr(0.1, 0.3, 0.3), gate, doneAction:2);
    sig = RLPF.ar(sig,SinOsc.kr(0.3, 0, 200, 1500), 0.1);
    sig = FreeVerb.ar(sig, 0.5, 0.5, 0.5);
    Out.ar(out, sig);

}).add;
)

(
Pbind(
    \instrument, \madtraffic,
    \freq, Pseq([137, 373, Prand([237, 473, 713],1)], inf),
    \legato, Pseq([1.7, 0.3], inf),
    \dur, 0.3,
    \out, Pseq([1, 0], inf)
).play;
)



Rielaborazioni varie

I Pirati delle Navi Rosse attaccarono nella notte, uccidendo o prendendo in ostaggio la maggior parte della popolazione. Una nota di riscatto giunta alla Rocca di Castelcervo chiedeva oro, sotto la minaccia di rilasciare gli ostaggi. Re Sagace trovò che non avesse senso, e rifiutò di pagare. I pirati misero in pratica la minaccia, rilasciando gli ostaggi all'apparenza incolumi e facendo vela nella notte. Ma fu subito chiaro che, per una magia arcana, gli abitanti del villaggio erano fuori di senno.

(
{
Klank.ar(
`[[100, 200, 300, 400, 500, 600, 700, 800, 900, 1000], //freq array
[0.05, 0.2, 0.04, 0.06, 0.11, 0.01, 0.15, 0.03, 0.15, 0.2]],
PinkNoise.ar(LFTri.kr(0.07, 0.07, 0.07))).dup
}.play
)

Klank.ar(specificationsArrayRef, input, freqscale, freqoffset, decayscale)
Klank is a bank of fixed frequency resonators which can be used to simulate the resonant modes of an object. Each mode is given a ring time, which is the time for the mode to decay by 60 dB.



{ Klank.ar(`[[800, 1071, 1353, 1723], nil, [1, 1, 1, 1]], PinkNoise.ar(0.007)).dup }.play;

(
play({
        Klank.ar(`[
                Array.rand(12, 800.0, 4000.0), // frequencies
                nil,  // amplitudes (default to 1.0)
                Array.rand(12, 0.1, 2)  // ring times
                ], Decay.ar(Impulse.ar(4), 0.03, 0.01)).dup
})
)



(
{
var harmonics = 16;
Mix.fill(harmonics,
{ arg count;
Pan2.ar(
FSinOsc.ar(
exprand(100, 2000),
mul: max(0, FSinOsc.kr(rrand(1/3, 1/6))*rrand(0.1, 0.9))),
1.0.rand2)
}
) / (2*harmonics)
}.play;
)

(
{
var dur = 6, base, aenv, fenv, out, trig;
base = Rand(40, 100);
trig = SinOsc.ar(1/10);
out = Mix.fill(15,{
var thisDur;
thisDur = dur * rrand(0.5, 1.0);
aenv = EnvGen.kr(Env.perc(0, thisDur), trig);
fenv = EnvGen.kr(Env.new([0, 0, 1, 0], [0.25*thisDur, 0.75*thisDur, 0]), trig);
Pan2.ar(SinOsc.ar( Rand(base, base * 12) * LFNoise1.kr(10, mul: 0.02 * fenv, add: 1), // freq
mul: aenv // amp
), ([1, -1].choose) * fenv)
}) * 0.05;
}.play(s);
{
var dur = 6, base, aenv, fenv, out, trig, detune;
base = Rand(40, 60);
detune = 0.1; // increase this number to detune the second bell
trig = SinOsc.ar(1/10, pi);
out = Mix.fill(15,
{ arg count;
var thisDur;
thisDur = dur * rrand(0.5, 1.0);
aenv = EnvGen.kr(Env.perc(0, thisDur), trig);
fenv = EnvGen.kr(Env.new([1, 1, 0, 1], [0.05*thisDur, 0.95*thisDur, 0]), trig);
Pan2.ar(SinOsc.ar( base*(count+1+ detune.rand) *
LFNoise1.kr(10, mul: 0.02 * fenv, add: 1), // freq
mul: aenv // amp
), ([1, -1].choose) * fenv)
}) * 0.05;
}.play(s);
)




"Qui svolazzava ritmicamente un'orda addomesticata di ibridi esseri alati [...] non si trattava esattamente di corvi, né di talpe, né di poiane, né di formiche, e nemmeno di esseri umani decomposti, ma erano un qualcosa che non posso e non devo ricordare." H. P. Lovecraft, Il Festival

[esempio trovato su SuperCollider Code e rielaborato]

(
SynthDef("pulse",{ arg freq,delayTime,amp = 1.0,attack = 0.01;
        var out,out2,env;
        env = EnvGen.kr(Env.perc(attack, 1, 5, 10),doneAction: 2);
        z = SinOsc.ar(freq,0,0.7);
        a = Pan2.ar(ToggleFF.ar(TDelay.ar(z,delayTime)) * SinOsc.ar(freq),
                 SinOsc.kr(3,0), 0.6);
        out = Pan2.ar(z, SinOsc.kr(5,1.0pi),0.7 ) + a;
        out = out * env;
        out = out.clip2(1);

        Out.ar(0,FreeVerb.ar(out,0.7,1.0,0.4, amp));
}).send(s);
)
(


SynthDef("droneee", { arg freq = 440, amp = 1.0, outbus = 0, phase = 0;
        var out, env;
        env = EnvGen.kr(Env.sine(10),doneAction: 2);
        out = LFPulse.ar(freq , 0.15);
        out = RLPF.ar(out,SinOsc.kr(0.3, 0, 200, 1500), 0.1);
        out = FreeVerb.ar(out, 0.5, 0.5, 0.5) * env;
        out = Pan2.ar(out, SinOsc.kr(1/10, phase),amp);

    Out.ar(outbus, out);
}).send(s);)

(
SynthDef("bass",{
        arg freq,amp,outbus=0;
        var env,out;
        out = SinOsc.ar(freq,0,amp);
        env = EnvGen.kr(Env.perc(0.5,1,1,0),doneAction: 2);
        out = out*env;
        out = Pan2.ar(out,0);
        Out.ar(outbus,out);


}).send(s);

)
 (

p = Prand( [61,77, 37,63,67,71], inf).asStream;
q = Prand( [3,0.7,1.3,0.7], inf ).asStream;
e = Prand([37,73,71,77,81,88,90],inf).asStream;

t = Task({
                inf.do({

                if( 0.1.coin, {
                        Synth("pulse",
                             [\freq,e.value.midicps,
                              \amp,0.07.rand +0.2,
                              \attack,7.0.rand,
                                    \delayTime, 0.02;
                                    ]);
                   });


                Synth("droneee",
                       [\outBus,0,
                        \freq, p.value.midicps,
                        \amp, (0.02.rand2 + 0.05) * 0.7,
                        \phase,[0,1.5pi].wchoose([0.5,0.5]);
                        ]);
                q.value.wait;

                Synth("bass",[\freq,p.value.midicps,\amp,0.3]);

                    });
});

t.start;


)





Nel libro SnowCrash, Neal Stephenson definisce il Nam Shub of Enki come un Linguaggio di Programmazione per il subconscio umano.

(
SynthDef(\snowcrash, {|out, gate=1, freq=440|
    // doneAction: 2 rilascia la synth quando EvnGen ha finito
Out.ar(out, (PinkNoise.ar(freq/2)*0.02*Saw.ar(freq) * EnvGen.kr(Env.asr(0.1, 0.3, 7.3), gate, doneAction:2)));
}).add;
)


(
Pbind(
    \instrument, \snowcrash,
    \freq, Pseq([137, 373, Prand([237, 473, 713],1)], inf),
    \legato, Pseq([1.7, 0.3], inf),
    \dur, 0.3,
    \out, Pseq([1, 0], inf)
).play;
)






"buio, pareti fredde, metallo, passi confusi in un labirinto di paura; precipitare in un abisso oscuro? Oppure continuare a camminare incerto sulla lama del rasoio? Vivo come un acrobata e danzo lentamente sul filo; mi trovo sulla lama del rasoio e inizio a avvertire brividi di piacere."

Non ritrovo come lho fatto;







Captate misteriose onde radio provenienti dalle profondità dell'Universo. Da dove provengono? Chi o cosa le ha prodotte? Sette anni fa, una singola raffica di onde radio di origine sconosciuta fu riconosciuta come proveniente dal di fuori della nostra galassia, un segnale dallo spazio esterno generato a miliardi di anni luce di distanza che ha viaggiato attraverso le profondità del cosmo ed è arrivato qui, sulla Terra.

(
{var frequency;
Mix.ar({
frequency = rrand(100, 300);
Pan2.ar(SinOsc.ar(frequency,
mul: EnvGen.kr(Env.perc(0.001, frequency/100),
Dust.kr(0.05), 0.2)), rrand(-1.0, 1.0)) }.dup(100))}.play
)

un Mix di 100 oscillatori sinusoidali, modulati in ampiezza da Envelope percussivi innescati da impulsi (Dust) random e pannati randomicamente;

rrand(24, 48)   // distribuzione lineare nel range indicato

audacity effect

reverse
vocoder
equalization high+ , bass-




(
var songLength = 60;
{
        //Sines
        var sineLine1 = Line.kr(600, 210, songLength);
        var sineLine2 = Line.kr(100, 210, songLength);
        var sines = SinOsc.ar(sineLine1) * SinOsc.ar(sineLine2); (questo è un Ring Mode?)
        //Filter
        var filterLineLFO = SinOsc.ar(0.2); (questo è un LFO, frequenza 0.2)
        var filterLine = Line.kr(200, 6000, songLength, doneAction: 2) * filterLineLFO; (qui sto moltiplicando l'LFO per un crescendo lineare, quindi una sinusoide che cresce in ampiezza)
        var filtLFO = SinOsc.kr(0.4).range(60, filterLine); (un altro LFO 0.4hz, range scala l'output nel range definito da lo e hi)
        var filter = BMoog.ar(sines, filtLFO, 0.9, 1).tanh * 0.5; (che va a modulare la freq di cutoff del filtro)
        //Comb
        var comb = CombL.ar(filter, 1, 0.3, 1); (effetto tipo il delay)
        var mix1 = (comb + GVerb.ar(filter)) * 0.1; (+ reverbero)
        mix1 = (CombL.ar(mix1, 1, 1, 6) * 0.3) + mix1; (altro delay?)
        HPF.ar(mix1, 100) * 0.5; (filtro passa alto a freq 100hz, toglie le basse frequenze)
}.play
)

tanh = tangente iperbolica

(
z = {
    var sig, freq;
    freq = MouseX.kr(20,12000,\exponential);
    sig = BMoog.ar(
        LFSaw.ar([freq * 0.99, freq * 1.01], 0, 0.1) ! 2,
        SinOsc.kr(SinOsc.kr(0.1),1.5pi,1550,1800),
        MouseY.kr(1,0,\linear),
        0);    // filter mode - lowpass
     (CombN.ar(sig, 0.4, [0.4,0.35],2) * 0.4) + (sig * 0.5);
}.play)
z.release

ar

SinOsc.ar
BMoog.ar
CombL.ar
HPF.ar

kr

Line.kr
SinOsc.kr

Bmoog

ar (in, freq: 440, q: 0.2, mode: 0, saturation: 0.95, mul: 1, add: 0)
Arguments:
in
input signal to be processed
freq
cutoff frequency
q
bandwidth / cutoffFreq. 0 < q > 1
mode
filter mode:
< 1 low pass filter
< 2 high pass filter
< 3 bandpass filter
defaults to lowpass.




Joshua: Volgiamo fare una partita?.
Jennifer: [Ridacchiando] Sentiva la mancanza di Falken.
David: Già.[Digitando sulla tastiera] Si, volentieri. Ti andrebbe Guerra Termonucleare Globale?
Joshua: Non preferirebbe una bella partita a scacchi?
David: Dopo, Giochiamo alla Guerra Termonucleare Globale.

(
{
var triggerSpeed, trigger;
triggerSpeed = 0.1;
trigger = Impulse.kr(triggerSpeed);
Pan2.ar(LFNoise0.ar(
TRand.kr(100, 1000, trigger),
mul: EnvGen.kr(
Env.perc(0.001, 3/triggerSpeed),
trigger
)
),0)
}.play
)


(
{
Pan2.ar(SinOsc.ar(SinOsc.ar(4/10, mul: 100, add: 1000), mul: 0.1) +
SinOsc.ar(SinOsc.ar(2/10, mul: 100, add: 1000), mul: 0.1) +
SinOsc.ar(SinOsc.ar(5/10, mul: 100, add: 1000), mul: 0.1),0)
}.play
)

2 suoni;

1) il trigger che è un Impulse.kr(0.1Hz, 1 volta ogni 10 sec) innesca il TRand.kr che produce una frequenza da 100 a 1000Hz randomicamente per il LFNoise0.ar, rumore la cui ampiezza ha un Envelopment percussivo con attacco istantaneo e un release di 3/0.1 secondi;

2) il secondo suono è creato dalla somma di 3 Sinusoidi modulate in frequenza da altre Sinusoidi a diverse frequenze, che da vita a interferenze costruttive e distruttive;

TRand           generatore di numeri casuali a innesco

TRand.kr(lo, hi, trig)
TRand.ar(lo, hi, trig)

Genera un valore float casuale nella distribuzione uniforme da lo a hi
ogni volta che il trigger passa da valori non positivi a valori positivi


Impulse     oscillatore a impulsi

Impulse.ar(freq, phase, mul, add)

genera un singolo campio di impulsi a banda non limitata.
freq - frequenza in Hertz
phase - offset di fase in cicli ( 0..1 )





"Erano creature di un colore tendente al rosa, lunghe circa un metro e mezzo; il loro corpo, avvolto in un involucro da crostaceo, era dotato di un paio di grandi pinne o ali membranose dorsali, e di diversi gruppi di membra articolate; una specie di ellissoide ricoperto da una moltitudine di brevi antenne teneva il posto della testa." H. P. Lovecraft, Colui che sussurrava nel buio

play({RLPF.ar(Dust.ar([12, 15]), LFNoise1.ar(1/[3, 4], 1500, 1600), 0.02)})

Un filtro risonante passa basso attraverso il quale vengono fatti passare due treni di impulsi random (Dust, il parametro density è il valor medio di impulsi al secondo); la frequenza del filtro è modulata tramite 2 UGen di tipo LFNoise, mentre il parametro della risonanza è impostato a 0.02;

(
{
GVerb.ar((
{
var burstEnv, att = 0, dec = 0.001;
var burst, delayTime, delayDecay = 0.5;
var midiPitch = 69; // A 440
delayTime = midiPitch.midicps.reciprocal;

burstEnv = EnvGen.kr(Env.perc(att, dec), gate: Impulse.kr(1/delayDecay));
burst = PinkNoise.ar(burstEnv);
CombL.ar(burst, delayTime, delayTime,delayDecay, add: burst);
}
),270,30,0.7,drylevel:0.5)
}.play
)

Viene costruito un Envelope di tipo percussivo, attack a 0 e decay a 0.001 con un gate di impulsi (2 al secondo); questo Envelope va a sagomare l'ampiezza di un segnale PinkNoise; il tutto viene dato in pasto a questa UGen CombL, una echo chamber :

viene inviato l'impulso rumoroso attraverso una camera di eco; CombL, che ha questi argomenti : in, maxdelaytime, delayTime, decayTime, mul, add. L'input sarà l'impulso rumoroso che abbiamo appena creato. Il delaytime e il maxdelaytime rappresentano quantità di tempo, in secondi, e indicano quanto il segnale viene ritardato (l'eco). Il tempo di decadimento è il tempo necessario per la scomparsa dell'eco. La frequenza del gate è impostata sul reciproco del  delayDecay in modo che un nuovo impulso inneschi un altro burst di rumore quando il precedente si è spento.



un mix di 5 SinOsc pannati random e modulati da LFO sinusoidali

(
{
Mix.ar(
Array.fill(5, // not too many values, could crash
{Pan2.ar(
SinOsc.ar(SinOsc.ar(1/10, rrand(0, 6.0), 200, 500)),
1.0.rand)}
)
)*0.02
}.play
)


(
{
var trig, out, delay;
trig = Impulse.kr(6); // trigger rate
out = Blip.ar(
TRand.kr(48, 72, trig).midicps, // range, in midi, of pitches
TRand.kr(1, 12, trig), // range of timbre
max(0, TRand.kr(-0.5, 0.4, trig)) // amplitudes
);
out = Pan2.ar(out, TRand.kr(-1.0, 1.0, trig));
out = out*EnvGen.kr(Env.perc(0, 1), trig);
out = Mix.ar({out}.dup(6))*0.2;
delay = CombL.ar(out, 2.0, 4/6, 6);
out + delay
}.play
)


Blip         generatore di impulsi a banda limitata

Blip.ar(freq, numharm, mul, add)

TRand        generatore di numeri random a innesco

TRand.kr(lo, hi, trig)
TRand.ar(lo, hi, trig)

Genera un valore float casuale nella distribuzione uniforme da lo a hi
ogni volta che il trigger passa da valori non positivi a valori positivi

EnvGen              generatore di evelope

Inherits from: Object : AbstractFunction : UGen

Gli envelope sono istanze della classe Env. Vedi la classe Env per maggiori informazioni. Gli argomenti levelScale, levelBias e timeScale vengono sottoposti a polling quando EnvGen viene attivato e rimangono costanti per tutta la durata dell'envelope.
   
*ar(envelope, gate, levelScale, levelBias, timeScale, doneAction)
*kr(envelope, gate, levelScale, levelBias, timeScale, doneAction)

*perc(attackTime, releaseTime, peakLevel, curve)

Crea un nuovo envelope che generalmente ha una forma percussiva;

attackTime - la durata dell'attack.
releaseTime - la durata del release.
peakLevel - il peak level dell'envelope.
curve - la curvatura dell'envelope.
 
Env.perc(0.05, 1, 1, -4).test.plot;
Env.perc(0.001, 1, 1, -4).test.plot;    // sharper attack
Env.perc(0.001, 1, 1, -8).test.plot;    // change curvature
Env.perc(1, 0.01, 1, 4).test.plot;  // reverse envelope


(
// a SynthDef
SynthDef(\bz, { | out, freq = 440, amp = 0.1, nharms = 3, pan = 0, gate = 1 |
    var audio = Blip.ar(XLine.kr(freq, 200,6), Line.kr(1,nharms,0.5), amp);
    var env = Linen.kr(gate, doneAction: 2);
    OffsetOut.ar(out, Pan2.ar(audio, pan, env) );
}).add;
)

Pbind(\instrument, \bz, \freq, Prand([1, 1.2, 2, 2.5, 3, 4], inf) * 200, \dur, 0.1, \nharms, Prand([1, 3, 10], inf, \pan, Prand([-1,0,1], inf)) ).play;

Blip

è un generatore di impulsi a banda limitata dove tutte le armoniche hanno stessa ampiezza; i parametri sono la frequenza, il numero di armoniche e poi mul e add;

Linen

è un generatore semplice di envelope

kr(gate: 1, attackTime: 0.01, susLevel: 1, releaseTime: 1, doneAction: 0)

Pbind

Un pattern di eventi, Pbind, mette in relazione eventi con pattern di dati, e può essere eseguito. Ne consegue una notazione estremamente compatta ed elegante per la specifica di flussi di eventi sonori


s.boot;

(
var res = 20, scrsize = 200, val, set, win, scr, currentColor = Color.gray, setColor;

SynthDef(\sinbz, { |out, freq = 800, pan = 1|

    var snd;
    snd = SinOsc.ar(freq,0,0.5);
    Out.ar(out, Pan2.ar(snd, pan , \amp.kr(0.1)));
}).add;

SynthDef(\sawbz, { |out, freq = 800, pan = 1|

    var snd;
    snd = Saw.ar(freq,1);
    Out.ar(out, Pan2.ar(snd, pan , \amp.kr(0.1)));
}).add;


x = Synth(\sinbz, [freq: 440]);
y = Synth(\sawbz, [freq: 220]);

win = Window.new("Bz Synth",Rect(400, 400, 2*scrsize+20, scrsize),false).front;

//win.view.background_(Color.white);

scr = UserView.new(win,Rect(scrsize+20, 0, scrsize, scrsize));
scr.background_(Color.white);

setColor = {|x, y, val, postVal=false|
    //x = x/scrsize;
    //y = y/scrsize;

    currentColor = Color.hsv(min(0.999, x), min(0.999, 1-y), val, 1);
    postVal.if{
//        ("Color.hsv("++(x)++", "++(1-y)++", "++val.value++", 1)").postln;
        "Color.new255(%, %, %)".format(*(currentColor.asArray*255)).postln;
    };

    scr.background_(
        Color.hsv(min(0.999, x), min(0.999, 1-y), val.value, 1)
    );
};

val = Slider(win, Rect(scrsize, 0, 20, scrsize)).value_(1).action_({|view|
    setColor.(m.x.postln, m.y, view.value);
    val.value.postln;
    x.set(\freq, val.value * 400);
    win.refresh
});

m = Slider2D(win, Rect(0, 0, scrsize, scrsize))
    .mouseDownAction_({|view|
        setColor.(view.x, view.y, val.value);
        win.refresh
    })
    .mouseMoveAction_({|view|
        setColor.(view.x, view.y, val.value);
    x.set(\pan, (view.x*(-2)) + 1);
    y.set(\freq, view.y * 400);
        view.x.postln;
        win.refresh
    }).mouseUpAction_({|view|
        setColor.(view.x, view.y, val.value, true);
        win.refresh
    });

win.front;
)





























(
 {
 var freq;
         freq = MouseY.kr(4000, 200, 'exponential', 0.1);
         SinOsc.ar(freq+(freq*SinOsc.ar(7,0,0.02)), 0, MouseX.kr(0, 0.9)
         )!2
 }.play
)

la variabile freq viene generata dal mouse, dal movimento verticale, da 4000 a 200, seguendo un andamento esponenziale, il lag (nel nostro caso 0.1) è il fattore di ritardo del movimento del mouse; più è alto è il lag e più in questo caso il pitch del suono si muoverà lentamente da un valore all'altro rispetto al movimento del mouse;

il volume del segnale sinusoidale è modulato dal movimento orizzontale del mouse; il segnale sinusoidale oscillerà alla frequeza di freq+(freq*SinOsc.ar(7,0,0,02)), per l'effetto vibrato del suono;





Out of memory (OOM) is an often undesired state of computer operation where no additional memory can be allocated for use by programs or the operating system. Such a system will be unable to load any additional programs, and since many programs may load additional data into memory during execution, these will cease to function correctly. This usually occurs because all available memory, including disk swap space, has been allocated.





Il delirium tremens (DTS) è uno stato confusionale di rapida insorgenza che di solito è causato dall'astinenza da alcool in soggetti affetti da alcolismo cronico. Se si verifica, avviene circa dopo tre giorni dall'inizio dell'astinenza e si protrae per due o tre giorni. Le persone colpite possono anche essere vittime di allucinazioni.[1] Gli effetti fisici possono includere tremore, brividi, battito cardiaco irregolare e sudorazione.In casi più rari si può verificare una ipertermia o un attacco epilettico, che possono portare alla morte. L'astinenza da alcol è una delle condizioni più pericolose tra le astinenze dalle varie droghe.




La sintesi granulare è spesso basata sullo stesso principio del campionamento ma include anche tecnologie di tipo analogico. L'idea è quella di creare suoni complessi a partire da una grossa quantità di suoni semplici. I grani sono di durata compresa tra 1 e 50 millisecondi e possono essere combinati e riprodotti insieme a velocità, fase e volume variabili. Il risultato non è un unico tono, ma una nuvola di suoni che viene manipolata in maniera differente da qualsiasi altro suono naturale o da qualsiasi altro metodo di sintesi.

Rielaborazione di un tutorial :

(
SynthDef(\sinegrain, {arg pan, freq, amp; var grain;
grain= SinOsc.ar(freq, 0, amp)*(XLine.kr(1.001,0.001,0.1,doneAction:2)-0.001);
XLine genera una curva esponenziale di durata dur, in questo caso 0.1, tra il valore start e il valore end;
Out.ar(0,Pan2.ar(grain, pan))}).add;
)
Synth(\sinegrain,[\freq,rrand(100,10000),\amp, exprand(0.05,0.1), \pan, 1.0.rand2]);
exprand è valore float randomico in una distribuzione esponenziale tra hi e lo; rand2 tra -this e this.
//schedule 100 random grains over 1 second
(
{
2000.do{arg i;
        Synth(\sinegrain,[\freq,rrand(50,50+i*2),\amp, exprand(0.05,0.1), \pan, 1.0.rand2]);
        0.01.wait
};
}.fork
)
(
SynthDef("bat", {
        var sig, resfreq;    
        sig = Pan2.ar(SinOsc.ar(540,0),-1) + Pan2.ar(SinOsc.ar(547,0),1);
        Out.ar(0, sig);
}).play;
)

I toni binaurali sono dei battimenti che vengono generati direttamente dal cervello quando le due onde sonore vengono ascoltate separatamente tramite degli auricolari (quindi non vi è sovrapposizione fisica delle due onde sonore). I toni binaurali, (o battiti binaurali dall'inglese binaural beats), sono dei battimenti che vengono percepiti dal cervello quando due suoni con frequenza inferiore ai 1500 Hz e con differenza inferiore ai 30 Hz vengono ascoltati separatamente attraverso degli auricolari. È importante precisare che tali battimenti non sono conseguenza, come normalmente accade, di una sovrapposizione fisica delle onde sonore (cosa impossibile utilizzando degli auricolari), ma vengono generati direttamente nel cervello. Il fenomeno è stato identificato nel 1839 da Heinrich Wilhelm Dove.

Gli stadi principali dell'attività elettrica corticale del nostro cervello possono essere riassunti così:

- Beta (13 - 30 Hz)
Le onde beta, sono proprie delle normali attività di veglia o fase REM del sonno, indicano che la corteccia cerebrale è attivata;

- Alpha (8 – 13 Hz)
Le onde alpha o alfa sono associate a uno stato di veglia ma rilassata. La mente è calma e ricettiva. E’ lo stato ideale per lo studio o la meditazione;

- Theta (4 - 8 Hz)
Le onde theta sono tipiche di uno stato meditativo profondo e/o in alcuni stati di sonno. In questo intervallo di frequenze l’individuo è concentrato sugli stimoli interni e l’interazione tra i due emisferi cerebrali è elevata. Questa fase è tipica del dormi/veglia;

- Delta (0,5 - 4 Hz)
Il ritmo delta è molto lento ed è caratteristico del sonno profondo e del coma.

Le onde Gamma sono rare e relative a frequenze superiori ai 30 Hz nel range 30-90 Hz e sono tipiche degli stati di meditazione e di grande energia, sono correlate con la volontà e i profondi poteri psichici.

E' difficile stabilire in che condizione si trovi il cervello; ma, si puo' supporre che, durante il giorno, si emettano, solitamente, delle onde Beta (20Hz); quindi, potrete iniziare da quella frequenza, per poi aumentarla, verso l'alto, o diminuirla, verso il basso. Se, invece, la situazione neuro-cerebrale e' piu' rilassata, iniziate pure da 15Hz, o, meno; e viceversa.

Già nelle missioni spaziali vengono usate queste tecniche; ad esempio, quando gli astronauti devono - per emergenze, o per esigenze tecniche - lavorare, molte ore, senza pausa; oppure, restare svegli per supervisionare gli strumenti. Allora, essi si sottopongono ad un trattamento, a base di lampi ad intermittenza e suoni, che sposta il loro orologio biologico e riattiva la loro concentrazione, permettendo loro di vincere il sonno e la stanchezza.

Oltre ad avere una particolare influenza sul rilassamento, dove si e' dimostrata di particolare efficacia, essa sembra sviluppare anche capacita' immaginative e creativita'. Può essere utile per aiutare la meditazione e l’ipnosi, per alleviare emicranie e mal di testa, per la riduzione del fabbisogno di sonno e l'induzione al sonno naturale, per l'eliminazione della depressione e dell’ansia. E’ di aiuto nei disordini nella capacità di attenzione e della concentrazione, e per molto altro.

Questi battimenti furono scoperti nel 1839 dal tedesco Heinrich Wilhelm Dove, egli di accorse che applicando alle nostre orecchie due frequenze differenti, è possibile percepire i battimenti pari alla sottrazione delle due frequenze. Spiegando praticamente quanto sopra affermato, supponendo di applicare (con delle cuffie) all’orecchio destro un segnale audio pari a 400 cicli al secondo (Hz) e all’orecchio sinistro un segnale pari a 412 cicli al secondo (Hz), saremo in grado di percepire un battimento di queste frequenze pari a 12 cicli al secondo (Hz).
Il fenomeno dei battimenti dimostra che il suono che noi percepiamo è un elaborazione interna al nostro cervello di quanto percepito dalle due orecchie in modo distinto.

Il nostro apparato uditivo è comunque limitato nella percezione delle frequenze acustiche, infatti il range di frequenze percepibili dall'essere umano è compreso tra 20 cicli al secondo (Hz) e 20.000 cicli al secondo (Hz). Al di sopra (ultrasuoni) e al di sotto (infrasuoni), non siamo in grado di percepire nulla. Così nel 1973 il Dr. Gerald Oster del Mount Sinai school of Medicine New York , decise di fare alcuni esperimenti sul possibile fenomeno di risonanza che poteva venirsi a creare tra i Battimenti Binaurali e l'attività elettrica corticale. Egli considerò che le frequenze del nostro elettroencefalogramma (EEG) sono inferiori ai 20 cicli al secondo (Hz), così da non poter essere influenzate per risonanza dai normali segnali audio. Questo perché l’orecchio umano non è in grado di percepire frequenze così basse (inferiori ai 20 Hz). Con i battimenti binaurali, è invece possibile percepire le variazioni anche a frequenze molto basse, ed il Dr. Oster rilevò che il nostro elettroencefalogramma è influenzato dai battimenti binaurali, arrivando ad avere una attività elettrica con frequenza simile a quella del battimento.
una condizione di errore che si verifica a runtime quando in un buffer di una data dimensione vengono scritti dati di dimensioni maggiori; viene sovrascritta parte della zona di memoria immediatamente adiacente al buffer in questione, con diversi effetti possibili a seconda di dove è situato il buffer e di come è organizzata la memoria.

{Limiter.ar(GVerb.ar(Blip.ar(20,Line.kr(1,100,20),1),1),1)!2}.play;


Blip band limited impulse oscillator

Blip.ar(freq, numharm, mul, add)

Band Limited ImPulse generator. All harmonics have equal amplitude. This is the equivalent of 'buzz' in MusicN languages.

Line line generator

Inherits from: Object : AbstractFunction : UGen

Line.ar(start, end, dur, mul, add, doneAction)
Line.kr(start, end, dur, mul, add, doneAction)

Generates a line from the start value to the end value.
start - starting value
end - ending value
dur - duration in seconds
doneAction - a doneAction to be evaluated when the Line is completed. See UGen-doneActions for more detail.

Limiter peak limiter

Limiter.ar(in, level, dur)

Limits the input amplitude to the given level. Limiter will not overshoot
like Compander will, but it needs to look ahead in the audio. Thus there is a
delay equal to twice the lookAheadTime.
Limiter, unlike Compander, is completely transparent for an in range signal.

in - the signal to be processed.
level - the peak output amplitude level to which to normalize the input.
dur - aka lookAheadTime. The buffer delay time. Shorter times will produce smaller delays
and quicker transient response times, but may introduce amplitude modulation artifacts.

GVerb A two-channel reverb

#left, right = GVerb.ar(in, roomsize, revtime, damping, inputbw, spread, drylevel, earlyreflevel, taillevel,
maxroomsize, mul, add)

A two-channel reverb UGen, based on the "GVerb" LADSPA effect by Juhana Sadeharju (kouhia at nic.funet.fi).

in - mono input
roomsize - in squared meters
revtime - in seconds
damping - 0 to 1, high frequency rolloff, 0 damps the reverb signal completely, 1 not at all
inputbw - 0 to 1, same as damping control, but on the input signal
spread - a control on the stereo spread and diffusion of the reverb signal
drylevel - amount of dry signal
earlyreflevel - amount of early reflection level
taillevel - amount of tail level
maxroomsize - to set the size of the delay lines. Defaults to roomsize + 1



Entrammo in laboratorio e vidi l'odiosa macchina elettrica che brillava di una luminosità violetta e poco promettente. Era collegata ad una potente batteria chimica, ma in quel momento non riceveva corrente perché, durante i primi esperimenti ricordavo di averla sentita vibrare e ronzare quando era in funzione.

b = Buffer.read(s,"/home/bz/Desktop/radicaledward/supercollider/a11wlk01.wav");

al posto del grano sinusoidale prendo un pezzetto di wav

{ RLPF.ar(Saw.ar([50,75],0.1), XLine.kr(8000,400,25), 0.05) }.play;

(
SynthDef(\sfgrain, {arg bufnum=0, pan=0.0, startPos=0.0, amp=0.1, dur=0.04;
var grain;

grain= PlayBuf.ar(1,bufnum, BufRateScale.kr(bufnum), 1, BufFrames.ir(bufnum)*startPos, 0)*(EnvGen.kr(Env.perc(0.01,dur),doneAction:2)-0.001);

Out.ar(0,Pan2.ar(grain, pan))}).add;
)

(
{
200.do{arg i;
var timeprop = (i/199.0)**3;

        Synth(\sfgrain,[\freq,exprand(100,5000-(20*i)),\amp, exprand(0.05,0.1), \pan, 1.0.rand2]);
        rrand((timeprop*0.1).max(0.01),timeprop*0.3).wait
};
}.fork

)

+ GVerb Audacity



 
Haiku : Il fuco vola via. La regina è schiava. (Fight Club, Chuck Palahniuk)

(
{
var source;
var fx;
var n=10;

source= EnvGen.ar(Env([0,1,0],[0.1,1.5]),LFNoise1.kr(Rand(20,30)))*Saw.ar(170,0.5);

fx= Mix.fill(n, {
var maxdelaytime= rrand(0.01,0.03);
var half= maxdelaytime*0.5;
var quarter= maxdelaytime*0.25;

DelayC.ar(source, maxdelaytime, LFNoise1.kr(Rand(5,10),0.01,0.02) )

})!2;

fx
}.play
)


(Env([0,1,0],[0.1,1.5])).plot

DelayC simple delay line with cubic interpolation
DelayC.ar(in, maxdelaytime, delaytime, mul, add)
DelayC.kr(in, maxdelaytime, delaytime, mul, add)

Simple delay line with cubic interpolation. See also DelayN which uses no interpolation, and DelayL which uses linear interpolation. Cubic interpolation is more computationally expensive than linear, but more accurate.

See also BufDelayC.

in - the input signal.
maxdelaytime - the maximum delay time in seconds. used to initialize the delay buffer size.
delaytime - delay time in seconds.


EnvGen envelope generator

Inherits from: Object : AbstractFunction : UGen

Plays back break point envelopes. The envelopes are instances of the Env class. See the Env for more info. The arguments for levelScale, levelBias, and timeScale are polled when the EnvGen is triggered and remain constant for the duration of the envelope.

*ar(envelope, gate, levelScale, levelBias, timeScale, doneAction)
*kr(envelope, gate, levelScale, levelBias, timeScale, doneAction)


envelope - an instance of Env, or an Array of Controls. (See Control and the example below for how to use this.)
gate - this triggers the envelope and holds it open while > 0. If the Env is fixed-length (e.g. Env.linen, Env.perc), the gate argument is used as a simple trigger. If it is an sustaining envelope (e.g. Env.adsr, Env.asr), the envelope is held open until the gate becomes 0, at which point is released.
levelScale - scales the levels of the breakpoints.
levelBias - offsets the levels of the breakpoints.
timeScale - scales the durations of the segments.
doneAction - an integer representing an action to be executed when the env is finished playing. This can be used to free the enclosing synth, etc. See UGen-doneActions for more detail.


Env envelope

superclass: Object

An Env is a specification for a segmented envelope. Envs can be used both server-side, by an EnvGen within a SynthDef, and clientside, with methods such as at and asStream, below. An Env can have any number of segments which can stop at a particular value or loop several segments when sustaining. It can have several shapes for its segment


LFNoise1 ramp noise

LFNoise1.ar(freq, mul, add)
LFNoise1.kr(freq, mul, add)

Generates linearly interpolated random values at a rate.
freq - approximate rate at which to generate random values.




(
SynthDef(\test, {arg roomsize, revtime, damping, inputbw, spread = 15, drylevel, earlylevel,
        taillevel;
    var a = Resonz.ar(
        Array.fill(4, {SinOsc.ar(170)}), 1760 * [1, 2, 4, 8], 0.01).sum * 10;
   // var a = SoundIn.ar(0);
   // var a = PlayBuf.ar(1, 0);
    Out.ar(0, GVerb.ar(
        a,
        roomsize,
        revtime,
        damping,
        inputbw,
        spread,
        drylevel.dbamp,
        earlylevel.dbamp,
        taillevel.dbamp,
        roomsize, 0.3) + a)}).load(s)
)

s = Server.internal.boot;
s.scope(2);

// bathroom
a = Synth(\test, [\roomsize, 150, \revtime, 0.6, \damping, 0.62, \inputbw, 0.48, \drylevel -6, \earlylevel, -11, \taillevel, -13]);
a.free