Zum Inhalt springen

Eine Live-Coding-Musik-App bauen · Teil 10 von 18 der Serie

Teil 10: Ändern, während es spielt

Mach aus der App eine Live-Coding-App: Die Engine vergleicht jeden Durchlauf des Codes mit dem, was gerade spielt, behält die Bausteine, die es noch gibt, erzeugt die neuen und blendet die übrigen aus. Die Musik ändert sich ohne Lücke.

Quest-Ziele

  • Verstehen, warum ein Baustein bei jedem Durchlauf des Codes dieselbe ID bekommt
  • Einen neuen Patch mit den laufenden Bausteinen vergleichen
  • Einen Baustein behalten und ihm seine Optionen nur übergeben, wenn sie sich geändert haben
  • Einen entfernten Baustein ausblenden, bevor er ausgesteckt wird
  • In der Statuszeile zeigen, was ein Durchlauf behalten, erzeugt und entfernt hat

Live-Coding heißt, Musik zu machen, indem man Code schreibt, während die Musik spielt: Du änderst eine Zeile, führst sie aus, und der Song ändert sich. Die App aus Teil 9 kann Code ausführen, während sie spielt, aber nicht auf diese Art. Jeder Durchlauf wirft alle Bausteine weg und baut neue. Drück Strg+Enter mitten in einem Takt, und du hörst es: Die Bassnote, die gerade klang, bricht mit einem Knacken ab, ebenso der Ausklang jedes Drum-Sounds, auch wenn du nichts geändert hast.

Nach diesem Teil ändert ein Durchlauf nur, was der Code geändert hat. Eine Basslinie, die du nicht angefasst hast, spielt weiter, als wäre nichts gewesen. Eine geänderte Option wandert zu ihrem neuen Wert, ein neuer Baustein setzt ein, und ein gelöschter wird ausgeblendet. Dieser Teil hat wenig Code. Die Arbeit wurde früher getan, und hier zahlt sie sich aus.

Dieselbe Zeile, dieselbe ID

Ein Durchlauf des Codes macht keinen Ton. Er ergibt einen Patch: eine Liste von Bausteinen, eine Liste von Kabeln und ein Tempo, alles reine Daten. Um so wenig wie möglich zu ändern, muss die Engine wissen, welcher Baustein des neuen Patches welcher der laufenden Bausteine ist. Dafür sind die IDs da. Das Skript aus Teil 9 vergibt sie schon in create(): der Typ des Bausteins und eine Zahl, in der Reihenfolge, in der der Code die Bausteine erzeugt. Der Song, mit dem der Editor startet, ergibt vier:

  • drums1 für drums()

  • pattern1 für das Drum-Pattern

  • monoSynth1 für monoSynth(…)

  • pattern2 für die Basslinie

Eine ID hängt von nichts ab als von dieser Reihenfolge. Die Optionen gehören nicht dazu, der Text eines Patterns nicht und auch nicht der Name der Variable. Wenn du also cutoff änderst und den Code noch einmal ausführst, ist der Synth immer noch monoSynth1, und die Engine weiß, dass es der ist, der gerade spielt.

Mit IDs läuft der Vergleich zweier Patches auf drei Fälle hinaus:

  • Die ID läuft und steht im neuen Patch: Der Baustein bleibt und übernimmt die neuen Optionen.

  • Die ID steht nur im neuen Patch: Der Baustein wird erzeugt.

  • Die ID läuft nur: Der Baustein geht.

Vergleichen statt neu bauen

Um zu sehen, ob ein Durchlauf die Optionen eines Bausteins geändert hat, merkt sich die Engine, was sie jedem zuletzt gegeben hat. Ergänze in src/engine.ts ein Feld in Engine, unter units:

src/engine.ts
/** The options every unit was last given, to see which ones a run changed. */
private readonly options = new Map<string, string>();

Ersetze apply():

