Zum Inhalt springen

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

Teil 16: Sehen, was man hört

Mach die Musik sichtbar: Jeder Schritt eines Patterns leuchtet im Editor auf, sobald seine Note zu hören ist, und eine kleine Anzeige zeigt Welle und Spektrum des Klangs. Dabei lernst du die Dekorationen von CodeMirror und den AnalyserNode kennen.

Quest-Ziele

  • Den Ort jedes Schritts vom Tokenizer bis in die Noten-Events mitnehmen
  • Mit einem State Field und einem State Effect in den Text von CodeMirror zeichnen
  • Die Texte aller pattern()-Aufrufe im Syntaxbaum des Editors finden
  • Jedes Licht zurückhalten, bis seine Note die Lautsprecher erreicht hat
  • Welle und Spektrum aus einem AnalyserNode lesen und auf ein Canvas zeichnen

Der Song spielt, und der Code, der ihn beschreibt, steht still. Dieser Teil verbindet die beiden für das Auge. Jeder Schritt eines Patterns leuchtet im Editor in dem Moment auf, in dem seine Note zu hören ist, und eine kleine Anzeige in der Kopfzeile zeigt den Klang selbst: seine Welle als Linie und seine Frequenzen als Balken dahinter.

Beide Anzeigen schauen nur zu. Der Klang bleibt, wie er am Ende von Teil 15 war.

Ein Ort für jeden Schritt

Damit sd in pattern('bd sd') aufleuchten kann, muss eine Note wissen, wo im Text sie geschrieben steht. Der Tokenizer aus Teil 5, der den Text eines Patterns in Tokens zerlegt, weiß das schon: Jedes Token trägt sein start und sein end, die bisher nur die Fehlermeldungen gebraucht haben. Dieser Ort reist jetzt mit: vom Token in den Baum, vom Baum ins Pattern und vom Pattern in die Note.

In src/mini.ts bekommt ein Atom des Baums, ein einzelner Name oder eine Zahl, eine location. Ersetze den Typ Node:

src/mini.ts
export type Node =
  | { type: 'atom'; value: Atom; location: [number, number] }
  | { type: 'rest' }
  | { type: 'sequence'; steps: Step[] }
  | { type: 'stack'; layers: Node[] }
  | { type: 'alternate'; steps: Step[] }
  | { type: 'choice'; options: Node[]; seed: number }
  | { type: 'polymeter'; layers: Node[]; steps: number | undefined }
  | { type: 'fast'; node: Node; factors: number[] }
  | { type: 'slow'; node: Node; factors: number[] }
  | { type: 'sometimes'; node: Node; amount: number; seed: number }
  | { type: 'euclid'; node: Node; pulses: number; steps: number; rotation: number };

Der Parser füllt sie aus dem Token. Ersetze in parseStep() das erste if:

src/mini.ts
if (token.type === 'word') {
  const number = Number(token.text);
  return { type: 'atom', value: Number.isFinite(number) ? number : token.text, location: [token.start, token.end] };
}

Der Compiler gibt sie an pure() weiter. Ersetze in compile() den ersten Fall:

src/mini.ts
case 'atom':
  return pure(node.value, node.location);

Ein Hap, ein Ereignis eines Patterns, bekommt Platz für den Ort. Ersetze in src/pattern.ts das Interface Hap:

src/pattern.ts
/** One event of a pattern: a value that begins and ends at a time, counted in cycles. */
export interface Hap<T> {
  begin: number;
  end: number;
  value: T;
  /** Where the value was written in the text of its pattern: from which character to which. */
  location?: [number, number];
}

pure() ist die einzige Funktion der Datei, die Haps aus dem Nichts erzeugt. Also ist sie die einzige, die den Ort eintragen muss. Ersetze sie:

src/pattern.ts
/** One value per cycle, as long as the cycle. */
export function pure<T>(value: T, location?: [number, number]): Pattern<T> {
  return (begin, end) => {
    const haps: Hap<T>[] = [];
    for (let cycle = Math.ceil(snap(begin)); cycle < snap(end); cycle += 1) {
      haps.push({ begin: cycle, end: cycle + 1, value, location });
    }
    return haps;
  };
}

