Zum Inhalt springen

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

Teil 12: Akkorde und Flächen

Bau einen Poly-Synth, der mehrere Noten gleichzeitig spielt: Jede Note bekommt zwei gegeneinander verstimmte Oszillatoren und eine eigene Hüllkurve mit Attack, Decay, Sustain und Release. Akkorde schreibst du in der Mini-Notation, und der neue Baustein braucht nur drei Stellen im Code.

Quest-Ziele

  • Jeder Note eigene Oszillatoren und eine eigene Hüllkurve geben
  • Eine Note mit Attack, Decay, Sustain und Release formen
  • Eine Note behandeln, die vor dem Ende ihres Attacks endet
  • Zwei Oszillatoren um ein paar Cent gegeneinander verstimmen
  • Akkorde in der Mini-Notation schreiben und mit jedem Takt wechseln
  • Eine neue Art von Baustein an drei Stellen ergänzen

Der Mono-Synth aus Teil 8 hat eine Stimme: einen Oszillator, der die ganze Zeit läuft und eine Note nach der anderen spielt. Ein Akkord besteht aus mehreren Noten, die gleichzeitig klingen. Eine Fläche, englisch Pad, ist ein Klang aus langen Akkorden, die langsam kommen und gehen und unter dem Rest der Musik liegen. Beides braucht einen Synth, dessen Noten sich nicht in die Quere kommen: einen Poly-Synth, kurz für polyphon, also vielstimmig.

Eine Stimme pro Note

Der Mono-Synth lässt seine Knoten durchlaufen und bewegt mit jeder Note nur ihre Einstellungen. Das macht einen Slide möglich, und es beschränkt den Synth auf eine Note zur selben Zeit. Der Poly-Synth geht zurück zum Weg aus Teil 1: Jede Note bekommt eigene Knoten, die für sie erzeugt und nach ihr weggeworfen werden.

Eine Note besteht aus zwei Oszillatoren und einem Gain-Knoten, der ihre Lautstärke formt. Alle Noten laufen dann durch einen gemeinsamen Tiefpassfilter, der alles oberhalb seines Cutoffs leiser macht, und durch einen Gain-Knoten für die Lautstärke des Synths. Zwischen den Noten läuft nichts. Lege src/polySynth.ts an. Die Datei beginnt mit den Optionen:

src/polySynth.ts
import { audio, midiToFreq } from './audio.ts';
import type { NoteEvent } from './notes.ts';
import type { Unit } from './unit.ts';

export type PolySynthOptions = {
  /** The shape of the oscillators' wave. */
  wave: OscillatorType;
  /** How far the two oscillators of a note are tuned below and above it, in cents: hundredths of a semitone. */
  detune: number;
  /** The low-pass filter all notes share, in hertz. */
  cutoff: number;
  /** The envelope of a note: seconds to get loud, seconds to fall to the sustain level, */
  attack: number;
  decay: number;
  /** the level a held note stays at, from 0 to 1, and seconds to fade after it ends. */
  sustain: number;
  release: number;
  volume: number;
};

Attack, Decay, Sustain, Release

Wie laut eine Note über ihre Dauer ist, ist ihre Hüllkurve. Die Drums aus Teil 3 haben die kürzeste, die es gibt: sofort oben, dann abfallend. Ein Synth für Akkorde braucht mehr Einfluss darauf. Die Form, die die meisten Synths nutzen, hat vier Teile und heißt nach deren Anfangsbuchstaben: ADSR.

  • Attack: die Zeit, die die Note von der Stille bis zu ihrem Höchstwert braucht. Mit 0,01 Sekunden ist die Note sofort da, mit 0,5 Sekunden schwillt sie an.

  • Decay: die Zeit, in der sie vom Höchstwert auf den Sustain-Pegel fällt.

  • Sustain: keine Zeit, sondern ein Pegel von 0 bis 1. Er ist der Anteil des Höchstwerts, auf dem die Note bleibt, solange sie gehalten wird.

  • Release: die Zeit, in der die Note ausklingt, nachdem sie geendet hat.