src/engine.ts
/**
 * Turns what is playing into a new patch, changing as little as possible. Says how many
 * units stayed, how many are new and how many are gone.
 */
apply(patch: Patch): { kept: number; created: number; removed: number } {
  const count = { kept: 0, created: 0, removed: 0 };
  const wanted = new Set(patch.units.map((spec) => spec.id));

  // 1. Units the code no longer creates fade out and go.
  for (const [id, unit] of this.units) {
    if (id === 'out' || wanted.has(id)) continue;
    unit.dispose();
    this.units.delete(id);
    this.options.delete(id);
    count.removed += 1;
  }

  // 2. Units that are still there keep running, and take over the options that changed.
  //    The rest are new.
  for (const spec of patch.units) {
    const options = JSON.stringify(spec.options);
    const unit = this.units.get(spec.id);
    if (!unit) {
      this.units.set(spec.id, FACTORIES[spec.type](spec.options));
      count.created += 1;
    } else {
      if (options !== this.options.get(spec.id)) unit.update(spec.options);
      count.kept += 1;
    }
    this.options.set(spec.id, options);
  }

  // 3. Cables: unplug every output, then plug in what the patch says. Both happen within
  //    a moment, so as a rule nothing of it is heard.
  for (const unit of this.units.values()) unit.output?.disconnect();
  this.routes = new Map();
  for (const cable of patch.cables) {
    const from = this.units.get(cable.from)!;
    const to = this.units.get(cable.to)!;
    if (cable.kind === 'audio') from.output!.connect(to.input!);
    else this.routes.set(from, [...(this.routes.get(from) ?? []), to]);
  }
  if (patch.bpm !== this.clock.bpm) this.clock.bpm = patch.bpm;
  return count;
}

Schritt 1 entfernt. wanted enthält die IDs des neuen Patches. Ein laufender Baustein, der nicht darunter ist, wird entsorgt und vergessen. out, die Lautsprecher, steht in keinem Patch und bleibt immer.

Schritt 2 behält und erzeugt. Die Optionen eines Bausteins sind Zahlen und Texte, und das Skript schreibt sie immer in der Reihenfolge des Schemas. Zwei Sätze von Optionen sind also genau dann gleich, wenn ihr JSON-Text gleich ist. Weicht der Text vom gemerkten ab, bekommt der Baustein die neuen Optionen über update(). Diese Methode hat jeder Baustein seit Teil 9: Der Mono-Synth bewegt seinen Filter und seine Lautstärke zu den neuen Werten, ein Pattern liest seinen neuen Text. Bisher haben nur die Konstruktoren sie aufgerufen.

Ein Baustein mit unveränderten Optionen wird gar nicht angefasst. Beim Mono-Synth ist das wichtig: Sein update() bewegt den Filter in ein paar Hundertstelsekunden zum Cutoff, und das würde den gezupften Anfang einer Note abschneiden, die in diesem Moment klingt.

Schritt 3 verbindet. Man könnte die Kabel einzeln vergleichen, aber es geht kürzer: jeden Ausgang ausstecken und dann einstecken, was der neue Patch sagt. Der Browser rechnet den Klang in Blöcken von 128 Samples aus, das sind etwa 3 Millisekunden, und eine Änderung an den Verbindungen wirkt zwischen zwei Blöcken, nie mitten in einem. Ausstecken und Einstecken folgen hier in viel kürzerer Zeit aufeinander, als ein Block dauert. In aller Regel fallen also beide zwischen dieselben zwei Blöcke, kein Block wird mit dem fehlenden Kabel berechnet, und von einem Kabel, das bleibt, hört man nicht, dass es gezogen wurde. Die Wege der Noten werden in derselben Schleife neu aufgebaut.

Ein Baustein, den Schritt 1 entfernt hat, steht nicht mehr in units, sein Ausgang wird hier also nicht ausgesteckt. Er behält sein Kabel noch einen Moment, und das braucht er, wie du weiter unten siehst.