Alle anderen Funktionen aus Teil 4 nehmen die Haps eines anderen Patterns und reichen sie weiter. fast() und compress() kopieren jeden Hap mit ...hap und ändern nur seine Zeiten. sometimes() lässt manche weg. stack() und die übrigen geben sie unverändert weiter. Der Ort kommt also durch alle hindurch, und keine von ihnen muss sich ändern. Wie oft ein Schritt auch wiederholt, beschleunigt oder gestaucht wird: Jeder seiner Haps zeigt weiter auf dieselben Zeichen.

Die letzte Station ist die Note. Ersetze in src/notes.ts das Interface NoteEvent:

src/notes.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;
  /** The text of the pattern the note comes from, and where in it the note was written. */
  source?: string;
  location?: [number, number];
}

Ein Ort sagt „Zeichen 3 bis 5“, aber nicht, in welchem Text. Deshalb trägt eine Note auch source, den ganzen Text ihres Patterns. Der Player hat beides zur Hand. Ersetze in src/player.ts die Methode events():

src/player.ts
events(from: number, to: number, clock: Clock): NoteEvent[] {
  return this.pattern(from, to).map((hap) => ({
    ...readAtom(hap.value),
    time: clock.timeAt(hap.begin),
    duration: (hap.end - hap.begin) * clock.cycleSeconds * this.options.legato,
    velocity: this.options.velocity,
    source: this.options.source,
    location: hap.location,
  }));
}

Was die Engine weitergibt

Jede Note kommt durch die Engine, und aller Klang geht durch sie hinaus. Sie bekommt für jede der beiden Anzeigen eine Ergänzung. Importiere in src/engine.ts den Typ NoteEvent aus ./notes.ts und ersetze den Kopf der Klasse bis zu ihrer clock. Danach folgen zwei neue Felder:

src/engine.ts
/** Makes a patch audible: creates its units, connects them, and sends them their notes. */
export class Engine {
  readonly clock = new Clock((from, to) => this.schedule(from, to));
  /** Listens to everything that reaches the speakers, for the displays. */
  readonly analyser = audio().createAnalyser();
  /** Called with every note, as soon as it is scheduled. */
  onNote: ((event: NoteEvent) => void) | undefined;

onNote ist eine Funktion, die jemand außerhalb der Engine setzen kann. schedule() ruft sie mit jeder Note auf, bevor die Note an ihre Instrumente geht. Ersetze schedule():

src/engine.ts
/**
 * Lets every unit schedule what it does by itself in the next stretch. Then asks every unit
 * that gives notes for that stretch, and hands the notes to their players.
 */
private schedule(from: number, to: number) {
  for (const unit of this.units.values()) unit.schedule?.(from, to, this.clock);
  for (const [source, targets] of this.routes) {
    for (const event of source.events?.(from, to, this.clock) ?? []) {
      this.onNote?.(event);
      for (const target of targets) target.play?.(event);
    }
  }
}

Der Analyser ist ein AnalyserNode: ein Knoten, der keinen Klang erzeugt und keinen verändert. Er merkt sich den letzten Augenblick dessen, was in ihn hineinfließt, und lässt sich danach fragen. Der Limiter aus Teil 13, der vor den Lautsprechern sitzt und zurückhält, was zu laut ist, bekommt ein zweites Kabel, zum Analyser, neben seinem Kabel zu den Lautsprechern. Ersetze den Konstruktor:

src/engine.ts
constructor() {
  // `out` is a unit like the others: a gain in front of the speakers. Between them sits
  // a limiter: a compressor set to turn down what is too loud, and that firmly.
  const out = audio().createGain();
  const limiter = audio().createDynamicsCompressor();
  limiter.threshold.value = -6;
  limiter.knee.value = 0;
  limiter.ratio.value = 20;
  limiter.attack.value = 0.002;
  limiter.release.value = 0.1;
  out.connect(limiter).connect(audio().destination);
  limiter.connect(this.analyser);
  this.units.set('out', { input: out, update() {}, dispose() {} });
}

Der Analyser bekommt jetzt genau das, was die Lautsprecher bekommen. Ein eigenes Kabel zu den Lautsprechern braucht er nicht: Ihm hört nur die Seite zu.

In den Text zeichnen

CodeMirror trennt den Text von dem, was auf ihn gezeichnet wird. Eine Farbe hinter einem Wort, eine Unterstreichung, ein Button zwischen zwei Zeilen: Jedes davon ist eine Dekoration, eine Anweisung an den Editor, ein Stück des Texts auf eine bestimmte Art zu zeigen. Die Unterstreichung aus Teil 11 ist eine, und das Lint-Paket hat sie für dich gemacht. Die Lichter sind Dekorationen, die du selbst machst.

Dekorationen müssen irgendwo wohnen. Alles, was der Editor weiß, steht in seinem State, seinem Zustand, und ein State ändert sich nie. Jeder Tastendruck und alles andere, was geschieht, ist eine Transaktion, die von einem State zum nächsten führt. Mit zwei Werkzeugen kann dein eigener Code daran teilnehmen:

