3.7 Sample-Pakete

# Sample-Pakete

**Hinweis: Dieser Abschnitt des Tutorials behandelt das fortgeschrittene Thema der Arbeit mit großen Verzeichnissen deiner eigenen Samples. Dies wird nützlich sein, wenn du deine eigenen Sample Packs heruntergeladen oder gekauft hast und diese in Sonic Pi nutzen möchtest.**

**Überspringe diesen Abschnitt, wenn dir die mitgelieferten Samples für die Arbeit ausreichen.**

Wenn du mit großen Ordnern mit externen Samples arbeitest, kann es mühselig sein, jedes Mal den vollständigen Pfad eingeben zu müssen, um ein bestimmtes Sample abzuspielen.

Sagen wir, du hast zum Beispiel folgenden Ordner auf deinem Computer:

```
/pfad/zu/meinen/samples/
```

Wenn wir in diesen Ordner schauen, finden wir die folgenden Samples:

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

Üblicherweise können wir den vollständigen Pfad nutzen um das Piano-Sample abzuspielen:

```
sample "/pfad/zu/meinen/samples/120_Bb_piano1.wav"
```

Wenn wir dann das Gitarren-Sample abspielen wollen, können wir ebenfalls den vollständigen Pfad nutzen:

```
sample "/pfad/zu/meinen/samples/120_Bb_guit.wav"
```

Wie auch immer, beide Aufrufe verlangen von uns, dass wir die Namen der Samples innerhalb des Verzeichnisses *kennen*. Was, wenn wir einfach nur schnell die einzelnen Samples nacheinander abhören wollen?

## Sample-Packs indizieren

Wenn wir das erste Sample in einem Verzeichnis abspielen wollen, müssen wir nur den Verzeichnisnamen an `sample` und den Index `0` eingeben. Folgendermaßen:

```
sample "/pfad/zu/meinen/samples/", 0
```

Wir können sogar eine Verknüpfung zu unserem Verzeichnispfad anlegen, indem wir eine Variable nutzen:

```
samps = "/pfad/zu/meinen/samples/"
sample samps, 0
```

Wenn wir nun das zweite Sample in unserem Verzeichnis abspielen wollen, müssen wir lediglich 1 zu unserem Index hinzufügen:

```
samps = "/pfad/zu/meinen/samples/"
sample samps, 1
```

Beachte, dass wir nicht mehr die Namen der Samples im Verzeichnis kennen müssen - wir müssen nur das Verzeichnis selbst kennen (oder eine Verknüpfung dort hin). Wenn wir nach einer Index-Zahl fragen, die größer ist als die Anzahl an Samples, fängt die Liste einfach von vorne an - wie bei Ringen. Also egal welche Index-Zahl wir nutzen, es ist garantiert, dass wir eines der Samples aus dem Verzeichnis bekommen.

## Sample-Packs filtern

Gewöhnlich reicht das Indizieren aus, aber manchmal benötigen wir machtvollere Mittel, um unsere Samples zu organisieren. Glücklicherweise packen viele Sample-Packs nützliche Informationen in die Dateinamen. Lass uns einen weiteren Blick auf die Dateinamen der Samples in unserem Verzeichnis werfen:

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

Achte darauf, dass In diesen Dateinamen einiges an Informationen enthalten ist. Zuerst haben wir die BPM ("beats per minute") des Samples am Beginn. D.h. das Piano-Sample ist in 120 BPM und unsere ersten drei Melodien sind in 100 BPM. Außerdem steht in den Sample-Namen die Tonart. Das Gitarren-Sample ist in Bb, und die Melodien sind in A#. Diese Information ist für das Mixen der Samples mit unserem Code sehr wichtig. Zum Beispiel wissen wir, dass wir das Piano-Sample nur mit Code verwenden können, der 120 BPM und die Tonart Bb hat.

Es stellt sich heraus, dass wir dies spezielle Namensgebung unserer Sample-Sets im Code nutzen können, um die Samples herauszufiltern, die wir wollen. Wenn wir zum Beispiel mit 120 BPM arbeiten, können wir mit folgendem Code alle Samples filtern, deren Name den String `"120"` enthält:

```
samps = "/pfad/zu/meinen/samples/"
sample samps, "120"
```

Dieser Code wird uns das erste passende Sample abspielen. Wenn wir das zweite passende Sample abspielen wollen, müssen wir nur eine Index-Zahl nutzen:

```
samps = "/pfad/zu/meinen/samples/“
sample samps, "120", 1
```

Wir können sogar mehrere Filter gleichzeitig nutzen. Wenn wir ein Sample wollen, dessen Name sowohl den String `"120"` als auch den String `"A#"` enthält, können wir das leicht mit dem folgenden Code erreichen:

```
samps = "/pfad/zu/meinen/samples/"
sample samps, "120", "A#"
```

Schließlich können wir auch noch unsere üblichen Optionen dem `sample`-Aufruf anhängen:

```
samps = "/pfad/zu/meinen/samples/"
sample samps, "120", "Bb", 1, lpf: 70, amp: 2
```