Das Tempo wird nur gesetzt, wenn es sich geändert hat, denn das Setzen verschiebt den Anker der Uhr (Teil 2), und ein Durchlauf, der das Tempo in Ruhe lässt, soll auch die Uhr in Ruhe lassen. Am Ende gibt die Methode ihre drei Zähler zurück.

Patterns brauchen nichts

Ein geändertes Pattern ist die Änderung, die du am häufigsten machst, und sie braucht in diesem Teil keinen Code. Das update() eines Patterns parst den neuen Text und tauscht eine Funktion gegen eine andere. Seit Teil 4 ist ein Pattern eine Funktion der Zeit: Es wird nach einem Abschnitt von Zyklen gefragt und antwortet mit den Noten, die darin beginnen. Es hält keine Position und keinen nächsten Schritt, den man ins neue hinüberretten müsste.

Die Uhr zählt durch einen Durchlauf hindurch weiter. Ihre nächste Frage, nach dem nächsten Abschnitt von Zyklen, geht an die neue Funktion statt an die alte, und die Antwort passt zu der Stelle im Takt, an der die Musik gerade ist. Ändere bd*4 auf dem dritten Schlag in bd(3,8), und der neue Rhythmus geht ab dem dritten Schlag weiter. Die Noten der nächsten Zehntelsekunde waren schon an die Instrumente übergeben, das ist die Vorausschau der Uhr. Ein geändertes Pattern hörst du also etwa eine Zehntelsekunde nach dem Ausführen.

Ausblenden statt abschneiden

In Teil 9 hat dispose() einen Baustein sofort ausgesteckt. Klingt gerade eine seiner Noten, wird die Welle mitten in einer Schwingung abgeschnitten, und dieser Sprung ist ein Knacken, wie in Teil 1. Ein Baustein, der geht, dreht sich jetzt zuerst selbst leise. Ersetze in src/drums.ts dispose():

src/drums.ts
/** Fades out, and unplugs once nothing is heard any more. */
dispose() {
  this.output.gain.setTargetAtTime(0, this.context.currentTime, 0.02);
  window.setTimeout(() => this.output.disconnect(), 200);
}

Und in src/monoSynth.ts:

src/monoSynth.ts
/** Fades out, and unplugs once nothing is heard any more. */
dispose() {
  const now = this.context.currentTime;
  this.output.gain.setTargetAtTime(0, now, 0.02);
  this.oscillator.stop(now + 0.2);
  window.setTimeout(() => this.output.disconnect(), 200);
}

setTargetAtTime(0, now, 0.02) lässt die Lautstärke mit einer Zeitkonstante von 0,02 Sekunden gegen 0 fallen: Alle 0,02 Sekunden fällt sie auf etwa 37 % dessen, was sie war. Nach 0,2 Sekunden, zehn davon, ist weniger als ein Zehntausendstel übrig. Dann steckt der Timer den Ausgang aus. setTimeout ist nicht genau, wie Teil 2 gezeigt hat, aber hier hängt nichts davon ab: Bis dahin ist nichts mehr zu hören. Auch der Oszillator des Mono-Synths, der läuft, seit es den Synth gibt, bekommt gesagt, dass er zu diesem Zeitpunkt aufhören soll.

Das dispose() eines Patterns bleibt leer. Es hat keine Knoten.

Sagen, was ein Durchlauf getan hat

apply() gibt seine Zähler zurück, damit die Seite sie zeigen kann. Ersetze in src/main.ts run():

src/main.ts
/** Runs the code in the editor. If it fails, what was playing plays on. */
function run(): boolean {
  try {
    const patch = runScript(editor.state.doc.toString());
    const { kept, created, removed } = engine.apply(patch);
    bpm.textContent = String(patch.bpm);
    status.textContent = `${patch.units.length} units: ${kept} kept, ${created} new, ${removed} removed`;
    status.classList.remove('error');
    return true;
  } catch (error) {
    status.textContent = String(error instanceof Error ? error.message : error);
    status.classList.add('error');
    return false;
  }
}