  • Ein State Field ist ein eigener Wert im State. Du sagst, womit er beginnt und wie eine Transaktion aus dem alten Wert den neuen macht.

  • Ein State Effect ist eine eigene Nachricht, die eine Transaktion mitnehmen kann. Von sich aus ändert er nichts. Ein Field, das den Effect kennt, liest ihn und reagiert. Mit den Audio-Effekten aus Teil 13 hat der Name nichts zu tun.

Hier hält das Field die Markierungen, die gerade leuchten, und der Effect sagt „diese Stellen klingen jetzt“. Lege src/lights.ts an. Die Datei hat drei Abschnitte, die aufeinander folgen. Der erste ist die Seite des Editors:

src/lights.ts
import { syntaxTree } from '@codemirror/language';
import { StateEffect, StateField, type EditorState, type Text } from '@codemirror/state';
import { Decoration, EditorView, type DecorationSet } from '@codemirror/view';
import { audio } from './audio.ts';
import type { NoteEvent } from './notes.ts';

/** Tells the editor which stretches of the code are sounding. */
const setPlaying = StateEffect.define<Array<[number, number]>>();
const mark = Decoration.mark({ class: 'cm-playing' });

/** The editor's part: it holds the marks, and draws them as decorations. */
export const playingMarks = StateField.define<DecorationSet>({
  create: () => Decoration.none,
  update(marks, transaction) {
    // Once the code changes, the places of the marks are no longer right.
    if (transaction.docChanged) marks = Decoration.none;
    for (const effect of transaction.effects) {
      if (effect.is(setPlaying)) marks = Decoration.set(effect.value.map(([from, to]) => mark.range(from, to)), true);
    }
    return marks;
  },
  provide: (field) => EditorView.decorations.from(field),
});

Decoration.mark() beschreibt eine Dekoration, die ein Stück des Texts in ein Element mit einer Klasse hüllt, hier cm-playing. Eine CSS-Regel weiter unten gibt ihm seine Farbe. In update() ersetzt ein Effect unserer Art alle Markierungen durch neue für seine Liste von Stellen. Jede Stelle ist ein Paar von Positionen, gezählt in Zeichen vom Anfang des Codes. Decoration.set() will seine Markierungen der Reihe nach haben, und sein zweites Argument, true, lässt es sie sortieren. provide macht das Field sichtbar: Es übergibt den Wert des Fields dem Editor als Dekorationen, die er zeichnen soll.

Die erste Zeile von update() ist fürs Tippen da. Eine Markierung besteht aus zwei Positionen, und sobald sich der Code ändert, zeigen sie auf andere Zeichen. Also verschwinden die Markierungen. Die nächsten Noten bringen neue.

Die Patterns im Code finden

Eine Note weiß, wo sie im Text ihres Patterns steht. Der Editor muss wissen, wo dieser Text im Code steht. Eine Suche nach dem Text würde ihn auch in Kommentaren und in anderen Strings finden. Der Editor hat etwas Genaueres: seinen Syntaxbaum, die Struktur, die sein eigener Parser aus dem Code liest und aus der die Farben des Codes kommen. In Teil 11 hat er die Zeile eines Syntaxfehlers geliefert. Jetzt liefert er jeden Aufruf von pattern. Ergänze in src/lights.ts den zweiten Abschnitt:

src/lights.ts
interface PatternText {
  /** Where the text starts in the code, after its quote. */
  from: number;
  text: string;
}

const found = new WeakMap<Text, PatternText[]>();

/** The texts of all pattern('…') calls in the code: the editor's syntax tree knows them. */
function patternTexts(state: EditorState): PatternText[] {
  let texts = found.get(state.doc);
  if (texts) return texts;
  texts = [];
  syntaxTree(state).iterate({
    enter(node) {
      if (node.name !== 'CallExpression') return;
      const callee = node.node.firstChild;
      if (callee?.name !== 'VariableName' || state.sliceDoc(callee.from, callee.to) !== 'pattern') return;
      // The argument list starts with its bracket. The first argument comes after it.
      const argument = node.node.getChild('ArgList')?.firstChild?.nextSibling;
      // A text in quotes, or in backticks without anything filled in.
      const isText = argument?.name === 'String' || (argument?.name === 'TemplateString' && !argument.firstChild);
      if (!argument || !isText) return;
      const text = state.sliceDoc(argument.from + 1, argument.to - 1);
      // With a backslash in it, the text in the code and the text of the pattern differ.
      if (!text.includes('\\')) texts!.push({ from: argument.from + 1, text });
    },
  });
  found.set(state.doc, texts);
  return texts;
}

iterate() besucht jeden Knoten des Baums. Ein Knoten hat einen Namen, den ihm die Grammatik von JavaScript gibt, und ein from und ein to im Code. Eine CallExpression ist ein Aufruf. Ihr erstes Kind ist das, was aufgerufen wird: bei pattern('bd sd') ein VariableName, in dem pattern steht. Ihre ArgList enthält die Klammern und die Argumente, das erste Argument ist also ihr zweites Kind. Ist das ein String, dann ist der Text zwischen seinen Anführungszeichen das Pattern. Dasselbe gilt für einen TemplateString, einen Text in Backticks, solange er keine Kinder hat, also kein ${…} enthält.

Zwei Fälle bleiben mit Absicht außen vor. Ein Text mit einem Backslash wird übersprungen: \n sind im Code zwei Zeichen und im Pattern eines, die Positionen würden nicht mehr stimmen. Und ein Pattern, dessen Text nicht im Aufruf steht, wie bei pattern(beat), wird nicht gefunden. Seine Schritte bleiben dunkel.

Den Baum für jede Note abzulaufen, wäre verschwendete Arbeit, also wird das Ergebnis aufgehoben. state.doc, der Text des Codes, ist ein neues Objekt, sobald sich der Code ändert, und taugt deshalb gut als Schlüssel. Eine WeakMap vergisst einen Eintrag, sobald sonst niemand mehr seinen Schlüssel hält.

Lichter, die warten

Die Engine meldet eine Note, wenn sie eingeplant wird, nicht wenn sie klingt. Die Uhr aus Teil 2 hat eine Vorausschau von einer Zehntelsekunde, also wird eine Note bis zu eine Zehntelsekunde früher gemeldet, als sie fällig ist. Ein Licht, das sofort anginge, liefe der Musik voraus, und das würdest du sehen.

Dazu kommt eine zweite, meist kleinere Verzögerung. Eine Zeit auf der Audio-Uhr ist der Moment, in dem der Audio-Kontext den Klang weitergibt. Von dort muss er noch durch das Betriebssystem und die Sound-Hardware. Der Kontext schätzt, wie lange das dauert, und bietet die Schätzung als outputLatency an, in Sekunden. Ein Browser, der keine Schätzung liefert, zählt als 0. Ein Licht wartet auf beides: bis seine Note fällig ist und bis die Note die Lautsprecher erreicht hat. Ergänze in src/lights.ts den dritten Abschnitt:

src/lights.ts
interface Light {
  from: number;
  to: number;
  /** When it goes on and off, on the clock of the page: performance.now(). */
  on: number;
  off: number;
  /** The code it belongs to. */
  doc: Text;
}

/** Lights up the steps of the patterns in the code while their notes sound. */
export class Lights {
  private readonly view: EditorView;
  private lights: Light[] = [];
  private shown = '';