## Quellen

Das Filter-System für Samples versteht zwei Typen von Informationen: Quellen und Filter. Quellen sind Informationen, um eine Liste möglicher Kandidaten zu versammeln. Eine Quelle kann in zwei Formen angegeben werden:

1. "/pfad/zu/samples" - eine Zeichenkette (string), die einen gültigen Pfad zu einem Verzeichnis angibt
2. "/pfad/zu/samples/foo.wav" - eine Zeichenkette (string), die einen gültigen Pfad zu einem Sample angibt

Die `sample`-Funktion sammelt alle Quellen und erzeugt daraus eine lange Liste von Kandidaten. Für diese Liste durchsucht die Funktion zunächst alle gültigen Verzeichnispfade und fügt dann alle darin enthaltenen Dateien in den Formaten `.flac`, `.aif`, `.aiff`, `.wav`, `.wave` hinzu.

Schau Dir z. B. den folgenden Code an:

```
samps = "/pfad/zu/meinen/samples/"
samps2 = "/pfad/zu/meinen/samples2/"
path = "/pfad/zu/meinen/samples3/foo.wav"
sample samps, samps2, path, 0
```

Hier kombinieren wir alle Samples aus zwei Verzeichnissen und fügen noch ein einzelnes Sample hinzu. Wenn `"/pfad/zu/meinen/samples/"` 3 Samples und `"/path/to/my/samples2/"` 12 Samples enthielte, hätten wir insgesamt 16 mögliche Samples, die wir indexieren und filtern können (3 + 12 + 1).

Standardmäßig werden nur die Sample-Dateien des angegebenen Verzeichnisses in der Kandidatenliste gesammelt. Manchmal möchtest du vielleicht eine ganze Reihe ineinander verschachtelter Ordner mit Samples durchsuchen und filtern. Das kannst du mit einer rekursiven Suche nach allen Samples in allen Unterordnern erreichen, indem du `**` an das Ende des Pfads hängst:

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

Beachte jedoch, dass eine Suche über viele Verzeichnisse hinweg viel Zeit in Anspruch nehmen kann. Allerdings wird der Inhalt aller Ordner, die du als Quellen angegeben hast, zwischengespeichert - die Verzögerung wird also nur bei der ersten Suche auftreten.

Ein wichtiger Punkt zum Abschluss: Die Quelle *muss als erstes angegeben werden*. Wenn keine Quelle angegeben wird, werden die mitgelieferten Samples als die Standardliste der Kandidaten ausgewählt, mit denen du dann weiter arbeitest.

## Filter

Wenn du erst einmal eine Kandidatenliste hast, kannst du die folgenden Filtertypen nutzen, um die Auswahl weiter einzugrenzen:

* `"foo"` filtert alle Dateinamen, in denen diese Zeichenkette vorkommt (abzüglich des Verzeichnispfades und der Dateiendung).
* `/fo[oO]/` filtert alle Dateinamen, die diesem regulären Ausdruck entsprechen (abzüglich des Verzeichnispfades und der Dateiendung).
* `:foo` - filtert alle Kandidaten, bei denen dieses Schlüsselwort genau dem Dateinamen entspricht (abzüglich des Verzeichnispfades und der Dateiendung).
* `lambda{|a| ... }` - Procs mit einem Argument werden als Filter für Kandidaten oder Generator-Funktionen behandelt. Diesem wird die Liste der aktuellen Kandidaten übergeben, und er gibt eine neue Liste von Kandidaten zurück (eine Liste gültiger Pfade zu Sample-Dateien).
* `1` - Zahlen wählen direkt den Kandidaten aus, dessen Indexposition dieser Zahl entspricht (wenn nötig wird wie bei einem Ring von vorne begonnen).

Wir können z. B. alle Samples in einem Verzeichnis herausfiltern, deren Dateinamen die Zeichenkette `"foo"` enthalten, und davon das erste passende Sample mit halber Geschwindigkeit spielen:

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

Sieh' dir die Hilfe zu `sample` an, sie enthält viele detaillierte Anwendungsbeispiele. Achte darauf, welche Rolle die Sortierung der Filter spielt.

## Verbünde

Abschließend sei gesagt, dass du Listen überall verwenden kannst, wo du eine Quelle oder einen Filter einsetzt. Die Liste wird automatisch eingebettet und ihre Inhalte behandelt wie normale Quellen- oder Filterangaben. Daher sind die folgenden Aufrufe von `sample` alle gleichbedeutend:

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

## Zum Abschluss

Das war ein fortgeschrittener Abschnitt für Leute, die machtvollere Möglichkeiten benötigen, um mit Sample-Paketen zu hantieren und sie zu nutzen. Wenn vieles davon für dich im Moment noch wenig Sinn ergeben hat, keine Sorge. Es ist gut möglich, dass du vieles davon jetzt noch nicht brauchst. Dennoch, du wirst merken, wann du es brauchst, und du kannst zurückkommen und den Abschnitt noch einmal lesen, wenn du anfängst mit umfangreicheren Sample-Sammlungen zu hantieren.
