Eine Live-Coding-Musik-App bauen · Teil 3 von 18 der Serie
Teil 3: Drums aus Oszillatoren und Rauschen
Du baust einen Drumcomputer ohne eine einzige Aufnahme: eine Bassdrum aus einem Sinus mit fallender Tonhöhe, Snare und Clap aus gefiltertem Rauschen, Hi-Hats aus sechs Rechteckwellen und eine offene Hi-Hat, die von der geschlossenen abgeschnitten wird. Dazu ein Rhythmus aus sechzehn Schritten.
Eine Live-Coding-Musik-App bauenTeil 3 von 18
Auf dieser Seite
Quest-Ziele
- Weißes Rauschen in einem Buffer erzeugen und abspielen
- Bassdrum, Snare, Clap und Hi-Hats aus Oszillatoren und Rauschen bauen
- Einen Sound mit einem Hochpass und einem Bandpass formen
- Eine geschlossene Hi-Hat eine offene abschneiden lassen
- Einen Rhythmus als sechzehn Schritte schreiben und mit der Uhr spielen
Die Uhr aus Teil 2 spielt ein Metronom. Jetzt bekommt sie einen Drumcomputer: ein Instrument, das Schlagzeug-Sounds von selbst spielt, Schritt für Schritt. Die meisten Drumcomputer spielen Samples ab, kurze Aufnahmen von Trommeln. Dieser hat keine Aufnahmen. Jeder Sound wird in dem Moment gebaut, in dem er spielt, aus den zwei Arten von Quellen, die die Web Audio API dafür hat: Oszillatoren und Rauschen. Frühe Drumcomputer haben genauso gearbeitet, mit Schaltkreisen, wo hier Code steht.
Man lernt so auch mehr. Jeder Sound ist eine Handvoll Zahlen, die du ändern kannst, und was er braucht, Hüllkurven, fallende Tonhöhen und Filter, ist das, woraus die Synths der späteren Teile bestehen.
Rauschen
Ein Oszillator wiederholt eine Welle, also hat er eine Tonhöhe. Rauschen ist das Gegenteil: eine Welle aus Zufallszahlen, in der sich nichts wiederholt. Es hat keine Tonhöhe, weil alle Frequenzen zugleich darin stecken, und man hört es als Zischen. Alles an einem Schlagzeug, was rasselt oder raschelt, beginnt als Rauschen.
Die Web Audio API hat keinen Knoten, der Rauschen erzeugt, aber sie spielt alle Zahlen ab, die man ihr gibt. Ein AudioBuffer hält Klang als Liste von Zahlen zwischen -1 und 1, so viele pro Sekunde, wie die sampleRate des Context sagt, und ein AudioBufferSourceNode spielt so einen Buffer ab. Lege src/drums.ts an. Die Datei beginnt mit den Namen der Sounds, sechs Frequenzen, die die Hi-Hats weiter unten brauchen, und dem Rauschen:
import { audio } from './audio.ts';
/** The sounds of the kit, by the short names drum patterns are written with. */
export const DRUM_SOUNDS = ['bd', 'sd', 'hh', 'oh', 'cp', 'rim', 'lt', 'mt', 'ht', 'cb', 'cy'] as const;
export type DrumSound = (typeof DRUM_SOUNDS)[number];
/** The six square waves of a TR-808 hi-hat. Their odd ratios make the metallic sound. */
const METAL = [205.3, 304.4, 369.6, 522.7, 540, 800];
let noiseBuffer: AudioBuffer | undefined;
/** Two seconds of white noise, made once: random numbers between -1 and 1. */
function noise(context: AudioContext): AudioBufferSourceNode {
if (!noiseBuffer) {
noiseBuffer = context.createBuffer(1, context.sampleRate * 2, context.sampleRate);
const data = noiseBuffer.getChannelData(0);
for (let i = 0; i < data.length; i += 1) data[i] = Math.random() * 2 - 1;
}
const source = context.createBufferSource();
source.buffer = noiseBuffer;
source.loop = true;
return source;
}Der Buffer wird einmal gefüllt, mit zwei Sekunden Zufallszahlen, und alle Anschläge teilen ihn sich. Der Quellknoten ist für jeden Anschlag neu: Wie ein Oszillator lässt er sich nur einmal starten. Er läuft in einer Schleife und kann deshalb nicht zu Ende gehen, egal wie lang ein Anschlag dauert.
Die Namen sind die üblichen Kürzel für Schlagzeug-Sounds: bd ist die Bassdrum, sd die Snare, hh die geschlossene Hi-Hat, oh die offene Hi-Hat, cp der Clap, rim der Rimshot, ein Stock auf dem Rand einer Trommel, lt, mt und ht die tiefe, die mittlere und die hohe Tom, cb die Cowbell und cy das Becken. Die Rhythmen der folgenden Teile werden mit diesen Namen geschrieben.
Eine Hüllkurve für jeden Anschlag
Eine Trommel wird angeschlagen und verklingt. Ihre Hüllkurve ist die aus Teil 1 mit einem schnelleren Anfang: innerhalb einer Millisekunde hinauf zur Spitze, dann ein exponentieller Abfall. Die meisten Sounds des Kits benutzen sie. Der nächste Block folgt in derselben Datei:
/** A hit's loudness: up to `peak` in a millisecond, then falling away over `decay` seconds. */
function hit(gain: AudioParam, time: number, peak: number, decay: number): number {
gain.setValueAtTime(0, time);
gain.linearRampToValueAtTime(peak, time + 0.001);
gain.exponentialRampToValueAtTime(peak * 0.001, time + 0.001 + decay);
return time + decay + 0.01;
}Die Funktion bekommt den Parameter gain eines Gain-Knotens und plant die drei Schritte darauf ein. Der Abfall endet bei einem Tausendstel der Spitze. Zurück gibt sie den Moment, in dem der Anschlag vorbei ist, ein paar Millisekunden nach dem Ende des Abfalls: Dann stoppt der Aufrufer seine Oszillatoren oder sein Rauschen.
Zwei Filter
Ein Filter dreht einen Teil der Frequenzen in einem Klang herunter und lässt den Rest durch. Das Kit benutzt zwei Arten. Ein Hochpass lässt durch, was über seiner Frequenz liegt, und dreht herunter, was darunter liegt. Ein Bandpass lässt ein Band um seine Frequenz durch und dreht herunter, was darunter und darüber liegt; sein Q sagt, wie schmal das Band ist, und ein höheres Q ist ein schmaleres Band. Beide sind ein BiquadFilterNode mit einem anderen type. Ein Filter macht aus demselben Zischen verschiedene Sounds: Er bestimmt, welcher Teil des Rauschens übrig bleibt.
Die Rezepte
Bassdrum und Toms, in
drum(): ein Sinus-Oszillator mit fallender Tonhöhe. Die Bassdrum beginnt bei 288 Hz, dem Sechsfachen der 48 Hz, auf denen sie endet, und ist nach 40 ms dort unten. Das Fallen ist der Aufprall des Schlägels, und der tiefe Sinus, der bleibt, ist der Körper der Trommel, der über 0,45 Sekunden verklingt. Die Toms sind dasselbe Rezept bei 82, 110 und 148 Hz mit einem kleineren und langsameren Fall: vom 2,5-Fachen der Tonhöhe, in 60 ms.Snare, in
snare(): zwei Schichten. Rauschen durch einen Hochpass bei 1800 Hz ist das Rasseln der Spiralen, die unter einer Snare gespannt sind. Ein Sinus, der in 20 ms von 370 Hz auf 185 Hz fällt, ist das Fell der Trommel. Das Rauschen dauert länger als der Sinus: 0,18 Sekunden gegen 0,1.Clap, in
clap(): Mehrere Hände klatschen nie im selben Augenblick. Rauschen durch einen Bandpass bei 1300 Hz bekommt drei kurze Stöße im Abstand von 11 ms, und jeder fällt innerhalb von 9 ms von 80 auf 4 Prozent der Spitze. Ein vierter bei 33 ms beginnt bei der vollen Spitze und braucht 120 ms zum Verklingen: der Ausklang.Hi-Hats und Becken, in
metal(): Ein Blech klingt nicht auf einer Tonhöhe. Sechs Rechteckwellen bei 205,3 Hz, 304,4 Hz, 369,6 Hz, 522,7 Hz, 540 Hz und 800 Hz klingen zusammen. Diese Frequenzen stehen in keinem einfachen Verhältnis zueinander, deshalb verschmelzen die sechs nicht zu einer Note. Mit all ihren Obertönen ergeben sie ein dichtes Gemisch, und ein Bandpass bei 9800 Hz und ein Hochpass bei 7000 Hz lassen nur dessen oberes Ende übrig. Die geschlossene Hi-Hat verklingt in 0,05 Sekunden, die offene in 0,35. Das Becken hat tiefere Filter, bei 5000 und 3500 Hz, und braucht 1,4 Sekunden.Rimshot und Cowbell, in
tone(): Rechteckwellen durch einen Bandpass. Der Rimshot ist eine Welle bei 1700 Hz, die nach 25 ms vorbei ist. Die Cowbell besteht aus zwei Wellen, bei 540 und 800 Hz, die eine Viertelsekunde lang verklingen.
Die Klasse ist der Rest der Datei:
/** A drum machine without samples: every hit is built from oscillators and noise. */
export class Drums {
private readonly context = audio();
/** Everything the kit plays goes through this gain: its volume. */
private readonly output = this.context.createGain();
/** The open hi-hat that is still ringing. A closed one cuts it off. */
private openHat: GainNode | undefined;
constructor(output: AudioNode) {
this.output.gain.value = 0.5;
this.output.connect(output);
}
play(sound: string, time: number, velocity = 1) {
switch (sound) {
case 'bd':
return this.drum(time, velocity, 48, 6, 0.04, 0.45);
case 'sd':
return this.snare(time, velocity);
case 'cp':
return this.clap(time, velocity);
case 'hh':
this.choke(time);
return void this.metal(time, velocity * 0.5, 0.05, 9800, 7000);
case 'oh':
this.choke(time);
this.openHat = this.metal(time, velocity * 0.35, 0.35, 9800, 7000);
return;
case 'cy':
return void this.metal(time, velocity * 0.25, 1.4, 5000, 3500);
case 'lt':
return this.drum(time, velocity, 82, 2.5, 0.06, 0.35);
case 'mt':
return this.drum(time, velocity, 110, 2.5, 0.06, 0.35);
case 'ht':
return this.drum(time, velocity, 148, 2.5, 0.06, 0.35);
case 'rim':
return this.tone(time, velocity * 0.5, [1700], 0.025, 1700, 3);
case 'cb':
return this.tone(time, velocity * 0.2, [540, 800], 0.25, 800, 1.5);
}
}
/** Kick and toms: a sine whose pitch falls from `hz * punch` to `hz`. */
private drum(time: number, peak: number, hz: number, punch: number, fall: number, decay: number) {
const oscillator = this.context.createOscillator();
oscillator.frequency.setValueAtTime(hz * punch, time);
oscillator.frequency.exponentialRampToValueAtTime(hz, time + fall);
const envelope = this.context.createGain();
oscillator.connect(envelope).connect(this.output);
oscillator.start(time);
oscillator.stop(hit(envelope.gain, time, peak, decay));
}
/** Snare: noise above 1800 Hz for the wires, and a short sine for the drum's skin. */
private snare(time: number, peak: number) {
const wires = noise(this.context);
const highpass = this.context.createBiquadFilter();
highpass.type = 'highpass';
highpass.frequency.value = 1800;
const wiresEnvelope = this.context.createGain();
wires.connect(highpass).connect(wiresEnvelope).connect(this.output);
wires.start(time, Math.random());
wires.stop(hit(wiresEnvelope.gain, time, peak * 0.6, 0.18));
const skin = this.context.createOscillator();
skin.frequency.setValueAtTime(370, time);
skin.frequency.exponentialRampToValueAtTime(185, time + 0.02);
const skinEnvelope = this.context.createGain();
skin.connect(skinEnvelope).connect(this.output);
skin.start(time);
skin.stop(hit(skinEnvelope.gain, time, peak * 0.5, 0.1));
}
/** Clap: three short bursts of noise, a few milliseconds apart, and a tail. */
private clap(time: number, peak: number) {
const source = noise(this.context);
const bandpass = this.context.createBiquadFilter();
bandpass.type = 'bandpass';
bandpass.frequency.value = 1300;
bandpass.Q.value = 1.2;
const envelope = this.context.createGain();
source.connect(bandpass).connect(envelope).connect(this.output);
const gain = envelope.gain;
gain.setValueAtTime(0, time);
for (const offset of [0, 0.011, 0.022]) {
gain.setValueAtTime(peak * 0.8, time + offset);
gain.exponentialRampToValueAtTime(peak * 0.04, time + offset + 0.009);
}
gain.setValueAtTime(peak, time + 0.033);
gain.exponentialRampToValueAtTime(peak * 0.001, time + 0.153);
source.start(time, Math.random());
source.stop(time + 0.16);
}
/** Hi-hats and cymbal: six square waves through a band-pass and a high-pass. */
private metal(time: number, peak: number, decay: number, band: number, floor: number): GainNode {
const mix = this.context.createGain();
const bandpass = this.context.createBiquadFilter();
bandpass.type = 'bandpass';
bandpass.frequency.value = band;
bandpass.Q.value = 0.8;
const highpass = this.context.createBiquadFilter();
highpass.type = 'highpass';
highpass.frequency.value = floor;
const envelope = this.context.createGain();
// A gain of its own after the envelope, so that the hit can be cut off later.
const out = this.context.createGain();
mix.connect(bandpass).connect(highpass).connect(envelope).connect(out).connect(this.output);
const end = hit(envelope.gain, time, peak, decay);
for (const hz of METAL) {
const oscillator = this.context.createOscillator();
oscillator.type = 'square';
oscillator.frequency.value = hz;
oscillator.connect(mix);
oscillator.start(time);
oscillator.stop(end);
}
return out;
}
/** Rim shot and cowbell: short square waves through a band-pass. */
private tone(time: number, peak: number, pitches: number[], decay: number, band: number, q: number) {
const bandpass = this.context.createBiquadFilter();
bandpass.type = 'bandpass';
bandpass.frequency.value = band;
bandpass.Q.value = q;
const envelope = this.context.createGain();
bandpass.connect(envelope).connect(this.output);
const end = hit(envelope.gain, time, peak, decay);
for (const hz of pitches) {
const oscillator = this.context.createOscillator();
oscillator.type = 'square';
oscillator.frequency.value = hz;
oscillator.connect(bandpass);
oscillator.start(time);
oscillator.stop(end);
}
}
/** A closed hi-hat stops the open one, as on a real pair of cymbals. */
private choke(time: number) {
if (!this.openHat) return;
this.openHat.gain.setTargetAtTime(0, time, 0.004);
this.openHat = undefined;
}
}Alles läuft durch einen Gain-Knoten,
output, der auf 0,5 steht: die Lautstärke des Kits. Der Konstruktor verbindet ihn mit dem Knoten, den er bekommt.play()wählt das Rezept nach dem Namen des Sounds und übergeht Namen, die es nicht kennt.velocitysagt, wie fest die Trommel angeschlagen wird, mit 1 für einen vollen Anschlag, und skaliert die Spitze der Hüllkurve. Die Faktoren daneben, etwa 0,5 für die geschlossene Hi-Hat und 0,2 für die Cowbell, gleichen die Sounds untereinander aus.Ein Oszillator, dessen
typenicht gesetzt ist, ist ein Sinus.drum()und das Fell der Snare verlassen sich darauf.frequencyist ein Audio-Parameter wiegain, eine Tonhöhe lässt sich also auf dieselbe Art mit einer Rampe bewegen. Die fallende Tonhöhe der Bassdrum ist ein einzigesexponentialRampToValueAtTime().Das Rauschen beginnt an einer zufälligen Stelle:
start(time, Math.random())setzt bis zu einer Sekunde tief im Buffer ein. Keine zwei Anschläge der Snare sind dasselbe Stück Rauschen.clap()plant seine Hüllkurve von Hand ein, ohnehit():setValueAtTime()springt hinauf, die Rampe fällt, dreimal hintereinander, und dann kommt der Ausklang.In
metal()laufen die sechs Oszillatoren inmix, einen Gain-Knoten, der nichts tut, als sie zu sammeln. Die Methode gibt einen Knoten zurück, denplay()nur für die offene Hi-Hat braucht.return void this.metal(…)wirft ihn bei den anderen weg.
Die offene Hi-Hat
Eine Hi-Hat ist ein Paar Becken auf einem Ständer mit Pedal. Offen klingen sie nach. Geschlossen geben sie ein kurzes Ticken von sich, und sie zu schließen beendet das Nachklingen. Ein Drumcomputer macht das nach: Eine geschlossene Hi-Hat schneidet eine offene ab, die noch klingt. Ohne das würde die offene Hi-Hat über die geschlossenen nach ihr hinwegklingen, und man würde die beiden nicht mehr als ein Instrument hören.
Dafür muss etwas an einen Sound herankommen, der schon spielt. Die Lautstärke der Hüllkurve taugt dazu nicht: Ihre Werte sind bis zum Ende des Anschlags eingeplant, und ein Schnitt müsste in diesen Plan eingreifen. Also setzt metal() einen weiteren Gain-Knoten hinter die Hüllkurve, out, auf dem nichts eingeplant ist. play() merkt sich den der letzten offenen Hi-Hat in openHat, und choke() dreht ihn herunter: setTargetAtTime(0, time, 0.004) lässt die Lautstärke ab time auf 0 zulaufen und alle 4 ms etwa zwei Drittel des restlichen Wegs zurücklegen. Nach 20 ms ist weniger als ein Hundertstel des Sounds übrig, und weil die Lautstärke nie springt, knackt der Schnitt nicht. Auch die offene Hi-Hat ruft zuerst choke() auf, sie beendet also ebenfalls die offene vor ihr.
Ein Rhythmus in sechzehn Schritten
Ein Drumcomputer teilt den Takt in sechzehn Schritte, vier pro Schlag, und jeder Sound ist an jedem Schritt an oder aus. Aufgeschrieben ist das eine Zeichenkette aus sechzehn Zeichen pro Sound: Ein x spielt, ein Punkt schweigt.
Ersetze in index.html das Element <main>. Die Bühne bekommt einen Platz für eine Reihe Pads, und der Hinweis ändert sich:
<main class="stage">
<div id="pads" class="pads"></div>
<p class="hint">Click a pad to hear a sound, or press Play for the beat.</p>
</main>In src/main.ts fallen beep() und das Metronom weg, und mit ihnen der Import von midiToFreq. Die Funktion selbst bleibt in src/audio.ts: Der Synth aus Teil 8 braucht sie. Ersetze alles über dem Play-Button, von den Importen bis zum Metronom, durch:
import { audio } from './audio.ts';
import { Clock } from './clock.ts';
import { DRUM_SOUNDS, Drums } from './drums.ts';
import './style.css';
const drums = new Drums(audio().destination);
/** One bar in sixteen steps per sound: x plays, a dot is silent. */
const BEAT: Record<string, string> = {
bd: 'x...x...x...x...',
sd: '....x.......x...',
hh: 'x.x.x.x.x.xxx.x.',
oh: '..............x.',
};
const clock = new Clock((from, to) => {
// Steps are sixteenths of a cycle. Take every step that starts inside the stretch.
for (let step = Math.ceil(from * 16); step < to * 16; step += 1) {
for (const [sound, steps] of Object.entries(BEAT)) {
if (steps[step % 16] === 'x') drums.play(sound, clock.timeAt(step / 16));
}
}
});Das Kit spielt direkt in die Lautsprecher. Die Funktion der Uhr hat die Form der Funktion des Metronoms, mit 16, wo die 4 stand: Ein Schritt ist ein Sechzehntel eines Zyklus, und Math.ceil() findet den ersten Schritt, der im Abschnitt beginnt. Für jeden Schritt geht sie die vier Zeichenketten durch und spielt die Sounds, die an dieser Stelle ein x haben. step % 16 beginnt die Zeichenketten in jedem Takt von vorn.
Lies den Rhythmus Zeile für Zeile. Die Bassdrum liegt auf jedem Schlag. Die Snare liegt auf den Schlägen 2 und 4. Die geschlossene Hi-Hat spielt auf jedem zweiten Schritt und noch einmal auf dem zwölften. Die offene Hi-Hat liegt auf dem fünfzehnten Schritt, und die geschlossene auf dem ersten Schritt des nächsten Takts schneidet ab, was von ihr noch übrig ist.
Der Play-Button und der Tempo-Regler bleiben, wie sie sind. Ergänze zwischen dem Regler und draw() ein Pad für jeden Sound:
// A pad per sound, to hear each one by itself.
const pads = document.querySelector<HTMLDivElement>('#pads')!;
for (const sound of DRUM_SOUNDS) {
const pad = document.createElement('button');
pad.textContent = sound;
pad.addEventListener('click', async () => {
await audio().resume();
drums.play(sound, audio().currentTime);
});
pads.append(pad);
}Ein Pad spielt seinen Sound jetzt, bei currentTime, wie die Tasten aus Teil 1. Das tut es auch, während der Rhythmus läuft.
Ergänze am Ende von src/style.css die Regeln für die Pads. In diesem Teil fällt keine Regel weg:
.pads {
display: flex;
flex-wrap: wrap;
justify-content: center;
gap: 6px;
max-width: 420px;
}
.pads button {
width: 64px;
height: 64px;
}Probier es aus
Klick die Pads der Reihe nach an und vergleiche, was du hörst, mit den Rezepten: die fallende Tonhöhe am Anfang von bd, die zwei Schichten von sd, die Stöße am Anfang von cp, die drei Toms von tief nach hoch.
Klick
ohan und lass es ausklingen. Klick es dann noch einmal an und gleich danachhh: Das Nachklingen bricht ab. Sei schnell, die offene Hi-Hat klingt nur eine Drittelsekunde lang.Klick
sdein paar Mal an. Die Anschläge unterscheiden sich ein wenig voneinander, weil jeder ein anderes Stück des Rauschens nimmt.Drück Play. Bassdrum, Snare und Hi-Hats spielen den Rhythmus, und die Pads funktionieren weiter darüber. Beweg den Tempo-Regler: Der Rhythmus behält bei jedem Tempo seine Form, weil er in Schritten und nicht in Sekunden geschrieben ist.
Ändere den Rhythmus in
BEAT. Vite lädt die Seite neu, wenn du speicherst, drück also wieder Play. Probierbd: 'x..x..x...x.x...', oder ergänze die Zeilecp: '....x.......x...', um einen Clap auf die Snare zu legen.Ändere ein Rezept. Ändere in
play()in der Zeile fürbddie 6, denpunchder Bassdrum, auf 2: Die Tonhöhe fällt viel weniger, und der Aufprall am Anfang wird dadurch schwächer. Ändere die0.45, ihrendecay, auf1.5: Der tiefe Sinus klingt anderthalb Sekunden nach.
Stell src/main.ts und src/drums.ts wieder her, bevor du weitermachst. Der Rhythmus steht vorerst fest im Code. Der nächste Teil macht aus Rhythmen Funktionen, die sich kombinieren und im Spielen austauschen lassen.
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.