  constructor(view: EditorView) {
    this.view = view;
  }

  /** Takes a note that was scheduled just now, to light its step when it is heard. */
  add(event: NoteEvent) {
    if (!event.location || event.source === undefined) return;
    const { state } = this.view;
    // The note is due at a time of the audio clock, a moment from now. And what is
    // scheduled is heard a little later still: the way to the speakers takes time.
    const wait = (event.time - audio().currentTime + (audio().outputLatency || 0)) * 1000;
    const on = performance.now() + wait;
    const off = on + Math.max(80, event.duration * 1000);
    for (const { from, text } of patternTexts(state)) {
      if (text !== event.source) continue;
      this.lights.push({ from: from + event.location[0], to: from + event.location[1], on, off, doc: state.doc });
    }
  }

  /** Once per frame: shows the lights that are on now. */
  frame() {
    const now = performance.now();
    const doc = this.view.state.doc;
    this.lights = this.lights.filter((light) => light.off > now && light.doc === doc);
    // Two notes of the same step light it once.
    const ranges = new Map<string, [number, number]>();
    for (const light of this.lights) {
      if (light.on <= now) ranges.set(`${light.from}-${light.to}`, [light.from, light.to]);
    }
    // The editor is only told when something changed.
    const key = [...ranges.keys()].sort().join(' ');
    if (key === this.shown) return;
    this.shown = key;
    this.view.dispatch({ effects: setPlaying.of([...ranges.values()].sort((a, b) => a[0] - b[0])) });
  }

