Bz Buzz

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

Il jamming è l'atto di disturbare volutamente le comunicazioni radio, facendo in modo che ne diminuisca il rapporto segnale/rumore, indice di chiarezza del segnale, tipicamente trasmettendo sulla stessa frequenza e con la stessa modulazione del segnale che si vuole disturbare.

(
{
var trigger, fund, flashInst;

Un Array di 7 elementi, ogni elemento  è un Mix di 13 denti di sega che passano singolarmente in un Envelope Generator ADSR (triggato da un Dust.kr) e moltiplicate per un PinkNoise; il pan viene fatto con un numero random tra -1 a 1; l'array flashInst viene poi mixato attraverso un UGen Mix

flashInst = Array.fill(7,
{
trigger = Dust.kr(3/7);
fund = rrand(37, 73);
Pan2.ar(Mix.ar(Array.fill(13,
{
arg counter;
var partial;
partial = counter + 1;
Saw.ar(fund*partial) * EnvGen.kr(Env.adsr(0, 0, 1.0, 7.0), trigger, 1/partial) * max(0, PinkNoise.kr(rrand(3, 17)))
}
)
)*0.3,
1.0.rand2)
});
Mix.ar(flashInst)*0.7
}.play
)

{Resonz.ar(PinkNoise.ar(0.713),713,XLine.kr(0.001, 1, 3.713))!2}.play


Resonz

Resonz è un filtro risonante passa banda molto, molto forte. È usato per enfatizzare una banda di frequenza.

in il segnale di ingresso;
freq la frequenza risonante in Hertz;

ATTENZIONE: a causa della natura della sua implementazione, i valori di frequenza prossimi a 0 possono causare anomalie e/o artefatti audio estremamente rumorosi!

bwr rapporto larghezza di banda (reciproco di q). rq = larghezza di banda/frequenza centrale .
mul il segnale in uscita sarà moltiplicato per questo valore.
add questo valore verrà aggiunto all'output.


PinkNoise

In fisica si definisce rumore rosa o rumore 1/f o rumore Flicker un particolare tipo di rumore in cui le componenti a bassa frequenza hanno potenza maggiore, a differenza del rumore bianco in cui la potenza è uguale per qualsiasi frequenza.

Genera rumore il cui spettro di frequenza diminuisce in potenza di 3 dB per ottava. Abbiamo uguale potenza nell'arco di ogni ottava e 8 ottave di rumore rosa.

mul il segnale in uscita sarà moltiplicato per questo valore.
add questo valore verrà aggiunto all'output.

XLine

Genera una curva esponenziale dal valore iniziale al valore finale. Entrambi i valori iniziale e finale devono essere diversi da zero e avere lo stesso segno.

*ar (start: 1, end: 2, dur: 1, mul: 1, add: 0, doneAction: 0)
*kr (start: 1, end: 2, dur: 1, mul: 1, add: 0, doneAction: 0)

Torturavo Puffi con piacere, strizzavo loro il naso e le orecchie, per poi schiacciarli vivi; poi li spremevo, raccogliendo il sangue blu in una ciotola di ametista per evocare Ithaqua, Colui Che Cammina Nel Vento, affinchè il Dio del Freddo Silenzio Bianco, flagellasse Napoleone;

(
// a SynthDef
SynthDef(\bz, { | out, freq = 440, amp = 1, nharms = 3, pan = 0, gate = 1 |
    var audio = SinOsc.ar(PinkNoise.kr(freq), Line.kr(1,nharms,0.5), amp);
    var env = Linen.kr(gate, doneAction: 2);
    Out.ar(CombL.ar(out, 2.0, 4/6, 6);, Pan2.ar(audio, pan, env) );
}).add;
)

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

(
{
x = RLPF.ar(SinOsc.ar(SinOsc.ar([0.020, 0.019]).range(3, 10)) * SyncSaw.ar(SinOsc.ar(0.01).range(1, 100), PinkNoise.ar(0.017).range(700, 713)), Line.ar(60, 3713, 60*5));
x = GVerb.ar(x + CombL.ar(x, 10, 0.2, 10));
EnvGen.ar(Env.linen(0.01, 60*5, 20), doneAction:2) * x * 0.03!2
}.play
)

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