3.7 Pachete de esantioane

# Pachete de esantioane

**Nota: aceasta sectiune din tutorial se refera la situatia in care vrei sa folosesti foldere mai cu propriile esantioane. Acest lucru se va intampla daca ai descarcat sau cumparat un pachet de esantioane si vrei sa-l foloseti cu Sonic Pi.**

**Poti sa sari peste aceasta sectiune daca esti multumit cu esantioanele deja incluse in program.**

Cand lucrezi cu foldere mari de esantioane externe poate fi dificil sa scrii de fiecare data calea completa cand vrei sa incarci un anumit esantion.

De exemplu, sa spunem ca ai folderul de mai jos in calculatorul tau:

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

Inauntrul folderului gasim urmatoarele esantioane:

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

In mod normal, pentru a reda esantionul de pian putem folosi calea completa:

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

Daca vrem ca apoi sa redam esantionul de chitara putem folosi de asemenea calea completa:

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

Totusi, ambele apeluri ale comenzii sample cer ca noi sa *stim* numele esantioanelor din folder. Cum ar fi daca am dori sa ascultam fiecare esantion pe rand?

## Indexarea pachetelor de esantioane

Daca vrem sa redam primul esantion dintr-un folder trebuie doar sa transmitem catre comanda 'sample' numele folderului si indexul '0' ca mai jos:

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

Putem crea o scurtatura catre folder folosind o variabila:

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

Acum, daca dorim sa redam al doilea esantion din folder, trebuie doar sa adaugam 1 la index:

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

Observi ca nu mai este nevoie sa stim numele esantioanelor din folder - trebuie doar sa stim numele folderului (sau sa avem o scurtatura catre el). Daca cerem un index mai mare decat numarul de esantioane, va relua numaratoarea de la inceputul listei. Astfel, orice numar vom folosi, avem garantia ca vom obtine un esantion din acel folder.

## Filtrarea pachetelor de esantioane

De obicei indexarea este suficienta, dar uneori avem nevoie de o metoda mai puternica de sortare si organizare a esantioanelor. Din fericire, multe pachete de esantioane contin informatii utile in numele fisierelor. Sa mai aruncam o privire la numele fisierelor din folderul nostru:

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

Observi ca in aceste nume de fisiere avem cateva informatii. In primul rand, avem ritmul in BPM (batai pe minut) la inceput. Deci, esantionul de pian este la 120 BPM si primele trei melodii sunt la 100 BPM. De asemenea, numele esantioanelor contin cheia. Esantionul de chitara este in Bb, iar melodiile in A#. Aceasta informatie este foarte utila cand combini aceste esantioane cu restul codului. De exemplu, stim ca putem reda esantionul de pian doar cu cod care este la 120 BPM si in cheia Bb.

Se pare ca putem folosi aceasta conventie de numire a esantioanelor in codul nostru pentru a le filtra pe cele pe care le vrem. De exemplu, daca lucram la 120 BPM, putem aplica un filtru care retine toate esantioanele al caror nume contine sirul '"120"' astfel:

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

Aceasta va reda primul esantion care se potriveste. Daca dorim sa il redam pe al doilea trebuie sa folosim un index:

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

Putem chiar folosi mai multe filtre in acelasi timp. De exemplu, daca vrem un esantion al carui nume contine atat subsirurile "120" cat si "A#", putem sa-l gasim usor astfel:

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

Putem de asemenea sa adaugam parametrii obisnuiti pentru 'sample':

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

## Surse

Sistemul de filtrare a esantioanelor intelege doua tipuri de informatii: surse si fltre. Sursele sunt informatii utilizate pentru a crea liste de potentiali candidati. O sursa poate lua doua forme:

1. "/path/to/samples" - un sir reprezentand o cale valida catre un folder
2. "/path/to/samples/foo.wav" - un sir reprezentand o cale valida catre un esantion

Functia 'sample' va aduna mai intai toate sursele si le va folosi pentru a crea o lista mare de candidati. Lista este construita adaugand mai intai toate caile valide si apoi adaugand toate fisierele '.flac', '.aif', '.aiff', '.wav' sau '.wave' din aceste foldere.

De exemplu, sa aruncam o privire la codul acesta:

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

Aici am combinat continutul a doua foldere cu esantioane, apoi am adaugat inca un esantion individual. Daca `"/path/to/my/samples/"` contine 3 esantioane, iar `"/path/to/my/samples2/"` contine 12, avem 16 esantioane de indexat si de filtrat (3 + 12 + 1).

Implicit, doar esantioanele din folder sunt adaugate la lista de candidati. Uneori ai putea avea si subfoldere in care ai vrea sa cauti. Poti sa efectuezi o cautare recursiva a tuturor esantioanelor din toate subfolderele unui anumit folder, adaugand '**' la sfarsitul caii:

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

Ai grija totusi, cautarea printr-un set mare de foldere poate dura foarte mult. Continutul tututor folderelor este pastrat in cache, deci intarzierea sa va manifesta doar prima data.

O observatie de final - sursele *trebuie sa treaca inainte*. Daca nicio sursa nu este specificata, setul de esantioane incluse in Sonic Pi va fi selectat ca lista implicita de candidati.

## Filtre

Odata ce ai lista de candidati, poti folosi urmatoarele tipuri de filtre pentru a reduce selectia:

* '"foo"' Siruri - filtrarea dupa un subsir care apare in numele fisierului (fara cale sau extensie).
* `/fo[oO]/` Expresii regulate - filtrarea se face prin compararea numelui fisierului (fara cale sau extensie) cu un sablon.
* ':foo' Cuvinte cheie - se verifica daca numele fisierului (fara cale sau extensie) se potriveste cu cuvantul cheie.
* `lambda{|a| ... }` Proceduri cu un argument vor fi tratate ca filtre. Vor primi lista curenta de candidati si trebuie sa intoarca o noua lista (continand cai valide catre esantioane).
* '1' Numere - vor selecta candidatul cu indexul respectiv (cu reluarea numararii de la inceput daca este cazul).

De exemplu, putem filtra toate esantioanele dintr-un folder care contin sirul '"foo"' si sa redam primul esantion care se potriveste, la jumatate din viteza normala:

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

Cauta in help (sistemul de ajutor) exemple mai detaliate de utilizare. Observa cum este respectata ordinea filtrelor.

## Combinatii

Poti folosi liste oriunde poti folosi o sursa sau un filtru. Lista va fi normalizata automat si continutul va fi tratat ca sursele si filtrele obisnuite. Ca urmare, urmatoarele apeluri ale functiei 'sample' sunt echivalente semantic:

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

## Concluzie

Aceasta a fost o sectiune avansata pentru cei care au nevoie de posibiltatea de a manevra pachete de esantioane. Daca n-ai inteles mare lucru din sectiunea asta, nu te ingrijora. Probabil inca nu ai nevoie de functionalitatea asta. Totusi, cand vei avea nevoie de ea vei sti ca exista si te vei putea intoarce sa recitesti aceasta parte cand vei lucra cu foldere mari cu esantioane.