  clear() {
    this.lights = [];
  }
}

add() rechnet die Wartezeit einmal aus, wenn die Note ankommt. Von da an läuft das Licht nach der Uhr der Seite, performance.now(), die in Millisekunden zählt. Ein Licht bleibt so lange an, wie seine Note gehalten wird, mindestens aber 80 Millisekunden, damit auch sehr kurze Noten zu sehen sind. Dann sucht add() den Text der Note unter den Patterns im Code und zählt den Ort der Note zu der Stelle dazu, an der dieser Text beginnt. Haben zwei Patterns denselben Text, leuchten beide: Nichts unterscheidet sie.

frame() läuft einmal pro Frame. Es wirft die Lichter weg, die vorbei sind, und die, die zu Code gehören, der sich seither geändert hat. Es sammelt die Stellen der Lichter, die an sind, und schickt sie an den Editor, aber nur, wenn sich die Liste von der zuletzt geschickten unterscheidet. Ein Dispatch macht dem Editor Arbeit, und in den meisten Frames ändert sich nichts.

Der Editor muss das Field bekommen. Importiere in src/editor.ts playingMarks aus ./lights.ts und nimm es in die Extensions auf. Ersetze createEditor():

src/editor.ts
/** A code editor in `parent`, holding `code`. */
export function createEditor(parent: HTMLElement, code: string, keys: EditorKeys): EditorView {
  return new EditorView({
    parent,
    doc: code,
    extensions: [
      // Before the basic setup, and with the highest precedence: Ctrl+Enter means
      // something else there.
      Prec.highest(
        keymap.of([
          { key: 'Mod-Enter', run: () => (keys.run(), true) },
          { key: 'Mod-.', run: () => (keys.stop(), true) },
        ]),
      ),
      basicSetup,
      javascript(),
      playingMarks,
      look,
      oneDark,
    ],
  });
}

Die Farbe eines leuchtenden Schritts kommt in src/style.css, hinter die Regel für .editor .cm-editor:

src/style.css
/* A step of a pattern while its note sounds. */
.editor .cm-playing,
.editor .cm-playing span {
  background: var(--orange);
  color: var(--void);
}

Der zweite Selektor gilt den Elementen der Syntaxhervorhebung innerhalb einer Markierung. Sie haben eine eigene Farbe, die sonst gewinnen würde.

Zwei Blicke auf denselben Klang

Ein AnalyserNode beantwortet zwei Fragen über den Klang, der in ihn hineinfließt.

Die erste: Wie sieht die Welle aus? Digitaler Klang ist eine Reihe von Zahlen von -1 bis 1, viele tausend pro Sekunde. Jede dieser Zahlen ist ein Abtastwert, auf Englisch ebenfalls „sample“, was hier nicht die Aufnahmen aus Teil 15 meint. Der Analyser behält die letzten 2048 davon, seine fftSize, und getFloatTimeDomainData() kopiert sie in ein Array. Bei 48.000 Abtastwerten pro Sekunde, einer üblichen Rate, sind das etwa 43 Millisekunden Klang. Dieser Blick heißt Zeitbereich: die Welle über die Zeit. Eine Anzeige, die ihn zeichnet, ist ein Oszilloskop.

Die zweite: Welche Frequenzen stecken darin? Jeder Klang lässt sich als Summe von Sinuswellen verschiedener Frequenzen beschreiben, jede mit ihrer eigenen Stärke. Der Analyser rechnet diese Summe für seine 2048 Abtastwerte aus, mit einem Verfahren namens schnelle Fourier-Transformation. getByteFrequencyData() liefert die Stärken: eine Zahl von 0 bis 255 für jedes von 1024 Bins, das sind nebeneinanderliegende Frequenzbänder. Dieser Blick ist der Frequenzbereich, und sein Bild ist das Spektrum. Tiefe Sounds wie die Bassdrum zeigen sich an seinem linken Ende, hohe wie die Hi-Hat am rechten.

Die Bins sind in Hertz alle gleich breit. Sie teilen den Bereich von 0 bis zur halben Abtastrate gleichmäßig auf, bei einer Rate von 48.000 ist also jedes etwa 23 Hz breit. Das Gehör arbeitet anders. Eine Oktave ist eine Verdopplung der Frequenz, egal wo sie beginnt: Von 40 bis 80 Hz ist eine Oktave, von 8000 bis 16.000 Hz auch. Die erste ist nicht einmal zwei Bins breit, die zweite 341. Bin für Bin gezeichnet, wäre der ganze Bass ein schmaler Streifen am linken Rand. Deshalb zeichnet die Anzeige 40 Balken, die alle dasselbe Verhältnis abdecken: Von 40 Hz bis 16.000 Hz endet jeder Balken bei etwa dem 1,16-Fachen der Frequenz, bei der er beginnt. Ein Balken zeigt das lauteste Bin in seinem Bereich. Lege src/scope.ts an:

src/scope.ts
/** How many bars the spectrum has, and the frequencies of the lowest and the highest one. */
const BARS = 40;
const LOWEST = 40;
const HIGHEST = 16000;

/** Draws what an analyser hears: the frequencies as bars, and the wave as a line across them. */
export class Scope {
  private readonly canvas: HTMLCanvasElement;
  private readonly analyser: AnalyserNode;
  private readonly wave: Float32Array<ArrayBuffer>;
  private readonly spectrum: Uint8Array<ArrayBuffer>;

