Eine Live-Coding-Musik-App bauen · Teil 2 von 18 der Serie
Teil 2: Eine Uhr, die den Takt hält
Die Timer von JavaScript sind für Musik zu ungenau. Du baust eine Uhr, die in Takten zählt, Noten im Voraus auf der genauen Uhr des AudioContext einplant und ihre Position behält, wenn sich das Tempo ändert. Ein Metronom macht sie hörbar.
Eine Live-Coding-Musik-App bauenTeil 2 von 18
Auf dieser Seite
Quest-Ziele
- Verstehen, warum setTimeout und setInterval Musik nicht im Takt halten können
- Noten im Voraus auf der Audio-Uhr einplanen
- Die Zeit in Zyklen zählen, damit das Tempo eine eigene Sache ist
- Das Tempo ändern, ohne dass die Position springt
- Jeden Schlag genau einmal spielen, egal wie die Zeit zerschnitten wird
- Takt und Schlag auf der Seite anzeigen
Die Tasten aus Teil 1 spielen eine Note in dem Moment, in dem du klickst. Musik braucht mehr: Noten zu genauen Zeitpunkten, eine nach der anderen, ohne dass jemand klickt. Dieser Teil baut die Uhr, die das leistet, und ein Metronom, an dem man sie hört: ein kurzer Klick auf jedem Schlag.
Warum ein Timer nicht reicht
JavaScript hat Timer, und setInterval(tick, 500) sieht aus wie ein Metronom mit zwei Klicks pro Sekunde. Es ist keines. Ein Timer verspricht nur, dass seine Funktion nicht früher läuft als verlangt. Sie läuft, wenn die Seite sonst nichts zu tun hat: nach dem Code, der gerade läuft, nach einem Layout, nach dem Neuzeichnen. Sie kommt also einige Millisekunden zu spät, und jedes Mal um einen anderen Betrag. Das Ohr ist bei Rhythmus streng: Schläge, von denen jeder um einen anderen Betrag zu spät kommt, klingen ungleichmäßig, auch wenn die Beträge klein sind.
Zwei Uhren
Der AudioContext hat eine eigene Uhr, currentTime. Sie zählt den Klang, den der Context ausgegeben hat, in Sekunden, und ihr ist egal, womit die Seite gerade beschäftigt ist. Und Klang lässt sich auf ihr im Voraus planen: start() und stop() des Oszillators und die Rampen der Hüllkurve in Teil 1 haben alle eine Zeit bekommen. Eine Note, die für 12,5 Sekunden geplant ist, beginnt bei 12,5 Sekunden der Audio-Uhr, egal was das JavaScript der Seite in diesem Moment tut.
Es gibt also eine genaue Uhr, die keinen Code aufrufen kann, und einen Timer, der Code zu ungenauen Zeiten aufruft. Zusammen benutzt man sie so:
Ein Timer läuft oft ab, alle 25 ms.
Jedes Mal schaut er ein kurzes Stück in die Zukunft der Audio-Uhr, 100 ms, und plant jede Note ein, die in dem Teil dieses Fensters beginnt, den er noch nicht abgedeckt hat. Eine Note einzuplanen heißt, sie auf der Audio-Uhr festzulegen, bevor sie fällig ist.
Jetzt darf der Timer zu spät kommen. Ein Aufruf, der pünktlich kam, hat die nächsten 100 ms abgedeckt, und der Aufruf danach ist 25 ms später fällig. Solange der weniger als 75 ms zu spät kommt, liegt der nächste Abschnitt noch in der Zukunft, wenn seine Noten eingeplant werden, und jede Note sitzt an ihrer genauen Zeit. Das Fenster ist die Vorausschau. Eine längere übersteht längere Verspätungen, aber was eingeplant ist, steht fest: Eine Änderung des Tempos, und später eine Änderung des Codes, hört man erst, wenn die Vorausschau vorbei ist. 100 ms sind so kurz, dass es sich wie sofort anfühlt.
Zyklen statt Sekunden
Musik zählt nicht in Sekunden. Der Puls, zu dem du mit dem Fuß wippen würdest, ist der Schlag, und das Tempo sagt, wie viele Schläge in eine Minute passen, in bpm (beats per minute). Schläge kommen in Gruppen, und eine Gruppe ist ein Takt. In dieser Serie hat ein Takt immer vier Schläge, wie in den meisten Pop- und Dance-Stücken.
Die Uhr zählt in Zyklen: Ein Zyklus ist ein Takt. Zyklus 0 ist der Anfang, 0,25 ist der zweite Schlag des ersten Takts, 2,5 ist die Mitte des dritten Takts. Alles, was spielt, wird in Zyklen platziert, und nur die Uhr weiß, wie lange ein Zyklus dauert: vier Schläge, also 240 / bpm Sekunden, bei 120 bpm sind das 2 Sekunden. Ein Rhythmus, der in Zyklen aufgeschrieben ist, ist bei jedem Tempo derselbe Rhythmus.
Um von Zyklen zu den Sekunden der Audio-Uhr und zurück zu kommen, merkt sich die Uhr einen Anker: einen Moment, von dem sie beide Zahlen kennt, die Audio-Zeit und den Zyklus. Von dort aus ist es eine gerade Linie: so viele Sekunden später ist so viele Zyklen später.
Lege src/clock.ts an:
import { audio } from './audio.ts';
/** How often the clock looks ahead, in milliseconds. */
const INTERVAL = 25;
/** How far ahead of the audio clock notes are scheduled, in seconds. */
const LOOKAHEAD = 0.1;
/**
* Counts time in cycles: one cycle is one bar of four beats. While it runs, it calls
* `schedule` with every stretch of cycles that is about to be heard, each stretch once.
*/
export class Clock {
playing = false;
private beatsPerMinute = 120;
/** A moment at which both clocks are known: the audio clock's seconds and our cycles. */
private anchor = { time: 0, cycle: 0 };
/** Everything before this cycle has been scheduled. */
private scheduled = 0;
private timer = 0;
private readonly schedule: (from: number, to: number) => void;
constructor(schedule: (from: number, to: number) => void) {
this.schedule = schedule;
}
/** The length of a cycle in seconds: four beats. */
get cycleSeconds(): number {
return 240 / this.beatsPerMinute;
}
get bpm(): number {
return this.beatsPerMinute;
}
set bpm(value: number) {
// The new tempo counts from now on: move the anchor to this moment first.
const now = audio().currentTime;
this.anchor = { time: now, cycle: this.cycleAt(now) };
this.beatsPerMinute = value;
}
/** The cycle that is playing at a time of the audio clock. */
cycleAt(time: number): number {
return this.anchor.cycle + (time - this.anchor.time) / this.cycleSeconds;
}
/** The time of the audio clock at which a cycle is reached. */
timeAt(cycle: number): number {
return this.anchor.time + (cycle - this.anchor.cycle) * this.cycleSeconds;
}
start() {
if (this.playing) return;
this.playing = true;
// Start a moment from now, so the first note is not already in the past.
this.anchor = { time: audio().currentTime + 0.05, cycle: 0 };
this.scheduled = 0;
this.timer = window.setInterval(() => this.tick(), INTERVAL);
this.tick();
}
stop() {
this.playing = false;
window.clearInterval(this.timer);
}
private tick() {
const until = this.cycleAt(audio().currentTime + LOOKAHEAD);
if (until <= this.scheduled) return;
this.schedule(this.scheduled, until);
this.scheduled = until;
}
}cycleAt()undtimeAt()sind dieselbe Linie, in beide Richtungen gelesen: von einer Zeit zu einem Zyklus und von einem Zyklus zu einer Zeit.start()setzt den Anker: Zyklus 0 liegt 50 ms in der Zukunft. Ohne diesen Abstand wäre die erste Note genau in dem Moment fällig, in dem sie eingeplant wird, und läge schon in der Vergangenheit, bevor ihre Knoten erzeugt sind. Dann startet die Methode den Timer und rufttick()gleich einmal auf, damit der erste Abschnitt nicht 25 ms wartet.tick()fragt, welcher Zyklus in 100 ms erreicht sein wird, gibt den Abschnitt vonscheduledbis dorthin an die Funktion, mit der die Uhr erzeugt wurde, und merkt sich, wie weit sie gekommen ist.stop()hält nur den Timer an. Noten, die schon eingeplant sind, spielen noch, das sind höchstens 100 ms Musik.
Der Vertrag von schedule
Die Uhr gibt der Funktion, die sie aufruft, ein Versprechen: Jeder Abschnitt von Zyklen kommt genau einmal. Jeder Aufruf beginnt dort, wo der vorige geendet hat, von 0 an, ohne Lücke und ohne Überlappung. Wie lang ein Abschnitt ist, steht nicht fest: etwa 25 ms Musik, wenn der Timer pünktlich ist, mehr, wenn er zu spät kam.
Im Gegenzug muss die Funktion alles spielen, was im Abschnitt beginnt, wobei from dazugehört und to nicht. Wird jeder Abschnitt so behandelt, fällt jede Note in genau einen von ihnen, egal wie die Zeit zerschnitten wird.
Das Tempo ändern
Der Setter von bpm tut eine Sache, bevor er das neue Tempo speichert: Er verschiebt den Anker auf jetzt. Zahlen zeigen, warum. Nach einer Minute bei 120 bpm ist die Musik bei Zyklus 30. Würde das Tempo auf 60 bpm wechseln, während der Anker noch am Anfang liegt, dann würde cycleAt() die ganze Minute mit dem neuen Tempo zählen und mit Zyklus 15 antworten: Die Musik spränge fünfzehn Takte zurück. Wird der Anker vorher auf diesen Moment verschoben, bleibt die Vergangenheit so, wie sie gespielt wurde, und nur was danach kommt, läuft im neuen Tempo.
Die Prüfung am Anfang von tick() gehört dazu. Gleich nachdem das Tempo gesunken ist, sind 100 ms voraus weniger Zyklen als vorher, und until kann vor dem liegen, was schon eingeplant ist. Dann gibt es nichts zu tun, bis die Uhr aufgeholt hat.
Ein Metronom
Die Seite bekommt einen Play-Button, eine Anzeige für die Position und einen Regler für das Tempo. Ersetze in index.html das Element <header> und das Element <main>. Die Tasten aus Teil 1 fallen weg, und der Hinweis ändert sich:
<header>
<strong class="name">loopcode</strong>
<button id="play">▶ Play</button>
<span id="position" class="position">1.1</span>
<label class="tempo">
<input id="bpm" type="range" min="60" max="180" value="120" />
<span id="bpm-value">120</span> bpm
</label>
</header>
<main class="stage">
<p class="hint">Press Play, then move the tempo.</p>
</main>Ergänze in src/main.ts einen Import von Clock aus ./clock.ts. beep() bleibt, wie es ist. Entferne alles darunter, die Tonleiter und die Tasten, und erzeuge dort die Uhr:
/** A metronome: a click on every beat, a higher one on the first beat of a bar. */
const clock = new Clock((from, to) => {
// Beats are quarters of a cycle. Take every beat that starts inside the stretch.
for (let beat = Math.ceil(from * 4); beat < to * 4; beat += 1) {
beep(beat % 4 === 0 ? 84 : 72, clock.timeAt(beat / 4), 0.08);
}
});Ein Schlag ist ein Viertel eines Zyklus, Schlag Nummer n liegt also bei Zyklus n / 4. Die Schleife beginnt mit dem ersten ganzen Schlag bei oder nach from, den findet Math.ceil(), und läuft, solange der Schlag vor to liegt.
Nimm einen Schlag genau auf einer Grenze: Schlag 1 bei Zyklus 0,25, und zwei Abschnitte, die sich dort treffen. Für den Abschnitt von 0,2375 bis 0,25 beginnt die Schleife bei Math.ceil(0.95), das ist 1, und 1 ist nicht kleiner als 1: Es spielt nichts. Für den Abschnitt von 0,25 bis 0,2625 beginnt sie bei Math.ceil(1), das ist wieder 1, und 1 ist kleiner als 1,05: Der Schlag spielt. Er spielt einmal, in dem Abschnitt, der mit ihm beginnt. Mit <= statt < würde er zweimal spielen, einmal in jedem der beiden Abschnitte.
timeAt() macht aus dem Zyklus des Schlags eine Zeit der Audio-Uhr, und genau dafür hat beep() den Parameter time. Der erste Schlag eines Takts ist Note 84, die anderen sind Note 72, eine Oktave tiefer, und jeder dauert 0,08 Sekunden: ein kurzer Klick.
Unter der Uhr startet und stoppt der Play-Button sie:
const play = document.querySelector<HTMLButtonElement>('#play')!;
play.addEventListener('click', async () => {
await audio().resume();
if (clock.playing) clock.stop();
else clock.start();
play.textContent = clock.playing ? '■ Stop' : '▶ Play';
play.classList.toggle('on', clock.playing);
});Der Text des Buttons und seine Klasse on folgen clock.playing. Die Regel für button.on steht seit Teil 1 in den Styles und färbt den Button orange. Dann der Regler, der das Tempo setzt, während die Uhr läuft:
const bpm = document.querySelector<HTMLInputElement>('#bpm')!;
const bpmValue = document.querySelector<HTMLSpanElement>('#bpm-value')!;
bpm.addEventListener('input', () => {
clock.bpm = Number(bpm.value);
bpmValue.textContent = bpm.value;
});Das Ereignis input kommt bei jeder Bewegung des Reglers, nicht erst beim Loslassen.
Wo die Musik gerade ist
Die Anzeige zeigt den Takt und den Schlag, beide von 1 an gezählt, wie es in der Musik üblich ist: 1.1 ist der erste Schlag des ersten Takts, 3.2 der zweite Schlag des dritten. Ergänze am Ende der Datei:
/** Shows where the music is, as bar.beat, once per frame. */
const position = document.querySelector<HTMLSpanElement>('#position')!;
function draw() {
const cycle = clock.playing ? Math.max(0, clock.cycleAt(audio().currentTime)) : 0;
position.textContent = `${Math.floor(cycle) + 1}.${Math.floor((cycle % 1) * 4) + 1}`;
requestAnimationFrame(draw);
}
draw();requestAnimationFrame() ruft draw() wieder auf, bevor der Browser sein nächstes Bild zeichnet. Die Funktion zählt selbst nichts. Sie fragt die Uhr, welchen Zyklus die Audio-Uhr erreicht hat, und so kann die Anzeige dem Klang nicht davonlaufen. Math.max(0, …) ist für die ersten 50 ms nach Play da, in denen der Zyklus noch unter 0 liegt. Solange die Uhr steht, bleibt die Anzeige bei 1.1.
Entferne in src/style.css die zwei Regeln am Ende, .keys und .keys button. Ergänze drei Regeln für die neuen Elemente der Kopfzeile, nach den Regeln für button und vor .stage:
.position {
min-width: 4ch;
color: var(--lilac);
font-weight: bold;
}
.tempo {
display: flex;
align-items: center;
gap: 6px;
margin-left: auto;
color: var(--muted);
}
.tempo input {
width: 110px;
accent-color: var(--orange);
}Probier es aus
Drück Play. Auf jedem Schlag kommt ein Klick, zwei pro Sekunde bei 120 bpm, und der erste von je vier ist eine Oktave höher. Die Anzeige zählt mit: 1.1, 1.2, 1.3, 1.4, 2.1. Beweg den Regler, während es spielt: Die Klicks werden sofort schneller oder langsamer, und die Zählung geht dort weiter, wo sie ist, ohne Sprung. Drück Stop, und die Anzeige steht wieder bei 1.1. Das nächste Play beginnt wieder beim ersten Takt.
Setz
LOOKAHEADinsrc/clock.tsauf 1. Das Metronom klingt wie vorher. Aber beweg den Regler: Die Klicks, die schon eingeplant sind, jetzt eine ganze Sekunde davon, behalten ihre alten Zeiten. Das neue Tempo kommt verspätet, und der Rhythmus stolpert dort, wo die alten Klicks auf die neuen treffen. Auch nach Stop spielen die eingeplanten Klicks noch. Setz den Wert zurück auf0.1.Lass das Metronom Sechzehntel zählen, vier pro Schlag: Schreib in der Schleife 16 statt 4, und zwar in
from * 4,to * 4,beat % 4undbeat / 4. Bei 120 bpm sind das acht Klicks pro Sekunde, mit dem höheren am Anfang jedes Takts, und sie sind so gleichmäßig wie vorher die Schläge. Schreib danach wieder 4 hin.
Eine Uhr und ein Klick sind noch keine Band. Der nächste Teil gibt der Uhr einen Drumcomputer zu spielen.
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.