3.7 Paquetes de muestras

# Paquete de samples

**Nota: esta sección del tutorial cubre el tema avanzado de trabajar con grandes directorios de tus propias muestras. Este será el caso si has descargado o comprado tus propios paquetes de muestras y deseas utilizarlos dentro de Sonic Pi.**

**Si te gusta trabajar con las muestras incluidas, puedes omitir esta parte.**

Cuando trabajas con carpetas grandes de samples externos puede ser difícil tener que escribir toda la ruta cada vez que quieras usar un sample.

Por ejemplo, si tienes la siguiente carpeta en tu máquina:

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

Cuando miramos dentro de esa carpeta encontramos las siguientes muestras:

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

Normalmente, para reproducir la muestra del piano podemos utilizar la ruta completa:

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

Si queremos reproducir un sample de guitarra podemos usar su ruta completa también:

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

Sin embargo, cada uno de estos llamados a sample requieren que sepamos los nombres de los samples en nuestro directorio. ¿Que tal si solo quisiéramos escuchar cada sample, uno tras otro, rápidamente?

## Indexando los paquetes de samples

Si queremos reproducir el primer sample en un directorio, necesitamos indicar el nombre del directorio en `sample` y el índice `0` de la siguiente manera:

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

Podemos incluso hacer un acceso directo a la ruta de nuestro directorio usando una variable:

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

Ahora, si queremos reproducir un segundo sample en nuestro directorio, sólo necesitamos añadir 1 a nuestro índice:

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

Date cuenta de que ya no necesitamos saber los nombres de los samples en el directorio - solamente debemos conocer el directorio (o tener una abreviatura para él). Si requerimos un indice que es mas grande que el numero de samples, simplemente retornamos al principio del directorio como si fuera un anillo. De cualquier manera, sin importar el número de índice que usemos, esta garantizado que tendremos un sample del directorio.

## Filtrar paquetes de samples

Usualmente con indexarlos es suficiente, pero algunas veces necesitamos algo mas poderoso para organizar nuestros samples. Afortunadamente muchos paquetes de samples añaden información valiosa en los nombres de los archivos. Ahora miremos de nuevo los nombres de los samples en nuestro directorio:

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

Date cuenta de que en estos nombres de archivo tenemos bastante información. En primer lugar tenemos el BPM del sample (número de pulsaciones por minuto) al comienzo. Por lo tanto, el sample del piano está a 120 BPM y nuestras primeras tres melodías están a 100 BPM. Además, nuestros nombres de los samples contienen la clave musical. Por tanto, el sample de la guitarra está en Bb (si bemol) y las melodías están en A# (la sostenido). Esta información es muy útil para mezclar estos samples con el resto del código. Por ejemplo, sabemos que solamente podemos usar el sample del piano con código que está a 120 BPM y en la clave de Bb.

Podemos usar como convención esta nomenclatura de nuestros conjuntos de samples en el código para ayudarnos a filtrar los que queremos. Por ejemplo, si trabajamos a 120 BPM, podemos filtrar a todos los ejemplos que contienen la cadena `" 120 "` con lo siguiente:

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

Ésto ejecutará el primer sample. Si queremos el segundo sample sólo necesitamos usar el índice:

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

Incluso podemos usar varios filtros al mismo tiempo. Por ejemplo, si queremos un sample cuyo nombre de archivo contenga las subcadenas "120" y "A #", lo encontraremos fácilmente con el siguiente código:

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

Por último, podemos añadir las opciones habituales al `sample`:

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

## Fuentes

El sistema de pre-arg de filtro del sample entiende dos tipos de información: fuentes y filtros. Las fuentes son información utilizada para crear la lista de candidatos potenciales. Una fuente puede tomar dos formas:

1. "/path/to/samples" - una cadena que representa una ruta de acceso válida a un directorio
2. "/path/to/samples/foo.wav" - Una cadena que representa una ruta válida a un sample

El 'sample' fn primero coge todas las fuentes y crear una lista con todos los candidatos. Esta lista se construye agregando primero todas las rutas válidas y añadiendo, luego, todos los ficheros `.flac`,` .aif`, `.aiff`,` .wav`, `.wave` contenidos en los directorios.

Por ejemplo, echemos un vistazo al siguiente código:

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

Aquí, combinamos el contenido de los samples dentro de dos directorios y añadiendo un sample específico. Si `"/path/to/my/samples/"` contiene 3 samples y `"/path/to/my/samples2/"` contiene 12, tenemos 16 samples potenciales para indexar y filtrar (3 + 12 + 1).

Por defecto, sólo los samples de un directorio se agrupan en una lista de candidatos. Es posible que tenga una serie de subcarpetas de samples en la que quieras buscar y filtrar. Por lo tanto, puedes realizar una búsqueda recursiva de todas los samples dentro de todas las subcarpetas de una carpeta determinada añadiendo `**` al final de la ruta:

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

Ten cuidado ya que la búsqueda en un conjunto muy grande de carpetas puede tomar mucho tiempo. Sin embargo, el contenido de todas las fuentes de las carpetas se almacenan en el caché, por lo que el retraso sólo se producirá la primera vez.

Por último, ten en cuenta que las fuentes *deben ir primero*. Si no se da ninguna fuente, entonces el conjunto de samples incorporados se seleccionará de la lista predeterminada de candidatos con los que trabajar.

## Filtros

Una vez que tienes una lista de candidatos deberías usar los siguientes tipos de filtros para reducir aún más la selección:

* `"foo"` Las cadenas filtrarán la ocurrencia de la subcadena dentro del nombre de archivo (menos la ruta del directorio y la extensión).
* `/fo[oO]/` Regular Expresssions filtrará aquellos archivos cuyo nombre sea más parecido al del archivo especificado (en el nombre de archivo no se incluye su ruta ni su extensión de archivo).
* `:foo` - Keywords filtrará aquellos candidatos donde la palabra clave coincida directamente con el nombre de archivo (salvo la ruta y la extensión).
* `lambda{|a| ... }` - Los procesos con un argumento serán tratados como un filtro candidato o como una función generadora. Se pasará la lista de candidatos actuales, y deberá devolver una lista nueva de candidatos (es decir, una lista de rutas válidas a archivos de samples).
* `1` - Los números seleccionarán el candidato cuyo índice coincida con dicho número (dando la vuelta como una estructura de anillo si hace falta).

Por ejemplo, podemos filtrar sobre todos las muestras en un directorio que contengan el string `"foo"` y ejecutar la primera muestra correspondiente a la mitad de su velocidad:

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

Mira la sección de ayuda para `sample` donde encontrarás muchos ejemplos de uso detallados. Ten en cuenta que debes respetar el orden de los filtros.

## Filtros y fuentes compuestos

Finalmente, puedes usar listas dentro de una fuente o filtro. La lista será aplanada automáticamente, y sus contenidos serán tratados como fuentes y filtros normales y corrientes. Por tanto, las siguientes llamadas a `sample` son equivalentes sintácticamente:

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

## Conclusión

Ésta es una sección avanzada pensada para gente que necesite manipular y usar paquetes de samples de forma eficiente. No te preocupes si no entiendes si esta sección. Es probable que no necesites ninguna de estas opciones ahora mismo. Cuando llegue el momento. verás si te hacen falta estas herramientas; siempre puedes volver y leer esta ayuda de nuevo cuando empieces a trabajar con directorios de samples muy grandes.