Ein kurzer Attack und ein Sustain von 0 ergeben eine gezupfte Note: Sie verstummt von selbst, egal wie lange sie gehalten wird. Ein langer Attack und ein langer Release ergeben eine Fläche. Bei einem Sustain von 1 gibt es nichts, wohin die Note fallen könnte, und sie bleibt auf ihrem Höchstwert, bis sie endet.

Die Klasse folgt in derselben Datei:

src/polySynth.ts
/**
 * Many voices for chords and pads. Unlike the mono synth, nothing runs between the notes:
 * every note gets oscillators and a gain of its own, which are thrown away when it has faded.
 */
export class PolySynth implements Unit {
  private readonly context = audio();
  private readonly filter = this.context.createBiquadFilter();
  readonly output = this.context.createGain();
  private options: PolySynthOptions;

  constructor(options: PolySynthOptions) {
    this.options = options;
    this.filter.type = 'lowpass';
    this.filter.connect(this.output);
    this.update(options);
  }

  update(options: PolySynthOptions) {
    this.options = options;
    const now = this.context.currentTime;
    this.filter.frequency.setTargetAtTime(options.cutoff, now, 0.02);
    this.output.gain.setTargetAtTime(options.volume, now, 0.02);
  }

  play(event: NoteEvent) {
    if (event.note === undefined) return;
    const { wave, detune, attack, decay, sustain, release } = this.options;
    const { time } = event;
    const off = time + event.duration;
    const peak = event.velocity * (event.accent ? 0.3 : 0.2);

    // Attack, decay, sustain, release: the four parts of a note's loudness.
    const envelope = this.context.createGain();
    const gain = envelope.gain;
    gain.setValueAtTime(0, time);
    if (off <= time + attack) {
      // The note ends before it got loud: rise as far as it gets.
      gain.linearRampToValueAtTime((peak * (off - time)) / attack, off);
    } else {
      gain.linearRampToValueAtTime(peak, time + attack);
      gain.setTargetAtTime(peak * sustain, time + attack, decay / 3);
    }
    gain.setTargetAtTime(0, off, release / 3);
    envelope.connect(this.filter);

    // Two oscillators a little apart in pitch sound wider than one.
    const end = off + release * 2;
    for (const cents of [-detune, detune]) {
      const oscillator = this.context.createOscillator();
      oscillator.type = wave;
      oscillator.frequency.value = midiToFreq(event.note);
      oscillator.detune.value = cents;
      oscillator.connect(envelope);
      oscillator.start(time);
      oscillator.stop(end);
    }
  }

