Reversing

// 18
// Nathaniel Virgo
(
play{
    p = PinkNoise.ar(1!2);
    BRF.ar(
        p + Blip.ar(p+2,400),
        150,
        2,
        0.1
    )
    +
    LPF.ar( FreeVerb2.ar( *LPF.ar( p + 0.2 * Dust.ar( 0.1 ), 60) ++ [ 1, 1, 0.2, 1e4 ]).tanh, 2000)
}
)

(1!2).postln -> [ 1, 1 ]
PinkNoise *ar (mul: 1.0, add: 0.0)
PinkNoise.ar([1,1])

Genera rumore rosa il cui spettro decade in potenza di 3 dB per ottava, il che fornisce uguale potenza nell'arco di ciascuna ottava. Questa versione ha un limite di banda di 8 ottave.

Al rumore rosa viene aggiunto un segnale

Blip.ar(freq: 440.0,  numharm: 200.0,  mul: 1.0,  add: 0.0)
che è un segnale di impulsi limitato in banda; il numero di armoniche nel nostro caso è settato a 400; la frequenza è data dal doppio PinkNoise; quella specie di rumore di gocce di acqua che cadono che si sente è dovuto all'UGen Blip.ar;

il segnale risultante è fatto passare in un filtro risonante rifiuta banda, BRF.ar(in: 0.0, freq: 440.0, rq: 1.0, mul: 1.0, add: 0.0)



BRF.scopeResponse

a questo segnale è aggiunto un secondo segnale :




















LPF.ar( FreeVerb2.ar( *LPF.ar( p + 0.2 * Dust.ar( 0.1 ), 60) ++ [ 1, 1, 0.2, 1e4 ]).tanh, 2000)

Un "*" prima di un array all'interno di una funzione divide gli elementi dell'array e li passa agli args, nel nostro caso alla UGen FreeVerb2.ar. Diventa più chiaro facendo questo con il metodo Array.with che genera un nuovo array e prevede elementi separati.

Array.with(*LPF.ar (PinkNoise.ar (1! 2) + 0.2 * Dust.ar (0.1), 60) ++ [1, 1, 0.2, 1e4])
-> [ a LPF, a LPF, 1, 1, 0.2, 10000.0 ]

quindi la UGen avra questi args : FreeVerb2.ar(in: LPF,  in2: LPF,  mix: 1,  room: 1,  damp: 0.2,  mul: 10000.0,  add: 0.0)

questo segnale genera un forte boato, 1 volta ogni 10 secondi circa, dovuto all'impulso creato dal Dust moltiplicato per il Rumore Rosa;

La precedenza sinistra-destra di SC provoca l'aggiunta di un offset di 0,2 (al Rumore Rosa stereo) prima della moltiplicazione con l'impulso Dust.
La funzione sigmoide tanh mantiene il segnale tra -1 e + 1;

Per quanto riguarda l'offset di 0,2. Ho solo un presupposto: il file di aiuto di PinkNoise dice:

NOTA: è stato osservato che i valori prodotti da questa UGen sono molto probabilmente tra -0,65 e +0,81 circa (prima di essere moltiplicati per mul).

Quindi potrebbe essere che l'intenzione fosse quella di mantenere il segnale all'incirca al di sotto di 1, con probabilità molto alta.

// Modo per attivare e esplorare le Eccezioni con la GUI

Exception.debug = true;

// Metodo per salvare l'immagine del Plot

p= {BRF.ar( PinkNoise.ar(1!2) + Blip.ar(PinkNoise.ar(1!2)+2,400), 150, 2, 0.1) }.plot(10);
i = Image.fromWindow(p.parent, p.interactionView.bounds);
i.write("~/concat.png".standardizePath);
i.free

// Metodo per tracciare una Synth

(
SynthDef(\resonz, { |out, freq = 440|
    var    sig, ffreq;
    sig = PinkNoise.ar(1!2);
    Out.ar(out, FreeVerb2.ar( *LPF.ar( sig + 0.2 * Dust.ar( 0.1 ), 60) ++ [ 1, 1, 0.2, 1e4 ]).tanh, 0.1)
}).send(s);

)

a = Synth(\resonz);
a.trace;

// Metodo per capire come è composto un segnale

sig = PinkNoise.ar(1 ! 2).postln;
sig = LPF.ar (sig + 0.2 * Dust.ar(0.1), 60).postln;
sig = (sig ++ [1, 1, 0.2, 1e4]).postln;
sig = FreeVerb2.ar(*sig).postln;