Zum Inhalt springen

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

Teil 8: Ein Synth für Bass und Lead

Bau einen Mono-Synth für Basslinien und Leads: ein Oszillator, ein Tiefpassfilter und ein Gain-Knoten, die die ganze Zeit laufen, und Noten, die nur ihre Einstellungen bewegen. Notennamen werden zu MIDI-Nummern, und zwei Markierungen in der Notation bringen Akzente und Slides.

Quest-Ziele

  • Notennamen wie c2 und f#2 in MIDI-Notennummern umrechnen
  • Eine Synth-Stimme aus Oszillator, Tiefpassfilter und Gain-Knoten bauen, die nie anhalten
  • Eine Einstellung mit setTargetAtTime und seiner Zeitkonstante auf ein Ziel zubewegen
  • Jeder Note mit einer Hüllkurve auf dem Filter einen gezupften Anfang geben
  • Akzente und Slides mit Markierungen im Pattern ergänzen
  • Drums und Synth über dieselbe Art von Noten-Ereignis spielen

Die Notation ist seit Teil 7 vollständig, aber sie spielt nur Drums, und Drums haben keine Melodie. Dieser Teil baut einen Synth, ein Instrument, das seinen Klang aus einem Oszillator erzeugt, für Basslinien und Leads: die tiefen Noten unter einem Stück und die Melodie darüber. Gespielt wird er von derselben Notation. Wo ein Drum-Pattern bd sd sagt, sagt eine Basslinie a1 c2.

Noten und ihre Nummern

Teil 1 hat mit midiToFreq() aus MIDI-Notennummern Frequenzen gemacht: eine ganze Zahl pro Taste eines Klaviers, 69 für das A mit 440 Hz. Eine Basslinie in Zahlen will niemand schreiben, also stehen in den Patterns Namen. Ein Name ist einer der Buchstaben c, d, e, f, g, a und b, gefolgt von der Nummer der Oktave. Es sind die englischen Namen: b ist das deutsche H. Eine Oktave ist der Abstand von einer Note zu der mit der doppelten Frequenz, und sie ist in zwölf Schritte geteilt, die Halbtöne. Ein # nach dem Buchstaben erhöht die Note um einen Halbton, ein b senkt sie um einen: f#2, eb3.

Ein Instrument braucht mehr als eine Tonhöhe. Es muss wissen, wann die Note beginnt, wie lang sie dauert und wie fest sie gespielt wird. All das kommt in ein Objekt, das NoteEvent, und alles, was solche Ereignisse spielen kann, ist ein Instrument. Lege src/notes.ts an:

src/notes.ts
import type { Atom } from './mini.ts';

/** A note or a drum hit, at a time of the audio clock. */
export interface NoteEvent {
  time: number;
  /** How long the step is that the note fills, in seconds. */
  duration: number;
  /** The step as it was written, without tags: the name of a drum sound, or of a note. */
  sound: string;
  /** The MIDI note number, if the step is a note. */
  note: number | undefined;
  /** How hard the note is played, from 0 to 1. */
  velocity: number;
  accent: boolean;
  slide: boolean;
}

/** Something that turns note events into sound. */
export interface Instrument {
  play(event: NoteEvent): void;
  /** Called when the music stops: let go of every note that is still held. */
  stop(): void;
}

Auch ein Anschlag der Drums ist ein Noten-Ereignis: Sein sound ist bd, und er hat keine note. Die Datei geht mit den Namen weiter:

src/notes.ts
const SEMITONES: Record<string, number> = { c: 0, d: 2, e: 4, f: 5, g: 7, a: 9, b: 11 };

