Eine Live-Coding-Musik-App bauen · Teil 14 von 18 der Serie
Teil 14: Bewegung mit LFOs
Lass langsame Wellen an den Reglern drehen: Ein LFO bewegt den Cutoff, die Tonhöhe oder die Lautstärke eines anderen Bausteins. Er ist ein Kabel in einen Audio-Parameter, und seine Welle wird aus dem Zyklus berechnet, also bleibt sie fest an den Takten.
Eine Live-Coding-Musik-App bauenTeil 14 von 18
Auf dieser Seite
Quest-Ziele
- Ein Signal mit einem Audio-Parameter verbinden, der es zu seinem eigenen Wert addiert
- detune, gezählt in Cent, als Eingang für eine Modulation nutzen
- Eine Welle aus dem Zyklus berechnen, sechzehn Punkte pro Runde
- Bausteinen Einstellungen geben, die der Code benennen kann, etwa bass.cutoff
- Eine dritte Art von Kabel in den Patch und die Engine einbauen
Der Bass des Songs spielt jeden Takt mit derselben Filtereinstellung. An einem Synth mit Reglern ist es eine Hand am Cutoff, der Grenzfrequenz, über der der Filter den Klang leiser dreht, die eine solche Linie zum Leben erweckt: langsam auf, langsam zu. Ein LFO, ein Low Frequency Oscillator, ist diese Hand. Er ist eine Welle, die viel zu langsam ist, um als Ton gehört zu werden, oft eine Runde in mehreren Sekunden, und niemand hört ihr zu: Ihr Wert bewegt eine Einstellung eines anderen Bausteins. Eine Einstellung mit einem Signal zu bewegen, heißt Modulation. Im Song ist es eine Zeile: lfo({ rate: 0.25, depth: 0.6 }).mod(bass.cutoff).
Ein Parameter zählt zusammen
Einstellungen wie filter.frequency oder gain.gain sind Audio-Parameter. Bisher haben sie Werte bekommen, sofort oder entlang einer Rampe. Sie haben einen zweiten Eingang: Der Ausgang eines Knotens lässt sich mit einem Parameter verbinden, mit demselben connect(), das Knoten zusammensteckt. Der Parameter zählt dann seinen eigenen Wert und alles, was mit ihm verbunden ist, zusammen, Abtastwert für Abtastwert. Eine Modulation braucht also keinen neuen Mechanismus. Sie ist ein Kabel, das in einem Parameter endet.
Der Cutoff des Mono-Synths sieht dafür allerdings nach einer schlechten Stelle aus. filter.frequency ist beschäftigt: Jede Note setzt sie auf einen Spitzenwert und lässt sie zurückfallen, das ist die Filterhüllkurve aus Teil 8. Und Hertz zu addieren, ist das falsche Maß. 200 Hz mehr sind bei einem Cutoff von 300 Hz ein großer Schritt und bei 3000 Hz kaum ein Unterschied. Das Ohr hört Frequenzen als Verhältnisse: Eine Oktave ist eine Verdopplung, egal wo sie beginnt.
Der Filterknoten hat genau dafür einen zweiten Parameter: detune. Er wird in Cent gezählt, wie in Teil 12: 100 Cent sind ein Halbton, der Schritt von einer Note zur nächsten, und 1200 sind eine Oktave. Er verschiebt die Frequenz um dieses Intervall, wo auch immer die Frequenz gerade steht: 1200 Cent verdoppeln sie, -1200 halbieren sie. Bisher hat nichts das detune des Filters benutzt, also steht es auf 0. Dort geht der LFO hinein, und Hüllkurve und LFO kommen sich nicht in die Quere: Die eine setzt die Frequenz, der andere verschiebt sie. Der Oszillator hat ein detune derselben Art, für die Tonhöhe.
Bleibt die Frage, wie weit. Der LFO gibt eine Welle zwischen -1 und 1 aus, multipliziert mit seiner Tiefe, depth, einer Zahl von 0 bis 1. Ein Gain-Knoten zwischen dem LFO und dem Parameter multipliziert sie mit einer Zahl, die zur Einstellung passt: 2400 für einen Cutoff, das sind zwei Oktaven hinauf und zwei hinunter, 100 für eine Tonhöhe, das ist ein Halbton, und 0.5 für eine Lautstärke, die Hälfte ihres Bereichs von 0 bis 1. Ein Baustein führt die Einstellungen, die er anbietet, zusammen mit dieser Zahl auf. Ersetze in src/unit.ts alles unter den Imports:
/** A setting that can be modulated: the parameter to add to, and how far a depth of 1 moves it. */
export interface Target {
param: AudioParam;
scale: number;
}
/** A unit of the patch as it runs: what the engine creates for a UnitSpec. */
export interface Unit {
/** Where audio comes in, and where it leaves. */
readonly input?: AudioNode;
readonly output?: AudioNode;
/** The settings of this unit that an LFO can move, by name. */
readonly targets?: Record<string, Target>;
/** Takes over new options without starting over. */
update(options: Options): void;
/** The notes this unit gives for a stretch of cycles. */
events?(from: number, to: number, clock: Clock): NoteEvent[];
/** Schedules whatever this unit does by itself over a stretch of cycles. */
schedule?(from: number, to: number, clock: Clock): void;
/** Plays a note. */
play?(event: NoteEvent): void;
/** Told the length of a cycle in seconds, after every run of the code. */
tempo?(cycleSeconds: number): void;
/** Called when the music stops: let go of every note that is still held. */
stop?(): void;
dispose(): void;
}Target und targets sind neu, ebenso schedule(), das der LFO gleich braucht. Der Mono-Synth bietet drei Einstellungen an. Importiere in src/monoSynth.ts den Typ Target aus ./unit.ts neben Unit, und ergänze in der Klasse ein Feld, nach options:
/**
* What an LFO can move. A parameter adds up its own value and everything connected to it.
* The filter and the oscillator have a second parameter for exactly that, counted in cents:
* `detune`. 2400 cents are two octaves, 100 are a semitone.
*/
readonly targets: Record<string, Target> = {
cutoff: { param: this.filter.detune, scale: 2400 },
pitch: { param: this.oscillator.detune, scale: 100 },
volume: { param: this.output.gain, scale: 0.5 },
};Der Poly-Synth erzeugt für jede Note neue Oszillatoren, also gibt es bei ihm nicht den einen Parameter für die Tonhöhe, in dem ein Kabel enden könnte. Seinen Filter und den Gain-Knoten an seinem Ausgang teilen sich alle Noten. Ergänze in src/polySynth.ts, mit demselben Import, ein Feld nach output:
readonly targets: Record<string, Target> = {
cutoff: { param: this.filter.detune, scale: 2400 },
volume: { param: this.output.gain, scale: 0.5 },
};Der Filter-Effekt bietet seinen Cutoff an. Importiere in src/effects.ts ebenfalls Target, und ergänze in Filter ein Feld, nach filter:
readonly targets: Record<string, Target> = {
cutoff: { param: this.filter.detune, scale: 2400 },
};Fest an den Takten
Die Web Audio API hat einen Oszillator-Knoten, und einer mit einem halben Hertz, verbunden mit dem Parameter, würde ihn bewegen. Aber er liefe nach seiner eigenen Uhr. Er startet, wenn er erzeugt wird, seine Geschwindigkeit wird in Hertz gezählt und weiß nichts vom Tempo, und nach einem Stopp und einem Start steht er woanders in seiner Runde. Eine Bewegung, die vier Takte dauern soll, würde gegen die Takte wandern.
Die Patterns haben dieses Problem nicht, weil sie Funktionen der Zeit sind (Teil 4): Nach einem Abschnitt in Zyklen gefragt, sagen sie, was darin passiert. Der LFO arbeitet genauso. Seine rate wird in Runden pro Zyklus gezählt, und sein Wert folgt in jedem Moment allein aus dem Zyklus. Mit einer Rate von 1 geht ein Sinus genau einmal pro Takt herum, und er steht an derselben Stelle jedes Takts an derselben Stelle seiner Runde, bei jedem Tempo.
Den Wert trägt eine Konstantquelle: ein Knoten, der bei jedem Abtastwert dieselbe Zahl ausgibt. Diese Zahl, sein offset, ist ein Audio-Parameter, lässt sich also wie eine Hüllkurve im Voraus auf der Audio-Uhr einplanen. Der LFO plant 16 Punkte pro Runde ein und lässt den Wert in einer geraden Linie von einem zum nächsten laufen. Für eine Einstellung, die sich über einen Takt bewegt, sind sechzehn gerade Stücke nah genug an der Kurve. Lege src/lfo.ts an:
import { audio } from './audio.ts';
import type { Clock } from './clock.ts';
import { random, snap } from './pattern.ts';
import type { Unit } from './unit.ts';
export type LfoOptions = {
shape: 'sine' | 'triangle' | 'saw' | 'square' | 'random';
/** How many times the wave goes round per cycle: 0.25 takes four bars. */
rate: number;
/** How far it moves what it is connected to, from 0 to 1. */
depth: number;
};
/** How many points of the wave are scheduled per round. Between them the value moves evenly. */
const POINTS = 16;
/** The wave at a point of its round, from -1 to 1. `round` counts the rounds, for the random shape. */
function wave(shape: LfoOptions['shape'], point: number, round: number): number {
const phase = point / POINTS;
switch (shape) {
case 'sine':
return Math.sin(phase * 2 * Math.PI);
case 'triangle':
return 1 - 4 * Math.abs(phase - 0.5);
case 'saw':
return phase * 2 - 1;
case 'square':
return phase < 0.5 ? 1 : -1;
case 'random':
return random(round, 7) * 2 - 1;
}
}wave() gibt die Höhe einer Form an einem der 16 Punkte:
sinebeginnt in der Mitte, geht zuerst nach oben und ist nach einem Viertel der Runde ganz oben.trianglebeginnt unten und erreicht in der Mitte der Runde die Spitze, entlang zweier gerader Linien.sawsteigt von unten durch die ganze Runde und fällt am Anfang der nächsten zurück.squareist in der ersten Hälfte oben und in der zweiten unten.randomwählt für jede Runde eine neue Höhe und hält sie. Es benutztrandom()aus Teil 6, das für dieselbe Runde jedes Mal dieselbe Zahl gibt, also ist der Song bei jedem Abspielen derselbe.
Die Klasse folgt in derselben Datei:
/**
* A low frequency oscillator: a slow wave that moves a setting of another unit. It is not an
* oscillator node. Its value is worked out from the cycle, like the notes of a pattern, so
* it is always at the same place of its round at the same place of the bar.
*/
export class Lfo implements Unit {
private readonly context = audio();
/** A source that puts out a constant number: the one we keep changing. */
readonly output = this.context.createConstantSource();
private options: LfoOptions;
constructor(options: LfoOptions) {
this.options = options;
this.output.offset.value = 0;
this.output.start();
}
update(options: LfoOptions) {
this.options = options;
}
/** Schedules the wave's points for a stretch of cycles. */
schedule(from: number, to: number, clock: Clock) {
const { shape, rate, depth } = this.options;
const step = 1 / (rate * POINTS);
for (let index = Math.ceil(snap(from / step)); index * step < to; index += 1) {
const point = index % POINTS;
const value = depth * wave(shape, point, Math.floor(index / POINTS));
const time = clock.timeAt(index * step);
// A jump of the wave is set at once. Everything else is reached in a straight line.
const jump = shape === 'square' || shape === 'random' || (shape === 'saw' && point === 0);
if (jump) this.output.offset.setValueAtTime(value, time);
else this.output.offset.linearRampToValueAtTime(value, time);
}
}
stop() {
const now = this.context.currentTime;
this.output.offset.cancelScheduledValues(now);
this.output.offset.setTargetAtTime(0, now, 0.05);
}
dispose() {
this.output.stop();
this.output.disconnect();
}
}schedule() bekommt einen Abschnitt in Zyklen, wie die Patterns. Die Punkte liegen step Zyklen auseinander: Bei einer Rate von 1 ist das ein Sechzehntel eines Zyklus, bei 0.25 ein Viertel. Der Punkt mit der Nummer index liegt beim Zyklus index × step, gezählt ab dem Anfang des Songs. Die Schleife beginnt beim ersten Punkt bei oder nach from und endet vor to, also wird jeder Punkt genau einmal eingeplant, egal wie die Zeit in Abschnitte geschnitten wird. Das ist der Vertrag der Uhr aus Teil 2. index % POINTS ist die Stelle in der Runde, und index / POINTS, abgerundet, ist die Nummer der Runde.
linearRampToValueAtTime erreicht den Wert zur Zeit des Punkts, in einer geraden Linie vom Punkt davor. Wo eine Form springt, würde eine Rampe den Sprung über ein Sechzehntel der Runde verschmieren. Deshalb werden das Rechteck und die zufällige Form sowie der Sägezahn am Anfang seiner Runde mit setValueAtTime gesetzt.
update() merkt sich nur die neuen Optionen. Die eingeplanten Punkte bleiben, und der nächste Abschnitt, höchstens eine Zehntelsekunde voraus, benutzt die neuen Optionen. stop() nimmt zurück, was eingeplant ist, und lässt den Wert auf 0 zurückgehen, sodass ein gestoppter Song seine Einstellungen dort hat, wo der Code sie hingestellt hat.
Eine dritte Art von Kabel
Ein Patch hat Kabel für Noten und Kabel für Audio. Eine Modulation ist eine dritte Art, und sie muss sagen, welche Einstellung ihres Ziels sie meint. Ersetze in src/patch.ts Cable:
/** A connection from one unit to another, by their ids. */
export interface Cable {
from: string;
to: string;
kind: 'notes' | 'audio' | 'mod';
/** For a modulation: the setting of the target that is moved. */
target?: string;
}Das Schema braucht dieselben zwei Ergänzungen: Ein Bausteintyp kann 'mod' geben, und er kann Ziele aufführen, jedes mit einem Satz, der sagt, was eine Tiefe von 1 tut. Teil 17 zeigt diese Sätze im Editor. Ersetze in src/schema.ts UnitType:
export interface UnitType {
doc: string;
/** What its input takes, if it has one, and what its output gives. */
takes?: 'notes' | 'audio';
gives?: 'notes' | 'audio' | 'mod';
options: Record<string, OptionSpec>;
/** The settings an LFO can move, with what a depth of 1 does to them. */
targets?: Record<string, string>;
}Ergänze die drei Sätze unter WAVES:
const TARGETS = {
cutoff: 'Moves the cutoff up and down, by up to two octaves.',
pitch: 'Moves the pitch up and down, by up to a semitone.',
volume: 'Moves the volume up and down, by up to half of the whole range.',
};Drei Einträge von UNITS bekommen eine Zeile, jeweils nach der schließenden Klammer ihrer options. Für monoSynth:
targets: TARGETS,Für polySynth:
targets: { cutoff: TARGETS.cutoff, volume: TARGETS.volume },Für filter:
targets: { cutoff: TARGETS.cutoff },Der LFO selbst ist ein neuer Eintrag am Ende von UNITS, nach distortion. Er hat keinen Eingang, und was er gibt, sind weder Noten noch Audio:
lfo: {
doc: 'A slow wave that moves a setting of another unit: lfo().mod(bass.cutoff). It is locked to the bars.',
gives: 'mod',
options: {
shape: { doc: 'The shape of the wave.', default: 'sine', choices: ['sine', 'triangle', 'saw', 'square', 'random'] },
rate: { doc: 'How many times the wave goes round per bar: 0.25 takes four bars.', default: 1, min: 0.0625, max: 32 },
depth: { doc: 'How far it moves the setting, from 0 to 1.', default: 0.5, min: 0, max: 1 },
},
},Regler im Code
Damit lfo().mod(bass.cutoff) funktioniert, muss bass.cutoff etwas sein. Das Skript macht daraus ein kleines Objekt, das seinen Baustein und seinen Namen kennt. Ergänze in src/script.ts über Handle:
/** A setting of a unit that an LFO can move: what `bass.cutoff` is in the code. */
class Knob {
readonly unit: Handle;
readonly name: string;
constructor(unit: Handle, name: string) {
this.unit = unit;
this.name = name;
}
}Ersetze Handle:
/** What the code holds in its variables: a unit of the patch, which can be connected. */
class Handle {
readonly id: string;
readonly type: string;
private readonly spec: UnitType;
private readonly patch: Patch;
constructor(id: string, type: string, spec: UnitType, patch: Patch) {
this.id = id;
this.type = type;
this.spec = spec;
this.patch = patch;
// Every setting that can be modulated becomes a property: bass.cutoff, bass.volume.
for (const name of Object.keys(spec.targets ?? {})) {
Object.defineProperty(this, name, { value: new Knob(this, name), enumerable: true });
}
}
/** Connects this unit to another one. Gives back the other one, so that calls can be chained. */
to(target: Handle): Handle {
if (!(target instanceof Handle)) throw new ScriptError(`${this.type}.to() needs something to connect to, such as out`);
const gives = this.spec.gives;
const takes = target.spec.takes;
if (!gives) throw new ScriptError(`${this.type} has no output`);
if (gives === 'mod') throw new ScriptError('An lfo is connected with mod(), like lfo().mod(bass.cutoff)');
if (gives !== takes) {
throw new ScriptError(`${this.type} gives ${gives}, but ${target.type} ${takes ? `takes ${takes}` : 'has no input'}`);
}
this.patch.cables.push({ from: this.id, to: target.id, kind: gives });
return target;
}
/** Lets this LFO move a setting of another unit. Gives back the LFO, to move more than one. */
mod(knob: Knob): Handle {
if (this.spec.gives !== 'mod') throw new ScriptError(`${this.type} can't modulate anything. Only an lfo can`);
if (knob === undefined) throw new ScriptError('That unit has no such setting. mod() needs one like bass.cutoff');
if (!(knob instanceof Knob)) throw new ScriptError('mod() needs a setting of a unit, such as bass.cutoff');
this.patch.cables.push({ from: this.id, to: knob.unit.id, kind: 'mod', target: knob.name });
return this;
}
}Der Konstruktor gibt dem Handle eine Eigenschaft pro Ziel seines Typs. Er benutzt Object.defineProperty und keine Zuweisung, weil die Namen aus dem Schema kommen und nicht aus der Klasse, und weil sich eine so definierte Eigenschaft nicht überschreiben lässt. bass.cutoff = 500 ist ein Fehler an seiner Zeile und keine Zeile, die stillschweigend nichts tut.
mod() fügt ein Kabel der neuen Art hinzu. Anders als to() gibt es den LFO zurück und nicht das Ziel, sodass ein LFO mehrere Einstellungen bewegen kann: lfo().mod(bass.cutoff).mod(keys.cutoff). Drei Fehler bekommen eine eigene Meldung. Ein Baustein, der kein LFO ist, kann nicht modulieren. Eine Einstellung, die der Baustein nicht hat, etwa kit.cutoff, ist in JavaScript undefined, und die Meldung sagt, dass es diese Einstellung nicht gibt. Alles andere, was kein Regler ist, eine Zahl zum Beispiel, wird ebenfalls abgewiesen. Und to() hat eine neue Zeile: Ein LFO, der mit to() verbunden wird, wird auf mod() verwiesen.
console.log(bass.cutoff) soll etwas Lesbares ausgeben. Ersetze show():
/** Turns a value into the text `console.log` shows for it. */
function show(value: unknown): string {
if (typeof value === 'string') return value;
if (value instanceof Handle) return `[${value.id}]`;
if (value instanceof Knob) return `[${value.unit.id}.${value.name}]`;
try {
return JSON.stringify(value) ?? String(value);
} catch {
return String(value);
}
}Es gibt [monoSynth1.cutoff] aus.
Die Engine steckt es ein
Importiere in src/engine.ts Lfo und den Typ LfoOptions aus ./lfo.ts, und ergänze eine Zeile am Ende von FACTORIES:
lfo: (options) => new Lfo(options as LfoOptions),Die Gain-Knoten zwischen den LFOs und ihren Zielen gehören zu den Kabeln, nicht zu einem Baustein, also behält die Engine sie. Ergänze in Engine ein Feld, nach routes:
/** The gains between the LFOs and what they move: each one sets how far. */
private amounts: GainNode[] = [];Ersetze in apply() Schritt 3, von seinem Kommentar bis zum return:
// 3. Cables: unplug every output, then plug in what the patch says. Both happen within
// a moment, so as a rule nothing of it is heard.
for (const unit of this.units.values()) unit.output?.disconnect();
for (const amount of this.amounts) amount.disconnect();
this.amounts = [];
this.routes = new Map();
for (const cable of patch.cables) {
const from = this.units.get(cable.from)!;
const to = this.units.get(cable.to)!;
if (cable.kind === 'audio') {
from.output!.connect(to.input!);
} else if (cable.kind === 'notes') {
this.routes.set(from, [...(this.routes.get(from) ?? []), to]);
} else {
// A modulation: the LFO's wave, scaled, is added to the parameter.
const target = to.targets![cable.target!];
const amount = audio().createGain();
amount.gain.value = target.scale;
from.output!.connect(amount).connect(target.param);
this.amounts.push(amount);
}
}
if (patch.bpm !== this.clock.bpm) this.clock.bpm = patch.bpm;
for (const unit of this.units.values()) unit.tempo?.(this.clock.cycleSeconds);
return count;Modulationskabel werden behandelt wie Audio-Kabel: alle ausgesteckt, dann eingesteckt, wie der Patch es sagt, zwischen zwei Blöcken Audio. Jedes bekommt einen neuen Gain-Knoten mit dem scale seines Ziels, zwischen dem Ausgang des LFO und dem Parameter. Die Welle selbst steckt im LFO, der weiterläuft, also ist vom Umstecken nichts zu hören.
Zuletzt muss der LFO nach seinen Punkten gefragt werden. Ersetze schedule():
/**
* 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) ?? []) {
for (const target of targets) target.play?.(event);
}
}
}Jeder Baustein, der ein schedule() hat, bekommt jeden Abschnitt, bevor die Noten verteilt werden.
Der Song
Ergänze in src/song.ts beim Bass eine Zeile, nach bass.to(…):
lfo({ rate: 0.25, depth: 0.6 }).mod(bass.cutoff)Eine Rate von 0.25 ist eine Runde in vier Takten, so lang wie die vier Akkorde. Der LFO multipliziert seine Welle mit der Tiefe, und der Gain-Knoten des Kabels multipliziert sie mit 2400, also bewegt eine Tiefe von 0.6 den Cutoff um bis zu 1440 Cent, 1,2 Oktaven: von seinen 300 Hz hinauf bis etwa 690 Hz und hinunter bis etwa 130 Hz. Der Sinus beginnt in der Mitte. Der Filter öffnet sich durch den ersten Takt, ist am Anfang des zweiten am weitesten offen und am Anfang des vierten am weitesten zu.
Probier es aus
Drück auf Play und hör dem Bass vier Takte lang zu: Er wird heller, dann dumpfer, und wenn die Position 5.1 zeigt, ist er dort, wo er begonnen hat. Stoppe und starte noch einmal: Die Bewegung beginnt an derselben Stelle. Ändere dann den Code, während er spielt:
Ändere
bpm(124)aufbpm(90)und führe den Code aus. Die Bewegung wird mit dem Song langsamer und dauert immer noch vier Takte.Gib dem LFO
shape: 'square', rate: 2. Der Cutoff springt auf jedem Schlag zwischen zwei Stellen: hinauf auf den Schlägen 1 und 3, hinunter auf 2 und 4.Gib ihm
shape: 'saw', rate: 4. Der Filter öffnet sich über jeden Schlag und fällt beim nächsten zu.Gib ihm
shape: 'random', rate: 4. Jeder Schlag hat seinen eigenen Cutoff, und es ist bei jedem Start des Songs dieselbe Folge.Ergänze
lfo({ rate: 8, depth: 0.3 }).mod(bass.pitch). Die Tonhöhe des Basses schwankt um 30 Cent hinauf und hinunter, achtmal pro Takt.Ergänze
lfo({ rate: 4, depth: 0.8 }).mod(keys.volume)am Ende des Codes, wo eskeysschon gibt. Die Akkorde schwellen einmal pro Schlag an und ab.Schreib
lfo().to(out)oderlfo().mod(kit.cutoff), und lies die Zeile unter dem Editor.
Auch ein Filter-Effekt lässt sich bewegen. Ersetze den Song durch:
bpm(120)
const keys = polySynth({ release: 0.4 })
pattern('[c3,e3,g3]*8').to(keys)
const sweep = filter({ cutoff: 800, resonance: 6 })
keys.to(sweep).to(out)
lfo({ shape: 'triangle', rate: 0.5, depth: 1 }).mod(sweep.cutoff)Derselbe Akkord achtmal pro Takt, durch einen Filter, den ein Dreieck von 800 Hz aus zwei Oktaven hinunter und hinauf bewegt, einmal in zwei Takten: von 200 Hz am Anfang bis 3200 Hz einen Takt später, und zurück.
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.