  constructor(canvas: HTMLCanvasElement, analyser: AnalyserNode) {
    this.canvas = canvas;
    this.analyser = analyser;
    this.wave = new Float32Array(analyser.fftSize);
    this.spectrum = new Uint8Array(analyser.frequencyBinCount);
    // As many pixels as the screen really has under the canvas.
    canvas.width = canvas.clientWidth * devicePixelRatio;
    canvas.height = canvas.clientHeight * devicePixelRatio;
  }

  draw() {
    const { width, height } = this.canvas;
    const context = this.canvas.getContext('2d')!;
    context.clearRect(0, 0, width, height);

    // The spectrum: the analyser sorts the sound into bins of equal width in hertz, from 0
    // to half the sample rate. We hear in octaves, so each bar covers the same ratio.
    this.analyser.getByteFrequencyData(this.spectrum);
    const hertzPerBin = this.analyser.context.sampleRate / this.analyser.fftSize;
    context.fillStyle = '#5b21b6';
    for (let bar = 0; bar < BARS; bar += 1) {
      const from = LOWEST * (HIGHEST / LOWEST) ** (bar / BARS);
      const to = LOWEST * (HIGHEST / LOWEST) ** ((bar + 1) / BARS);
      let level = 0;
      for (let bin = Math.floor(from / hertzPerBin); bin <= Math.ceil(to / hertzPerBin); bin += 1) {
        level = Math.max(level, this.spectrum[bin] ?? 0);
      }
      const barHeight = (level / 255) * height;
      context.fillRect((bar / BARS) * width, height - barHeight, width / BARS - 1, barHeight);
    }

    // The wave: the last samples, from -1 to 1. Start where it crosses zero going up, so
    // that a steady tone stands still instead of running through the picture.
    this.analyser.getFloatTimeDomainData(this.wave);
    const length = this.wave.length / 2;
    let start = 0;
    while (start < length && !(this.wave[start] < 0 && this.wave[start + 1] >= 0)) start += 1;
    if (start === length) start = 0;
    context.strokeStyle = '#f97316';
    context.lineWidth = devicePixelRatio;
    context.beginPath();
    for (let i = 0; i < length; i += 1) {
      const x = (i / (length - 1)) * width;
      const y = (0.5 - this.wave[start + i] * 0.5) * height;
      if (i === 0) context.moveTo(x, y);
      else context.lineTo(x, y);
    }
    context.stroke();
  }
}

Der Konstruktor gibt dem Canvas so viele Pixel, wie der Bildschirm unter ihm hat: seine Größe auf der Seite mal devicePixelRatio. Ohne das wäre die Linie auf einem Bildschirm mit hoher Auflösung unscharf.

Für die Balken macht hertzPerBin aus einer Frequenz die Nummer ihres Bins. Am tiefen Ende ist ein Balken schmaler als ein Bin. Weil sein erstes Bin abgerundet und sein letztes aufgerundet wird, liest jeder Balken mindestens eines. Benachbarte Balken am linken Rand teilen sich deshalb Bins und bewegen sich gemeinsam.

Die Welle wird aus der Hälfte der Abtastwerte gezeichnet, aus 1024 davon. Die andere Hälfte ist der Spielraum für die Wahl des Anfangs. Die Schleife sucht die erste Stelle, an der die Welle auf dem Weg nach oben die Null kreuzt, und dort beginnt die Zeichnung. Ein gleichmäßiger Ton beginnt dann in jedem Frame am selben Punkt seiner Schwingung und steht im Bild still. Ab dem zufälligen Anfang des Arrays gezeichnet, würde er seitwärts laufen. Gibt es keine solche Stelle, etwa bei Stille, beginnt die Zeichnung am Anfang.

Das Canvas kommt in die Kopfzeile, zwischen Position und Tempo. Ersetze in index.html den Header:

index.html
<header>
  <strong class="name">loopcode</strong>
  <button id="play">▶ Play</button>
  <span id="position" class="position">1.1</span>
  <canvas id="scope" class="scope"></canvas>
  <span class="tempo"><span id="bpm">120</span> bpm</span>
  <button id="run" title="Ctrl+Enter">Run</button>
</header>

Ersetze in src/style.css die Regel für .tempo durch diese zwei. Das margin-left: auto, das das Tempo nach rechts geschoben hat, wandert zum Oszilloskop, das jetzt davor steht:

src/style.css
.scope {
  width: 200px;
  height: 32px;
  margin-left: auto;
  border: 1px solid var(--edge);
  border-radius: 4px;
  background: var(--void);
}

.tempo {
  color: var(--muted);
}

Alles verbinden

Der Rest steht in src/main.ts. Importiere Lights aus ./lights.ts und Scope aus ./scope.ts. Ein Stopp verwirft auch die Lichter, die noch warten. Ersetze stop():

src/main.ts
function stop() {
  engine.stop();
  lights.clear();
  showPlaying();
}

Erzeuge beide Anzeigen nach dem Editor, und lass die Engine ihre Noten an die Lichter melden:

src/main.ts
const lights = new Lights(editor);
engine.onNote = (event) => lights.add(event);
const scope = new Scope(document.querySelector<HTMLCanvasElement>('#scope')!, engine.analyser);

Die Schleife am Ende der Datei, die einmal pro Frame die Position zeigt, nimmt beide mit. Ersetze draw() samt Kommentar:

src/main.ts
/** Once per frame: where the music is, as bar.beat, and what it looks like. */
const position = document.querySelector<HTMLSpanElement>('#position')!;
function draw() {
  const { clock } = engine;
  const cycle = clock.playing ? Math.max(0, clock.cycleAt(audio().currentTime)) : 0;
  position.textContent = `${Math.floor(cycle) + 1}.${Math.floor((cycle % 1) * 4) + 1}`;
  lights.frame();
  scope.draw();
  requestAnimationFrame(draw);
}
draw();

Probier es aus

Drück Play. In allen vier Patterns des Beispielsongs werden Schritte orange, während ihre Noten klingen. In der Basslinie leuchtet von <e2:s g2:as> pro Takt eine der beiden Noten, immer abwechselnd. Die Schritte mit einem ? dahinter leuchten nur, wenn ihre Note gespielt wird. bd*4 ist ein Schritt, der viermal gespielt wird, und jede seiner Noten dauert, bis die nächste beginnt. Seine zwei Zeichen leuchten deshalb von Schlag zu Schlag durch.

Um das Timing deutlich zu sehen, ersetze den Code hierdurch und drück Strg+Enter:

javascript
bpm(120)

pattern('bd sd [hh hh] cp').to(drums()).to(out)

Bei 120 bpm dauert ein Takt zwei Sekunden, jeder der vier Schritte also eine halbe. Das Licht wandert jede halbe Sekunde weiter, zusammen mit dem Klang: bd, sd, die zwei hh, die sich eine halbe Sekunde teilen, cp, und wieder von vorn. Tipp jetzt irgendwo im Code ein Leerzeichen. Die Lichter gehen sofort aus und kommen mit den nächsten Noten wieder. Änderst du den Text des Patterns, ohne den Code auszuführen, bleiben seine Schritte dunkel: Was spielt, ist noch der alte Text. Strg+Enter bringt sie zurück.

Die Anzeige in der Kopfzeile ist eine flache Linie, solange nichts spielt. Laufen die Drums, sollte die Linie mit jedem Schlag springen. Die Balken zeigen, aus welchen Frequenzen ein Schlag besteht: Die der Bassdrum, eines tiefen Sounds, liegen links, die der Hi-Hats rechts. Für einen Ton, der stillsteht, führe das hier aus:

javascript
bpm(120)

const tone = polySynth({ wave: 'sine', detune: 0, sustain: 1 })
pattern('c3').to(tone)
tone.to(out)

Eine Sinuswelle ist eine einzige Frequenz. Die Linie sollte also eine glatte Welle sein, und die Balken sollten einen Hügel nahe dem linken Rand bilden. Ändere wave auf 'sawtooth' und führe den Code noch einmal aus. Ein Sägezahn hat Kanten, und er enthält viele Frequenzen über seiner Tonhöhe: Das sind die Balken, die rechts vom Hügel auftauchen sollten.

Drück Play: Die Schritte im Code leuchten, während sie klingen, und die Anzeige in der Kopfzeile zeigt Welle und Spektrum. Strg+Enter führt geänderten Code aus, 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.