3.7 Pacchetti di sample

# Pacchetti di sample

**Nota: questa sezione del tutorial copre argomenti avanzati e spiega come lavorare con directory contenenti molti sample. Questo, ad esempio, può accadere se hai scaricato o comprato dei sample pack e vuoi utilizzarli con Sonic Pi.**

**Sentiti libero di saltare questa sezione se i campioni già presenti in Sonic Pi ti sono sufficienti.**

Quando lavori con cartelle piene di file esterni, può essere scomodo digitare l'intero percorso ogni volta che vuoi lanciare un singolo campione.

Per esempio, facciamo finta che tu abbia questa cartella sul tuo computer:

```
/path/to/my/samples/
```

Quando guardiamo all'interno di quella cartella, troviamo i seguenti campioni:

* `100_A#_melody1.wav`
* `100_A#_melody2.wav`
* `100_A#_melody3.wav`
* `120_A#_melody4.wav`
* `120_Bb_guit1.wav`
* `120_Bb_piano1.wav`

Di solito, per suonare i campioni di pianoforte dovremmo usare il percorso completo:

```
sample "/path/to/my/samples/120_Bb_piano1.wav"
```

Se volessimo usare anche i campioni di chitarra, anche in questo caso dovremmo usare il percorso completo:

```
sample "/path/to/my/samples/120_Bb_guit.wav"
```

Purtroppo, per caricare questi campioni è necessario *conoscere* i nomi dei campioni all'interno della nostra cartella. E se volessimo ascoltare velocemente ciascun sample a turno?

## Indicizzare i pacchetti di campioni

Se vogliamo suonare il primo campione in una cartella, dobbiamo semplicemente passare il nome della cartella al comando `sample`e l'indice `0` in questo modo:

```
sample "/path/to/my/samples/", 0
```

Se vogliamo, possiamo anche creare una scorciatoia per la nostra cartella utilizzando una variabile:

```
samps = "/path/to/my/samples/"
sample samps, 0
```

Ora, se vogliamo suonare il secondo sample nella directory, dobbiamo aggiungere 1 al nostro indice:

```
samps = "/path/to/my/samples/"
sample samps, 1
```

Puoi notare come non sia più necessario conoscere i nomi dei campioni nella cartella, dobbiamo solo conoscere la posizione della cartella stessa (o avere una scorciatoia). Se proviamo a utilizzare un indice maggiore del numero dei campioni, ripartirà semplicemente da capo come nei Rings. Per cui, indipendentemente dal numero usato, abbiamo la sicurezza che verrà utilizzato un campione in quella cartella.

## Filtrare i pacchetti di campioni

Di solito è sufficiente indicizzare, ma qualche volta abbiamo bisogno di maggiore potenza per organizzare i nostri campioni. Per fortuna molti pacchetti di campioni aggiungono informazioni nei nomi dei file. Diamo ancora un'occhiata ai campioni nella nostra cartella:

* `100_A#_melody1.wav`
* `100_A#_melody2.wav`
* `100_A#_melody3.wav`
* `120_A#_melody4.wav`
* `120_Bb_guit1.wav`
* `120_Bb_piano1.wav`

Puoi notare come i nomi dei file hanno molte informazioni. Per iniziare abbiamo il BPM del sample (beat per minuto) all'inizio del nome. PEr cui se il campione del pianoforte è a 120BPM mentre le nostre tre melodie sono a 100BPM. In aggiunta, il nome dei campioni contiene anche la tonalità: il campione di chitarra è in Bb (Si bemolle) e le melodie in A# (La diesis). Questa informazione è molto utile per mixare questi sample con il nostro codice. Per esempio, sappiamo che possiamo suonare il campione del piano se il nostro codice è a 120BPM e in tonalità di Bb.

È possibile usare questa convenzione sui nomi dei file del nostro set di campioni nel codice per aiutarci a filtrare quelli che vogliamo. Per esempio, se stiamo lavorando a 120BPM, possiamo visualizzare tutti i campioni che contengono la stringa `"120"` come segue:

```
samps = "/path/to/my/samples/"
sample samps, "120"
```

Questo farà suonare il primo risultato. Se volessimo il secondo, possiamo usare l'indice:

```
samps = "/path/to/my/samples/"
sample samps, "120", 1
```

Possiamo anche usare più filtri contemporaneamente. Per esempio, se vogliamo utilizzare i campioni il cui nome contenga sia "120" che "A#" possiamo farlo usando questo codice:

```
samps = "/path/to/my/samples/"
sample samps, "120", "A#"
```

Infine, possiamo sentirci liberi di usare i parametri di `sample` che abbiamo già visto:

```
samps = "/path/to/my/samples/"
sample samps, "120", "Bb", 1, lpf: 70, amp: 2
```