/** The MIDI note number of a name such as c3, f#2 or eb4. C4 is 60. */
export function noteToMidi(name: string): number | undefined {
  const match = /^([a-g])([#b]?)(\d)$/i.exec(name);
  if (!match) return undefined;
  const shift = match[2] === '#' ? 1 : match[2] === 'b' ? -1 : 0;
  return 12 * (Number(match[3]) + 1) + SEMITONES[match[1].toLowerCase()] + shift;
}

/**
 * Reads a step of a pattern: `c2` and `48` are notes, `bd` is a sound. After a colon come
 * the tags: `c2:a` is played with an accent, `c2:s` slides into the next note, `c2:as` both.
 */
export function readAtom(atom: Atom): Pick<NoteEvent, 'sound' | 'note' | 'accent' | 'slide'> {
  if (typeof atom === 'number') return { sound: String(atom), note: atom, accent: false, slide: false };
  const [sound = '', tags = ''] = atom.split(':');
  const number = Number(sound);
  return {
    sound,
    note: Number.isFinite(number) ? number : noteToMidi(sound),
    accent: tags.includes('a'),
    slide: tags.includes('s'),
  };
}

noteToMidi() nimmt einen Buchstaben, wahlweise ein # oder b, und eine Ziffer an. c4 ist 12 × 5 + 0 = 60, und a1 ist 12 × 2 + 9 = 33, woraus midiToFreq() 55 Hz macht. Alles andere, etwa bd, ergibt undefined: keine Note.

readAtom() liest einen Schritt eines Patterns. Eine Zahl gilt als MIDI-Notennummer. Ein Wort wird am Doppelpunkt geteilt: Davor steht der Name, danach stehen die Markierungen, a für einen Akzent und s für einen Slide. Was sie mit dem Klang machen, kommt weiter unten. Der Tokenizer braucht keine Änderung, denn er zählt # und : schon zu den Buchstaben eines Worts. f#2:a kommt hier also als ein Schritt an.

Eine Stimme, die nie anhält

Die Drums aus Teil 3 bauen für jeden Anschlag neue Knoten und werfen sie weg. Das passt zu Klängen, die beginnen, verklingen und vorbei sind. Eine Basslinie ist anders: Sie ist eine Stimme, und eine Note führt in die nächste. Ein Synth mit einer einzigen Stimme heißt Mono-Synth. Er spielt eine Note nach der anderen, und eine neue Note löst die vorige ab.

Dieser Synth baut seine Knoten deshalb einmal, und sie laufen, solange es den Synth gibt:

  • Ein Oszillator erzeugt die Welle. Der Bass dieses Teils nimmt einen Sägezahn, eine Welle, die die Frequenz der Note und jedes ganze Vielfache davon enthält.

  • Ein Tiefpassfilter lässt die Frequenzen unter seinem Cutoff, der Grenzfrequenz, durch und macht die darüber leiser. Er entscheidet, wie viele der Vielfachen des Sägezahns zu hören sind. Seine Resonanz hebt die Frequenzen direkt am Cutoff an.

  • Ein Gain-Knoten, das gate, ist zwischen den Noten zu und wird für jede Note geöffnet.

  • Ein zweiter Gain-Knoten ist die Lautstärke des ganzen Synths.

Eine Note startet keinen davon. Sie bewegt ihre Einstellungen: die Frequenz des Oszillators, den Cutoff des Filters, die Lautstärke des Gates.

Eine Einstellung auf ein Ziel zubewegen

Die Rampen aus Teil 1 führen vom zuvor eingeplanten Wert zu einem neuen Wert an einem festen Zeitpunkt. Hier ist das ein Problem. Wenn eine Note beginnt, kann das Gate irgendwo stehen: zu, offen oder mitten im Ausklingen der Note davor. Eine Rampe müsste das wissen.

setTargetAtTime(target, startTime, timeConstant) muss es nicht. Ab startTime bewegt sich der Wert auf target zu, von dort, wo er in diesem Moment steht, zuerst schnell und dann immer langsamer. Die Zeitkonstante sagt in Sekunden, wie schnell: Nach einer Zeitkonstante hat der Wert etwa 63 Prozent des Wegs zum Ziel zurückgelegt, nach drei etwa 95 Prozent, nach fünf mehr als 99. Genau kommt er nie an, aber der Rest ist bald zu klein, um ihn zu hören.

Das Gate öffnet mit einer Zeitkonstante von 0,003. Nach 3 Millisekunden ist es zu 63 Prozent offen, nach 9 Millisekunden zu 95 Prozent. Das ist schnell genug, um wie ein sofortiger Anfang zu klingen, und langsam genug, um nicht zu knacken, was ein Sprung in der Lautstärke täte.

Der Synth

Lege src/monoSynth.ts an. Die Datei beginnt mit den Optionen:

src/monoSynth.ts
import { audio, midiToFreq } from './audio.ts';
import type { Instrument, NoteEvent } from './notes.ts';

export type MonoSynthOptions = {
  /** The shape of the oscillator's wave. */
  wave: OscillatorType;
  /** Where the filter rests, in hertz. Everything above it is turned down. */
  cutoff: number;
  /** How much the filter emphasizes the frequencies around its cutoff. */
  resonance: number;
  /** How far every note opens the filter, in octaves above the cutoff. */
  envelope: number;
  /** How long the filter takes to fall back, in seconds. */
  decay: number;
  volume: number;
};

/** The highest frequency the filter is opened to, in hertz. */
const CEILING = 16000;

Die Optionen sind als type geschrieben und nicht als interface. Noch macht das keinen Unterschied. Teil 9 hat dafür eine Verwendung. Die Klasse folgt in derselben Datei:

src/monoSynth.ts
/**
 * One voice for bass lines and leads: an oscillator, a low-pass filter that every note
 * opens for a moment, and a gain that lets the note through. All three run the whole time.
 * A note doesn't start them, it only moves their settings.
 */
export class MonoSynth implements Instrument {
  private readonly context = audio();
  private readonly oscillator = this.context.createOscillator();
  private readonly filter = this.context.createBiquadFilter();
  private readonly gate = this.context.createGain();
  private readonly volume = this.context.createGain();
  private options: MonoSynthOptions;
  /** When the last note slides: the time at which it ends, and the next one takes over. */
  private slideEnd: number | undefined;

  constructor(output: AudioNode, options: MonoSynthOptions) {
    this.options = options;
    this.filter.type = 'lowpass';
    this.gate.gain.value = 0;
    this.oscillator.connect(this.filter).connect(this.gate).connect(this.volume).connect(output);
    this.oscillator.start();
    this.update(options);
  }

  update(options: MonoSynthOptions) {
    this.options = options;
    const now = this.context.currentTime;
    this.oscillator.type = options.wave;
    this.filter.Q.setTargetAtTime(options.resonance, now, 0.02);
    this.filter.frequency.setTargetAtTime(options.cutoff, now, 0.02);
    this.volume.gain.setTargetAtTime(options.volume, now, 0.02);
  }

  play(event: NoteEvent) {
    if (event.note === undefined) return;
    const { time } = event;
    const hz = midiToFreq(event.note);
    const end = time + event.duration;

    if (this.slideEnd !== undefined && time <= this.slideEnd + 0.005) {
      // The note before slides into this one: take back its release, and glide to the new pitch.
      this.gate.gain.cancelScheduledValues(this.slideEnd - 0.001);
      this.oscillator.frequency.setTargetAtTime(hz, time, 0.02);
    } else {
      this.oscillator.frequency.setValueAtTime(hz, time);
      // An accent is louder, and opens the filter an octave further.
      this.gate.gain.setTargetAtTime(event.velocity * (event.accent ? 1 : 0.6), time, 0.003);
      const octaves = this.options.envelope + (event.accent ? 1 : 0);
      const peak = Math.min(CEILING, this.options.cutoff * 2 ** octaves);
      this.filter.frequency.setValueAtTime(peak, time);
      this.filter.frequency.setTargetAtTime(this.options.cutoff, time, this.options.decay / 3);
    }

    this.gate.gain.setTargetAtTime(0, end, 0.015);
    this.slideEnd = event.slide ? end : undefined;
  }

  stop() {
    const now = this.context.currentTime;
    this.gate.gain.cancelScheduledValues(now);
    this.gate.gain.setTargetAtTime(0, now, 0.015);
    this.slideEnd = undefined;
  }

  dispose() {
    this.oscillator.stop();
    this.volume.disconnect();
  }
}

Der Konstruktor steckt die vier Knoten in eine Reihe und startet den Oszillator, bei geschlossenem Gate. connect() gibt den Knoten zurück, mit dem es verbunden hat, also ist die Reihe eine einzige Kette von Aufrufen.

update() übernimmt einen Satz Optionen. Es bewegt den Filter und die Lautstärke mit einer Zeitkonstante von 0,02 auf ihre neuen Werte zu, damit eine Änderung nicht knackt. dispose() stoppt den Oszillator und steckt den Synth ab. Von außen ruft diese beiden noch nichts auf. Das tut die Engine der nächsten zwei Teile.

Eine Note und ihr gezupfter Anfang

Der zweite Zweig von play() ist der Normalfall, eine Note, die neu beginnt. Zu ihrem Zeitpunkt passieren drei Dinge:

  • Die Tonhöhe springt auf die Frequenz der Note.

  • Das Gate öffnet, auf das 0,6-Fache der velocity der Note.

  • Der Cutoff des Filters springt nach oben und fällt zurück.

Das dritte formt den Klang. Der Verlauf, den ein Wert über eine Note nimmt, heißt Hüllkurve. In Teil 1 war es die Lautstärke, hier ist es der Cutoff. envelope sagt in Oktaven, wie weit er nach oben springt. Eine Oktave höher verdoppelt eine Frequenz. Bei einem Cutoff von 300 Hz und einer Hüllkurve von 3 öffnet der Filter also bis 300 × 2 × 2 × 2 = 2400 Hz. CEILING hält ihn bei höchstens 16000 Hz.

Von dort fällt der Cutoff mit setTargetAtTime() zurück. Die Zeitkonstante ist ein Drittel von decay, nach decay Sekunden hat er also 95 Prozent des Wegs hinter sich. Was du hörst: Jede Note beginnt hell und wird im Bruchteil einer Sekunde dumpf, wie eine gezupfte Saite.

Nach beiden Zweigen wird das Ende der Note eingeplant. Bei end schließt das Gate mit einer Zeitkonstante von 0,015. Dieses Ausklingen ist der Release der Note.

Akzent und Slide

Ein Akzent hebt eine Note von den anderen ab. a1:a öffnet das Gate ganz statt auf 0,6 und öffnet den Filter eine Oktave weiter. Die Note ist lauter und heller.

Ein Slide bindet eine Note an die nächste. a2:s c2 spielt das a2, und in dem Moment, in dem das c2 fällig ist, beginnt der Klang nicht neu: Die Tonhöhe gleitet zum c2 hinunter, und der Ton läuft weiter. Dafür merkt sich eine Note mit Slide in slideEnd, wann sie endet. Die nächste Note vergleicht ihre eigene Zeit damit. Beginnt sie dort, nimmt sie den ersten Zweig von play() und tut zwei Dinge:

  • Sie nimmt den Release der Note davor zurück. cancelScheduledValues(time) entfernt jede Änderung, die auf einem Parameter zu dieser Zeit oder später eingeplant ist. Der Release war für slideEnd eingeplant, also ist er weg, und das Gate bleibt offen.

  • Sie gleitet zur neuen Tonhöhe, mit setTargetAtTime() und einer Zeitkonstante von 0,02: Nach 20 Millisekunden hat die Tonhöhe 63 Prozent des Wegs zurückgelegt.

Der Filter wird nicht noch einmal geöffnet, und das Gate bleibt, wie es ist. Eine Note, in die hineingeglitten wird, hat keinen eigenen gezupften Anfang, und ein Akzent auf ihr ändert nichts. Sie endet wie jede andere Note: Ihr eigener Release wird an ihrem eigenen Ende eingeplant.

Dass sich der Release zurücknehmen lässt, liegt an der Uhr aus Teil 2. Noten werden einen Moment früher eingeplant, als sie zu hören sind. Wenn die nächste Note eingeplant wird, steht der Release der Note davor im Plan, aber er hat noch nicht begonnen.

Das Ende der einen Note und der Anfang der nächsten werden auf zwei verschiedenen Wegen ausgerechnet, und durch Gleitkommazahlen können sie um eine Winzigkeit auseinanderliegen. Deshalb lässt der Vergleich 5 Millisekunden zu, und das Entfernen setzt 1 Millisekunde früher an.

stop() ist für den Stop-Button: Es entfernt, was auf dem Gate eingeplant ist, und schließt es.

Die Drums nehmen dieselben Ereignisse

Die Seite soll beide Instrumente gleich behandeln, also werden auch die Drums ein Instrument. Importiere in src/drums.ts die Typen Instrument und NoteEvent aus ./notes.ts und ergänze in der ersten Zeile der Klasse implements Instrument, zwischen Drums und der Klammer. Ersetze dann den Kopf von play(). Die Fälle bleiben, wie sie sind:

src/drums.ts
play(event: NoteEvent) {
  const { time, velocity } = event;
  switch (event.sound) {

Die Drums halten nur einen Sound fest, die offene Hi-Hat, die noch klingt. Beim Stoppen wird sie abgeschnitten. Ergänze stop() über choke():

src/drums.ts
stop() {
  this.choke(this.context.currentTime);
}

Zwei Zeilen auf der Seite

Die Seite bekommt ein Eingabefeld pro Instrument. Ersetze in index.html das Element <main>:

index.html
<main class="stage">
  <div class="line">
    <label for="drums">drums</label>
    <input id="drums" value="bd*4, ~ cp ~ cp, hh*8?0.2" spellcheck="false" autocomplete="off" />
    <p class="message"></p>
  </div>
  <div class="line">
    <label for="bass">bass</label>
    <input id="bass" value="a1 a1:a [a2:s c2] &lt;e2:s g2:as&gt;" spellcheck="false" autocomplete="off" />
    <p class="message"></p>
  </div>
  <p class="hint">Notes: c2, f#2, eb3 · c2:a is an accent, c2:s slides into the next note</p>
</main>

Die Meldungen haben keine IDs mehr. Jede Meldung wird als das Element nach ihrem Eingabefeld gefunden. Ändere in src/style.css den gap von .stage von 16px auf 8px und ergänze über der Regel für .line input eine Regel für die Beschriftungen:

src/style.css
.line label {
  display: block;
  margin-bottom: 4px;
  color: var(--muted);
}

In src/main.ts bleiben der Tempo-Regler und die Positionsanzeige am Ende stehen. Ersetze alles darüber, von den Imports bis zum Handler des Play-Buttons, durch die nächsten drei Blöcke. Der erste erzeugt die Instrumente:

src/main.ts
import { audio } from './audio.ts';
import { Clock } from './clock.ts';
import { Drums } from './drums.ts';
import { mini, MiniError, type Atom } from './mini.ts';
import { MonoSynth } from './monoSynth.ts';
import { readAtom, type Instrument } from './notes.ts';
import type { Pattern } from './pattern.ts';
import './style.css';

/** A line of the page: a pattern and the instrument that plays it. */
interface Line {
  instrument: Instrument;
  pattern: Pattern<Atom>;
}

const output = audio().destination;
const bass = new MonoSynth(output, {
  wave: 'sawtooth',
  cutoff: 300,
  resonance: 8,
  envelope: 3,
  decay: 0.2,
  volume: 0.5,
});

const lines: Line[] = [
  line('#drums', new Drums(output)),
  line('#bass', bass),
];

Der Bass ist ein Sägezahn mit dem Filter bei 300 Hz, den jede Note um drei Oktaven öffnet. line() wird hier aufgerufen und steht weiter unten. JavaScript erlaubt das bei Funktionen, die mit function deklariert sind. Sie folgt als Nächstes:

src/main.ts
/** Connects an input of the page to an instrument. */
function line(selector: string, instrument: Instrument): Line {
  const input = document.querySelector<HTMLInputElement>(selector)!;
  const message = input.nextElementSibling!;
  const result: Line = { instrument, pattern: mini(input.value) };

  // Every key stroke is read. A pattern that can't be read leaves the last good one playing.
  input.addEventListener('input', () => {
    try {
      result.pattern = mini(input.value);
      message.textContent = '';
    } catch (error) {
      if (!(error instanceof MiniError)) throw error;
      // Point at the place of the mistake, under the input's text.
      message.textContent = `${' '.repeat(error.position)}^ ${error.message}`;
    }
  });
  return result;
}

Das ist der Input-Handler aus Teil 5, einmal pro Zeile. Jede Zeile behält ihr eigenes letztes gültiges Pattern und zeigt ihre eigene Meldung. Die Uhr fragt alle Zeilen:

src/main.ts
const clock = new Clock((from, to) => {
  for (const { instrument, pattern } of lines) {
    for (const hap of pattern(from, to)) {
      instrument.play({
        ...readAtom(hap.value),
        time: clock.timeAt(hap.begin),
        duration: (hap.end - hap.begin) * clock.cycleSeconds,
        velocity: 1,
      });
    }
  }
});

const play = document.querySelector<HTMLButtonElement>('#play')!;
play.addEventListener('click', async () => {
  await audio().resume();
  if (clock.playing) {
    clock.stop();
    for (const { instrument } of lines) instrument.stop();
  } else {
    clock.start();
  }
  play.textContent = clock.playing ? '■ Stop' : '▶ Play';
  play.classList.toggle('on', clock.playing);
});

Aus jedem Ereignis eines Patterns wird ein NoteEvent. readAtom() liefert den Sound, die Note und die Markierungen. Die Uhr liefert die Zeit und die Länge des Schritts in Sekunden: seine Länge in Zyklen mal die Sekunden eines Zyklus. Wenn die Musik stoppt, erfährt es jedes Instrument.

Keines der Instrumente beschwert sich über das, was es geschickt bekommt. Der Synth übergeht einen Schritt, der keine Note ist, und die Drums übergehen einen Namen, den sie nicht kennen. bd in der Basslinie bleibt still, c2 bei den Drums ebenso.

Probier es aus

Drück Play. Der Bass spielt a1 a1:a [a2:s c2] <e2:s g2:as> unter den Drums. Eine Note, die neu beginnt, fängt hell an und schließt sich: der gezupfte Anfang. Die zweite Note hat den Akzent und ist lauter und heller als die erste. Im dritten Schritt gleitet das a2 ohne neuen Anfang zum c2 hinunter. Der letzte Schritt ist in einem Takt ein e2 und im nächsten ein g2 mit Akzent, und beide gleiten hinunter in das a1, mit dem der folgende Takt beginnt.

  • Entferne das :s von a2:s. Das c2 bekommt seinen eigenen gezupften Anfang.

  • Tipp c2:s g2:s c3:s g2 ein. Pro Takt wird einmal gezupft, und die Tonhöhe gleitet von Note zu Note.

  • Tipp a1*8 ein, dann a1:a*8: acht einfache Noten, dann acht mit Akzent.

  • Die ganze Notation funktioniert mit Noten. Probier a1(3,8), a1 [c2 e2] a2 <g2 f#2> und {a1 c2 e2}%8, das drei Noten über acht Schritte laufen lässt.

  • Tipp beim Bass a1 [c2 ein. Die Meldung erscheint unter diesem Eingabefeld, und der Bass spielt sein letztes gültiges Pattern weiter, während du den Fehler behebst.

Wenn du mitbaust, ändere die Optionen des Basses in src/main.ts. Mit envelope: 0 ist der gezupfte Anfang weg, weil der Filter auf seinem Cutoff bleibt. Nur die Noten mit Akzent öffnen ihn noch, um ihre eine Oktave. Mit decay: 0.6 braucht der Filter dreimal so lang, um zu schließen. wave: 'square' gibt dem Filter eine andere Welle.

Zwei Eingabefelder, weiter kommt man mit Eingabefeldern nicht. Jedes neue Instrument bräuchte ein weiteres, und seine Einstellungen stehen im Quellcode. Im nächsten Teil machen die Eingabefelder einem Editor Platz, und der Song wird zu Code.

Die App am Ende von Teil 8. Drück Play und ändere dann die zwei Patterns: Drum-Sounds im ersten Eingabefeld, Noten wie a1 c2 e2 im zweiten, mit :a für einen Akzent und :s für einen Slide.
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.