  /** 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);
  }
}

play() rechnet zuerst aus, wann die Note endet, off, und wie laut sie wird, peak: ihre Anschlagstärke mal 0,2, mit einem Akzent (:a) mal 0,3. Das ist mit Absicht wenig. Die Noten eines Akkords addieren sich, und ein Akkord aus drei Noten besteht aus sechs Oszillatoren.

Die Hüllkurve ist ein Gain-Knoten, der für diese eine Note erzeugt wird. Sein Wert beginnt bei 0 und steigt während des Attacks in einer geraden Linie zum Höchstwert. Von dort bewegt ihn setTargetAtTime() zum Sustain-Pegel. Diese Methode nähert sich ihrem Ziel erst schnell und dann immer langsamer. Ihr letztes Argument, die Zeitkonstante, ist die Zeit, in der sie etwa 63 % des Wegs zurücklegt, und nach drei Zeitkonstanten sind es 95 %. decay / 3 heißt also: Nach decay Sekunden ist der Pegel so gut wie dort. Wenn die Note endet, bewegt dieselbe Methode den Pegel gegen 0, mit release / 3.

Die Oszillatoren erfahren schon beim Start, wann sie aufhören: release * 2 nach dem Ende der Note. Bis dahin ist der Pegel auf ein Viertelprozent dessen gefallen, was er war, und man hört nichts, wenn sie abgeschnitten werden. Danach hält nichts mehr die Knoten der Note fest, und sie werden weggeworfen.

update() bewegt die zwei Dinge, die durchlaufen, den Filter und die Lautstärke, zu ihren neuen Werten. Alle anderen Optionen liest die nächste Note. Ändere attack, während ein Akkord klingt, und dieser Akkord behält die Hüllkurve, mit der er begonnen hat.

dispose() ist das der anderen Instrumente seit Teil 10: ausblenden, dann ausstecken. Ein stop() gibt es nicht, Stop bringt den Poly-Synth also nicht zum Schweigen. Eine Note wird als Ganzes eingeplant, samt ihrem Ende, und der Synth behält nichts, womit er eine Note zurücknehmen könnte. Drück mitten in einem Takt auf Stop, und der Akkord dieses Takts klingt, bis der Takt vorbei ist, und klingt dann aus.

Eine Note, die zu früh endet

Ein Fall braucht Sorgfalt: eine Note, die endet, bevor ihr Attack vorbei ist. Nimm einen Attack von 0,5 Sekunden und Achtelnoten, also acht Noten pro Takt. Bei 124 Schlägen pro Minute dauert eine Achtel 0,24 Sekunden.

Es sieht so aus, als würde der Release bei off das erledigen. Aber ein AudioParam ordnet, was man ihm sagt, nach den Zeitpunkten und nicht nach der Reihenfolge der Aufrufe. Der Release bei off würde vor dem Ende des Attacks einsortiert, und der Decay käme nach beiden und hätte das letzte Wort. Der Pegel würde sich auf den Sustain-Pegel einstellen, und die Note bliebe dort hängen, bis ihre Oszillatoren abgeschnitten werden.

Also fragt play() zuerst. Endet die Note innerhalb des Attacks, geht die Rampe nur so weit, wie die Note kommt. Eine gerade Linie von 0 bis peak über attack Sekunden hat peak × (off − time) / attack erreicht, wenn die Note endet. Dort endet die Rampe, und von dort startet der Release. Decay und Sustain fallen weg, weil die Note nie bis zu ihnen kommt. Die Achtelnote von oben erreicht 48 % ihres Höchstwerts: Kurze Noten auf einem langsamen Synth sind leiser.

Zwei Oszillatoren, ein paar Cent auseinander

Die Welle eines einzelnen Oszillators ist in jeder Schwingung gleich. Der Poly-Synth gibt jeder Note zwei Oszillatoren und verstimmt sie ein wenig gegeneinander: Einer liegt detune Cent unter der Note, der andere ebenso viele darüber. Ein Cent ist ein Hundertstel eines Halbtons, und ein Halbton ist der Schritt von einer Taste eines Klaviers zur nächsten. 12 Halbtöne oder 1200 Cent ergeben eine Oktave. Ein Oszillator hat dafür einen eigenen Parameter, detune, in Cent, neben frequency in Hertz.

Mit dem Standardwert 8 wird das A bei 220 Hertz (a3) zu zwei Wellen von etwa 219 und 221 Hertz. Das ist zu nah, um als zwei Noten gehört zu werden. Stattdessen driften die beiden Wellen gegeneinander: In einem Moment addieren sich ihre Schwingungen, einen Moment später löschen sie sich zum Teil aus, hier etwa zweimal pro Sekunde. Die Note verändert sich ständig, wo ein einzelner Oszillator stillstehen würde, und jede Note eines Akkords tut das in ihrem eigenen Tempo. Mit detune: 0 spielen beide Oszillatoren dieselbe Welle, und nichts bewegt sich. Bei 50, dem höchsten Wert, liegen die beiden einen ganzen Halbton auseinander.

Akkorde in der Mini-Notation

Die Sprache braucht für Akkorde nichts Neues. Seit Teil 5 legt ein Komma Ebenen übereinander: So spielt bd*4, ~ cp ~ cp Bassdrum und Clap gleichzeitig. In eckigen Klammern werden die Ebenen zu einem Schritt. [a3,c4,e4] ist ein Schritt mit drei Noten, ein Akkord. Für die Engine sind das drei Noten, die zur selben Zeit beginnen. Jede wird an play() übergeben, und jede bekommt eine Stimme.

Ein Akkord ist ein Schritt wie jeder andere, also funktioniert der Rest der Mini-Notation mit ihm:

  • [a3,c4,e4] [f3,a3,c4]: zwei Akkorde pro Takt, jeder einen halben Takt lang.

  • [a3,c4,e4]*4: der Akkord viermal pro Takt.

  • <[a3,c4,e4] [f3,a3,c4]>: ein Akkord pro Takt. <…> nimmt in jedem Zyklus den nächsten seiner Schritte, der Akkord wechselt also mit jedem Takt.

Ein neuer Baustein an drei Stellen

Die Klasse ist die erste Stelle. Die zweite ist das Schema. Die zwei Synths bieten dieselben Wellen an, also bekommt die Liste einen Namen. Ergänze in src/schema.ts über volume:

src/schema.ts
const WAVES = ['sawtooth', 'square', 'triangle', 'sine'] as const;

Ersetze im Eintrag von monoSynth die Zeile von wave, damit sie die Liste nutzt:

src/schema.ts
wave: { doc: "The oscillator's wave.", default: 'sawtooth', choices: WAVES },

Und ergänze den Poly-Synth in UNITS, unter monoSynth:

src/schema.ts
polySynth: {
  doc: 'Many voices for chords and pads. [c3,e3,g3] in a pattern plays three notes at once.',
  takes: 'notes',
  gives: 'audio',
  options: {
    wave: { doc: "The oscillators' wave.", default: 'sawtooth', choices: WAVES },
    detune: { doc: 'How far the two oscillators of a note are tuned below and above it, in cents.', default: 8, min: 0, max: 50 },
    cutoff: { doc: 'The low-pass filter all notes share, in hertz.', default: 2500, min: 50, max: 16000 },
    attack: { doc: 'How long a note takes to get loud, in seconds.', default: 0.01, min: 0.001, max: 2 },
    decay: { doc: 'How long it takes to fall to the sustain level, in seconds.', default: 0.2, min: 0.01, max: 2 },
    sustain: { doc: 'The level a held note stays at, from 0 to 1.', default: 0.6, min: 0, max: 1 },
    release: { doc: 'How long a note fades after it ends, in seconds.', default: 0.3, min: 0.01, max: 4 },
    volume,
  },
},

Dieser Eintrag leistet viel. Das Skript baut seine API aus UNITS, also hat der Code im Editor ab jetzt eine Funktion polySynth(). Die Prüfungen aus Teil 11 kennen seine Optionen, ihre Bereiche und die Wellen und schlagen für atack attack vor. Und takes und gives sagen, welche Kabel passen.

Die dritte Stelle ist die Engine, die wissen muss, wie so ein Baustein erzeugt wird. Ergänze in src/engine.ts eine Zeile in FACTORIES, und importiere PolySynth und den Typ PolySynthOptions aus ./polySynth.ts:

src/engine.ts
/**
 * How a unit of each type is made. A patch holds its options as plain data. The script
 * filled in every option the schema lists, so here they are taken for what each unit expects.
 */
const FACTORIES: Record<string, (options: Options) => Unit> = {
  pattern: (options) => new Player(options as PlayerOptions),
  drums: (options) => new Drums(options as DrumsOptions),
  monoSynth: (options) => new MonoSynth(options as MonoSynthOptions),
  polySynth: (options) => new PolySynth(options as PolySynthOptions),
};

Das ist alles. Die Engine aus Teil 10 behandelt den neuen Baustein wie die anderen: Sie behält ihn von Durchlauf zu Durchlauf, übergibt ihm geänderte Optionen und blendet ihn aus, wenn seine Zeile gelöscht wird. Jeder Baustein, der in dieser Serie noch folgt, kommt über dieselben drei Stellen herein.

Der Song

Der Song bekommt eine dritte Stimme. Ersetze src/song.ts:

src/song.ts
/** The code the editor starts with. */
export const SONG = `bpm(124)

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

const bass = monoSynth({ cutoff: 300, resonance: 8 })
pattern('a1 a1:a [a2:s c2] <e2:s g2:as>').to(bass)
bass.to(out)

const keys = polySynth({ release: 0.6, cutoff: 1800 })
pattern('<[a3,c4,e4] [f3,a3,c4] [c3,e3,g3] [g3,b3,d4]>').to(keys)
keys.to(out)
`;

Der Poly-Synth klingt länger aus als mit seinem Standardwert und hat seinen Filter etwas tiefer. Sein Pattern enthält vier Akkorde aus je drei Noten, einen pro Takt: a-Moll, F-Dur, C-Dur und G-Dur. Nach vier Takten beginnt es von vorn.

Probier es aus

Drück Play. Unter den Drums und dem Bass klingt ein Akkord, der mit jedem Takt wechselt, und die Statuszeile zeigt 6 units: 0 kept, 6 new, 0 removed. Mach dann aus den Akkorden eine Fläche. Ändere die letzten drei Zeilen und drück Strg+Enter:

javascript
const keys = polySynth({ attack: 0.5, release: 2, cutoff: 1800 })
pattern('<[a3,c4,e4] [f3,a3,c4] [c3,e3,g3] [g3,b3,d4]>').to(keys)
keys.to(out)

Ab dem nächsten Takt schwillt jeder Akkord über eine halbe Sekunde an. Wenn der Takt wechselt, klingt der alte Akkord noch aus, während der neue ansteigt, die beiden überlappen sich also. Jetzt das Gegenteil, kurze gezupfte Akkorde:

javascript
const keys = polySynth({ sustain: 0, decay: 0.3, cutoff: 1800 })
pattern('<[a3,c4,e4] [f3,a3,c4] [c3,e3,g3] [g3,b3,d4]>*4').to(keys)
keys.to(out)

*4 macht das Pattern viermal so schnell, also werden in jedem Takt alle vier Akkorde gespielt, einer pro Schlag. Jeder verstummt nach etwa einer Drittelsekunde, obwohl sein Schritt länger dauert. Mehr zum Ausprobieren:

  • Ergänze in den Optionen detune: 0, dann detune: 25. Mit 0 stehen die Noten still. Mit 25 schwanken sie etwa dreimal so schnell wie mit dem Standardwert 8.

  • Setz attack: 0.5 und schreib im Pattern *8 statt *4. Die Akkorde werden leiser: Jede Note endet, bevor sie die Hälfte ihres Anstiegs geschafft hat.

  • Setz cutoff auf 600, während ein Akkord klingt. Der Filter bewegt sich ohne Knacken, und der Akkord verliert seine hohen Frequenzen.

  • Schreib atack statt attack. Die Statuszeile zeigt Line 11: polySynth has no option "atack". Did you mean attack?, und die Musik spielt weiter.

  • Lösch die drei Zeilen des Poly-Synths und führ den Code aus. Der Akkord wird ausgeblendet, und die Zeile zeigt 4 units: 4 kept, 0 new, 2 removed.

Drück Play: Akkorde unter den Drums und dem Bass. Ändere die Optionen von polySynth, etwa attack, release oder detune, und drück Strg+Enter (Cmd+Enter auf einem Mac).
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.