## Fonti

Il sistema di filtro dei campioni capisce due tipi di informazioni: la fonte e i filtri. Le fonti sono informazioni usate per creare la lista dei potenziali candidati. Una fonte può avere due forme:

1. "/path/to/samples" - una stringa che rappresenta un percorso valido a una cartella
2. "/path/to/samples/foo.wav" - una stringa che rappresenta un percorso valido per un campione

La funzione `sample` raccoglierà per prima cosa tutte le fondi e le userà per creare una lunga lista di possibili candidati. Questa lista viene costruita aggiungendo tutti i percorsi e tutti i file con estensione `.flac`, `.aif`, `.aiff`, `.wav`, `.wave` contenuti all'interno della cartella.

Per esempio, diamo un'occhiata a questo codice:

```
samps = "/path/to/my/samples/"
samps2 = "/path/to/my/samples2/"
path = "/path/to/my/samples3/foo.wav"
sample samps, samps2, path, 0
```

In questo caso stiamo combinando il contenuto dei campioni all'interno di due cartelle e aggiungendo un campione specifico. Se `"/path/to/my/samples/"` contiene 3 campioni e `"/path/to/my/samples2/"` ne contiene 12, abbiamo 16 potenziali campioni da indicizzare e filtrare (3 + 12 + 1).

Per impostazione predefinita, sono inclusi nella lista dei candidati solo i campioni contenuti in una cartella. E' possibile talvolta che in una serie di cartelle di campioni annidate, si voglia eseguire una ricerca e applicarvi dei filtraggi. Pertanto, è possibile eseguire una ricerca ricorsiva per tutti i campioni contenuti in ogni sottocartella di una data cartella aggiungendo `**` alla fine del percorso:

```
samps = "/path/to/nested/samples/**"
sample samps, 0
```

Fai attenzione quindi, perché la ricerca all'interno di un gruppo di cartelle ampio può impegare parecchio tempo ad essere portata a termine. Comunque, il contenuto di tutte le cartelle sorgenti sono memorizzati nella cache, quindi soltanto la prima volta la ricerca impiegherà più tempo.

Infine, tieni presente che la sorgente *deve essere inserita prima*. Ne nessuna sorgente viene indicata, allora il gruppo di campioni già presenti nel sistema verrà selezionato automaticamente per la sessione.

## Filtri

Quando avrai ottenuto una lista di campioni da usare durante la sessione, puoi quindi utilizzare le seguenti chiavi per ridurne ulteriormente il numero:

* La stringa `"foo"` filtrerà le occorrenze all'interno del nome del file (cartella di percorso ed estensione escluse).
* L'espressione regolare `/fo[oO]/` filtrerà il pattern riconosciuto nel nome del file (cartella di percorso ed estensione esclusi).
* La parola chiave `:foo` filtrerà i vari file candidati se la parola chiave avrà riscontro diretto nel nome del file (cartella di percorso ed estensione esclusi).
* I Procs `lambda{|a| ... }` (ndT: in Ruby i Procs sono blocchi di codice legati a variabili locali) con un argomento saranno trattati come filtri o funzioni di generazione. La lista dei file correnti candidati deve essere passata all'oggetto che restituirà una nuova lista di candidati (una lista di percorsi validi ai file).
* I numeri `1` selezioneranno il file candidato a quell'indice (ripartendo dall'inizio se necessario).

Per esempio, possiamo filtrare tutti i campioni in una cartella che contengono la stringa `"foo"` e riproduttre il primo risultato a metà della velocità:

```
sample "/path/to/samples", "foo", rate: 0.5
```

Vedi il capitolo relativo ai `sample` nel manuale per altri esempi di utilizzo. Attenzione: verrà rispettato l'ordine dei filtri.

## Compositi

Infine, puoi usare delle liste sia al posto delle fonti che dei filtri. Le liste saranno automaticamente appiattite e il loro contenuto sarà trattato come una fonte o un filtro. Per questo motivo, i seguenti esempi su `sample` sono equivalenti a livello semantico:

```
sample "/path/to/dir", "100", "C#"
sample ["/path/to/dir", "100", "C#"]
sample "/path/to/dir", ["100", "C#"]
sample ["/path/to/dir", ["100", ["C#"]]]
```

## Conclusione

Questa era una sezione per coloro che hanno bisogno di manipolare e usare i pacchetti di campioni in modo avanzato. Se per te questa sezione non aveva alcun senso, non ti preoccupare. Probabilmente non hai ancora bisogno di utilizzare queste funzionalità. In ogni caso ora sai dove si trova questa sezione e potrai tornare indietro a rileggerla quando ne avrai bisogno.