Die Zeile unter dem Editor sagt jetzt, wie viele Bausteine der Patch hat, wie viele davon behalten wurden und wie viele neu sind, und wie viele der alten entfernt wurden. Schneller siehst du nirgends, ob ein Durchlauf getan hat, was du wolltest.

Probier es aus

Drück Play. Die Statuszeile zeigt 4 units: 0 kept, 4 new, 0 removed. Ändere jetzt den Code, während die Musik spielt, eine Änderung nach der anderen, und drück nach jeder Strg+Enter (Cmd+Enter auf einem Mac):

  • Nichts ändern. Die Zeile zeigt 4 units: 4 kept, 0 new, 0 removed, und die Musik läuft weiter, ohne eine Spur vom Durchlauf. In Teil 9 hat dieselbe Taste jede Note abgeschnitten.

  • Ein Pattern ändern. Mach aus bd*4 ein bd(3,8). Weiterhin 4 kept: Die Bassdrum wechselt ihren Rhythmus von der Stelle im Takt aus, und die Hi-Hats, der Clap und der Bass spielen weiter.

  • Eine Option ändern. Setz cutoff auf 900. Wieder 4 kept: Von einer Note zur nächsten lässt der Bass mehr von seinen hohen Frequenzen durch, und seine Linie fängt nicht von vorn an. Ergänze in den Optionen auch wave: 'square'.

  • Das Tempo ändern. Schreib bpm(140). 4 kept: Die Musik wird schneller, und der Zähler für Takt und Schlag in der Kopfzeile springt nicht.

Füge dann ein zweites Pattern für die Drums ein, eine Cowbell, unter dem ersten:

javascript
const kit = drums()
pattern('bd*4, ~ cp ~ cp, hh*8?0.2').to(kit)
pattern('cb(3,8)').to(kit)
kit.to(out)

Die Zeile zeigt 5 units: 4 kept, 1 new, 0 removed, und die Cowbell setzt an der Stelle im Takt ein, an der die Musik gerade ist. Der neue Baustein ist übrigens nicht die Cowbell. Die Cowbell-Zeile ist jetzt das zweite Pattern im Code, also hat das laufende pattern2 ihren Text bekommen, und die Basslinie spielt aus dem neuen pattern3. Du hörst keinen Unterschied.

  • Den Bass löschen. Entferne seine drei Zeilen: 3 units: 3 kept, 0 new, 2 removed. Der Bass wird im Bruchteil einer Sekunde ausgeblendet, ohne Knacken, und die Drums lassen keinen Schlag aus.

  • Ihn zurückholen. Mach das Löschen mit Strg+Z rückgängig und führ den Code aus: 5 units: 3 kept, 2 new, 0 removed. Der Bass setzt dort ein, wo seine Linie inzwischen wäre.

  • Ein Kabel ziehen. Lösch nur bass.to(out): 5 units: 5 kept, 0 new, 0 removed, und der Bass ist sofort still. Den Synth gibt es noch, und er bekommt weiter seine Noten, aber nichts führt von ihm zu den Lautsprechern.

  • Stoppen und starten. Drück Strg+. und dann wieder Play. Alle Bausteine werden behalten: Sie bleiben, wenn die Musik stoppt.

Drück Play, ändere dann den Code und drück Strg+Enter (Cmd+Enter auf einem Mac), während die Musik spielt. Die Zeile unter dem Editor sagt, was der Durchlauf behalten, erzeugt und entfernt hat. Strg+. stoppt.
In neuem Tab öffnen

Kommentare

Die Kommentare sind GitHub Discussions: Zum Schreiben mit GitHub anmelden.

Die Kommentare kommen über giscus von GitHub. Beim Laden gehen deine IP-Adresse an giscus.app und GitHub.