Zum Inhalt springen

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

Teil 15: Deine eigenen Sounds

Bau einen Sampler, der Aufnahmen in der Tonhöhe jeder Note abspielt. Audiodateien werden dekodiert, in IndexedDB aufbewahrt und in einer Leiste über dem Code aufgelistet, eine Glocke entsteht in einem OfflineAudioContext, und Dateien lassen sich auf die Seite ziehen.

Quest-Ziele

  • Audiodateien in Puffer dekodieren und in IndexedDB aufbewahren
  • Eine Glocke mit einem OfflineAudioContext in einen Puffer rendern
  • Einen Puffer schneller oder langsamer abspielen, um seine Tonhöhe zu ändern
  • Dem Worker sagen, welche Samples es gibt, damit ein falscher Name ein Fehler ist
  • Dateien über einen Button und per Drag and Drop annehmen

Jeder Klang des Songs ist bisher ausgerechnet: Oszillatoren, Rauschen, Filter. Ein Sampler spielt eine Aufnahme ab, ein Sample, und das kann alles sein: eine Note eines Klaviers, ein gesprochenes Wort, ein Löffel auf einem Topf. Er spielt die Aufnahme für höhere Noten schneller und für tiefere langsamer ab, und so wird aus einer Aufnahme ein Instrument.

Dieser Teil bringt den Ort, an dem die Samples liegen, den Sampler, ein Sample, das immer da ist, und eine Leiste über dem Editor, die deine Dateien annimmt.

Von der Datei zum Puffer

Eine Audiodatei ist verpackt: Eine WAV-Datei hat einen Kopf vor ihren Zahlen, und bei einer MP3-Datei müssen die Zahlen erst ausgerechnet werden. Um einen Klang zu einer genauen Zeit zu starten, muss er ganz als einfache Zahlen im Speicher liegen. Das ist ein AudioBuffer: eine Reihe von Zahlen pro Kanal, zwei Reihen für Stereo. decodeAudioData() des Audio-Kontexts macht aus den Bytes einer Datei einen solchen Puffer. Es kümmert sich um das Format, rechnet den Klang auf die Abtastrate des Kontexts um, also die Zahl seiner Werte pro Sekunde, und antwortet mit einem Promise. Welche Formate es liest, hängt vom Browser ab. Die Datei, mit der dieser Teil geprüft wurde, ist eine WAV-Datei.

Eines daran ist ungewöhnlich: Es leert den ArrayBuffer, den es bekommt. Der Browser übergibt die Bytes dem Dekoder, ohne sie zu kopieren, und was du in der Hand behältst, hat die Länge 0. Die App braucht die Bytes ein zweites Mal, um sie aufzubewahren, also bekommt der Dekoder eine Kopie: data.slice(0).

Die Dateien aufbewahren

Ein Sample, das du hinzugefügt hast, soll beim nächsten Besuch da sein. localStorage speichert nur Text, und nicht viel davon. IndexedDB ist die Datenbank des Browsers: Sie speichert Objekte, auch Binärdaten, viele Megabyte davon, getrennt für jede Website. Drei ihrer Begriffe braucht es hier. Eine Datenbank hat einen Namen und eine Version. Sie enthält Object Stores, Tabellen, in denen Werte unter einem Schlüssel liegen. Und alles, was liest oder schreibt, geschieht in einer Transaktion, die abgeschlossen ist, wenn die Datenbank es niedergeschrieben hat.

Ihre API ist älter als Promises: Jeder Aufruf gibt eine Anfrage zurück, die später onsuccess oder onerror auslöst. Zwei kleine Funktionen packen das ein. Lege src/samples.ts an. Ihre drei Abschnitte folgen aufeinander:

src/samples.ts
import { audio } from './audio.ts';

/** The samples that are ready to play, by name. */
const buffers = new Map<string, AudioBuffer>();

export const sample = (name: string): AudioBuffer | undefined => buffers.get(name);
export const sampleNames = (): string[] => [...buffers.keys()].sort();

// ---------------------------------------------------------------------------
// The files are kept in IndexedDB, the browser's database: unlike localStorage it takes
// binary data, and megabytes of it.

function open(): Promise<IDBDatabase> {
  return new Promise((resolve, reject) => {
    const request = indexedDB.open('loopcode', 1);
    // Runs the first time: the database gets its one table.
    request.onupgradeneeded = () => request.result.createObjectStore('samples');
    request.onsuccess = () => resolve(request.result);
    request.onerror = () => reject(request.error);
  });
}

/** Does one thing with the table, and waits until the database has written it down. */
async function withStore<T>(mode: IDBTransactionMode, action: (store: IDBObjectStore) => IDBRequest<T>): Promise<T> {
  const database = await open();
  return new Promise((resolve, reject) => {
    const transaction = database.transaction('samples', mode);
    const request = action(transaction.objectStore('samples'));
    transaction.oncomplete = () => resolve(request.result);
    transaction.onerror = () => reject(transaction.error);
  });
}

Die Map buffers hält die dekodierten Samples, und sample() und sampleNames() sind das, was der Rest der App davon sieht. open() fragt nach Version 1 der Datenbank loopcode. Gibt es sie noch nicht, läuft zuerst onupgradeneeded, und das ist die einzige Stelle, an der ein Store angelegt werden kann. withStore() beginnt eine Transaktion auf dem Store, tut darin eine Sache und wird erfüllt, wenn die Transaktion abgeschlossen ist, mit dem, was die Anfrage zurückgegeben hat.

Die Datenbank speichert die Dateien so, wie sie gekommen sind, nicht den dekodierten Klang. Dekodierter Klang ist viel größer als die meisten Dateien: Eine Sekunde Stereo bei 48.000 Abtastwerten pro Sekunde braucht 384 Kilobyte.

src/samples.ts
// ---------------------------------------------------------------------------

/** A name for a file: lower case, without its ending, only letters, digits and dashes, and never the built-in bell's. */
function nameOf(file: string): string {
  const name = file
    .replace(/\.[^.]+$/, '')
    .toLowerCase()
    .replace(/[^a-z0-9]+/g, '-')
    .replace(/^-|-$/g, '');
  return name === 'bell' ? 'bell-2' : name || 'sample';
}

/** Takes in an audio file: decodes it, and keeps it for the next visit. Gives back its name. */
export async function addSample(file: File): Promise<string> {
  const data = await file.arrayBuffer();
  const name = nameOf(file.name);
  // Decoding empties the buffer it is given, so it gets a copy.
  buffers.set(name, await audio().decodeAudioData(data.slice(0)));
  await withStore('readwrite', (store) => store.put(data, name));
  return name;
}

export async function removeSample(name: string): Promise<void> {
  buffers.delete(name);
  await withStore('readwrite', (store) => store.delete(name));
}

/** Makes the built-in sample, and decodes the files of earlier visits. */
export async function loadSamples(): Promise<void> {
  buffers.set('bell', await bell());
  const names = await withStore('readonly', (store) => store.getAllKeys());
  const files = await withStore<ArrayBuffer[]>('readonly', (store) => store.getAll());
  for (const [index, name] of names.entries()) {
    try {
      buffers.set(String(name), await audio().decodeAudioData(files[index].slice(0)));
    } catch {
      // A file that can't be decoded any more is left out.
    }
  }
}

nameOf() macht einen Namen, der sich im Code schnell tippen lässt: Aus der Datei Test Tone!.wav wird test-tone. Nur den Namen bell bekommt keine Datei, weil er der Glocke gehört, die die App selbst macht: Aus bell.wav wird bell-2. addSample() dekodiert zuerst. Ist die Datei kein Audio, scheitert decodeAudioData(), und nichts wird gespeichert. Die Bytes werden unter dem Namen gespeichert, also nimmt eine Datei mit dem Namen eines Samples, das schon da ist, dessen Platz ein. loadSamples() läuft, wenn die Seite geöffnet wird. getAllKeys() und getAll() antworten beide in der Reihenfolge der Schlüssel, also gehören ein Name und eine Datei am selben Index zusammen.

Eine Glocke aus dem Nichts

Beim ersten Besuch gibt es keine Dateien, und ein Sampler ohne Sample ist stumm. Also macht die App ein Sample selbst. Ein OfflineAudioContext hat dieselben Knoten wie der Audio-Kontext, spielt aber nichts ab: Er rendert eine vorgegebene Zahl von Abtastwerten in einen Puffer, so schnell der Computer kann, und startRendering() wird mit diesem Puffer erfüllt. Hier ist es ein Kanal, eineinhalb Sekunden lang, mit der Abtastrate des Kontexts der Seite. Zeiten werden ab dem Beginn des Renderns gezählt.

Die Glocke entsteht durch Frequenzmodulation, kurz FM. Teil 14 hat eine langsame Welle mit einer Tonhöhe verbunden, und die Note hat geschwankt. Ist die Welle schnell, hunderte Runden pro Sekunde, und bewegt sie die Frequenz weit, hört das Ohr kein Schwanken mehr, sondern neue Frequenzen neben der Note: eine andere Klangfarbe. Der Oszillator, den man hört, ist der Träger, bei 261,63 Hz, der Note C4. Der Modulator läuft 3,5-mal so schnell und ist über einen Gain-Knoten mit der frequency des Trägers verbunden. Dieser Gain-Knoten sagt, um wie viele Hertz die Frequenz hinauf und hinunter geschoben wird. Weil 3,5 keine ganze Zahl ist, sind viele der neuen Frequenzen keine ganzzahligen Vielfachen der Frequenz der Note, wie im Klang von angeschlagenem Metall. Der Wert des Gain-Knotens beginnt bei 700 und fällt innerhalb von 1,2 Sekunden auf 1: viele zusätzliche Frequenzen beim Anschlag, fast keine im Nachklang.

src/samples.ts
/**
 * A sample that is always there: a bell on the note C4, a second and a half long. It is
 * played once into an offline context, which renders into a buffer instead of the speakers,
 * as fast as the computer can.
 */
function bell(): Promise<AudioBuffer> {
  const rate = audio().sampleRate;
  const offline = new OfflineAudioContext(1, rate * 1.5, rate);

  // One oscillator moves the frequency of the other, fast enough to be heard as a tone
  // color. Far at first, then less and less: the bright strike, and the pure ring after it.
  const carrier = offline.createOscillator();
  carrier.frequency.value = 261.63;
  const modulator = offline.createOscillator();
  modulator.frequency.value = 261.63 * 3.5;
  const amount = offline.createGain();
  amount.gain.setValueAtTime(700, 0);
  amount.gain.exponentialRampToValueAtTime(1, 1.2);
  modulator.connect(amount).connect(carrier.frequency);

  const envelope = offline.createGain();
  envelope.gain.setValueAtTime(0.8, 0);
  envelope.gain.exponentialRampToValueAtTime(0.001, 1.5);
  carrier.connect(envelope).connect(offline.destination);

  carrier.start();
  modulator.start();
  return offline.startRendering();
}

Der zweite Gain-Knoten ist die Hüllkurve, der Verlauf der Lautstärke des ganzen Klangs: von 0.8 hinunter auf 0.001, weil eine exponentielle Rampe 0 nicht erreichen kann (Teil 1).

Der Sampler

Einen Puffer spielt ein Buffer-Source-Knoten ab, der einmal benutzt und dann weggeworfen wird, wie ein Oszillator. Seine playbackRate ist die Geschwindigkeit. Bei doppelter Geschwindigkeit braucht jede Welle der Aufnahme die halbe Zeit, also verdoppelt sich ihre Frequenz: Der Klang ist eine Oktave höher und halb so lang. Eine Oktave hat zwölf Halbtöne, die Schritte von einer Note zur nächsten, also ist ein Halbton ein Faktor von 2 ** (1 / 12), etwa 1,06.

Dafür muss der Sampler wissen, welche Note die Aufnahme ist. Das ist die Option root, eine MIDI-Notennummer wie in Teil 1, bei der jeder Halbton um eins weiterzählt. Ihr Standardwert ist 60, C4, und das ist die Note der Glocke. Eine Note 16 Halbtöne darüber, e5, spielt die Glocke mit etwa 2,5-facher Geschwindigkeit, und sie klingt 0,6 Sekunden lang, nicht 1,5. Lege src/sampler.ts an:

src/sampler.ts
import { audio } from './audio.ts';
import type { NoteEvent } from './notes.ts';
import { sample } from './samples.ts';
import type { Target, Unit } from './unit.ts';

export type SamplerOptions = {
  /** The name of the sample to play. */
  sample: string;
  /** The MIDI note at which the sample sounds as it was recorded. */
  root: number;
  volume: number;
};

/** Plays a recording at the pitch of every note: faster for higher notes, slower for lower ones. */
export class Sampler implements Unit {
  private readonly context = audio();
  readonly output = this.context.createGain();
  readonly targets: Record<string, Target> = {
    volume: { param: this.output.gain, scale: 0.5 },
  };
  private options: SamplerOptions;

  constructor(options: SamplerOptions) {
    this.options = options;
    this.output.gain.value = options.volume;
  }

  update(options: SamplerOptions) {
    this.options = options;
    this.output.gain.setTargetAtTime(options.volume, this.context.currentTime, 0.02);
  }

  play(event: NoteEvent) {
    const buffer = sample(this.options.sample);
    if (!buffer) return;
    const source = this.context.createBufferSource();
    source.buffer = buffer;
    // Twice the speed is an octave up. A step that is no note plays the sample as it is.
    const semitones = (event.note ?? this.options.root) - this.options.root;
    source.playbackRate.value = 2 ** (semitones / 12);

    const level = this.context.createGain();
    level.gain.value = event.velocity * (event.accent ? 1 : 0.7);
    source.connect(level).connect(this.output);
    source.start(event.time);
  }

  /** Fades out, and unplugs once nothing is heard any more. */
  dispose() {
    this.output.gain.setTargetAtTime(0, this.context.currentTime, 0.02);
    window.setTimeout(() => this.output.disconnect(), 200);
  }
}

Drei Dinge sind anders als bei den Synths. Ein Schritt, der keine Note ist, etwa x, spielt das Sample so ab, wie es aufgenommen wurde, und das ist es, was ein Drum-Schlag oder ein Wort braucht. Das Sample spielt immer bis zu seinem Ende, egal wie kurz die Note ist, also können Samples übereinander liegen. Und der Puffer wird bei jeder Note unter seinem Namen nachgeschlagen: Wird eine Datei durch eine andere mit demselben Namen ersetzt, spielt die nächste Note die neue, und ist das Sample weg, wird nichts gespielt.

Ergänze den Typ in src/schema.ts in UNITS, nach polySynth:

src/schema.ts
sampler: {
  doc: 'Plays a recording at the pitch of every note. Add your own files in the bar above the code.',
  takes: 'notes',
  gives: 'audio',
  options: {
    sample: { doc: 'The name of the sample to play.', default: 'bell' },
    root: { doc: 'The MIDI note at which the sample sounds as it was recorded: 60 is c4.', default: 60, min: 0, max: 127 },
    volume,
  },
  targets: { volume: TARGETS.volume },
},

Importiere in src/engine.ts Sampler und den Typ SamplerOptions aus ./sampler.ts, und ergänze eine Zeile in FACTORIES, nach polySynth:

src/engine.ts
sampler: (options) => new Sampler(options as SamplerOptions),

Der Worker sieht die Samples nicht

Ein Sampler mit dem Namen eines Samples, das es nicht gibt, wäre stumm, und Stille ist eine schlechte Fehlermeldung. Der Fehler soll dort abgefangen werden, wo die anderen abgefangen werden: wenn der Code ausgeführt wird, mit einer Meldung an seiner Zeile (Teil 11).

Aber seit Teil 11 läuft der Code in einem Worker, und ein Worker hat seinen eigenen Speicher. Würde das Skript dort src/samples.ts importieren, bekäme es eine zweite, leere Map, und füllen könnte es sie auch nicht: Ein Worker hat keinen Audio-Kontext, mit dem er dekodieren könnte. Also sagt die Seite dem Worker bei jedem Durchlauf, welche Namen es gibt. Namen sind Text und reisen ohne Weiteres in einer Nachricht. Ersetze in src/script.ts den Anfang von runScript(), von seinem Kommentar bis zum Ende von create():

src/script.ts
/**
 * Runs the code and gives back the patch it describes. Never throws. `samples` are the names
 * of the samples that are loaded: the code runs where it can't look them up itself.
 */
export function runScript(code: string, samples: string[]): Outcome {
  const patch: Patch = { bpm: 120, units: [], cables: [] };
  const counts: Record<string, number> = {};
  const logs: string[] = [];

  /** Adds a unit to the patch. */
  function create(type: string, given: unknown): Handle {
    const spec = UNITS[type];
    const options = readOptions(type, spec, given);
    if (type === 'sampler' && !samples.includes(String(options.sample))) {
      const name = String(options.sample);
      throw new ScriptError(`There is no sample called "${name}", only ${samples.join(', ')}.${didYouMean(name, samples)}`);
    }
    counts[type] = (counts[type] ?? 0) + 1;
    const id = `${type}${counts[type]}`;
    patch.units.push({ id, type, options });
    return new Handle(id, type, spec, patch);
  }

Die Meldung zählt auf, was es gibt, und didYouMean() aus Teil 11 hängt den ähnlichsten Namen an. Ist nur die Glocke geladen, antwortet sampler({ sample: 'test-tone' }) mit: There is no sample called "test-tone", only bell.

Die Namen reisen in der Anfrage. Ersetze src/worker.ts durch:

src/worker.ts
import { runScript, type Outcome } from './script.ts';

export interface Request {
  id: number;
  code: string;
  samples: string[];
}

export type Reply = Outcome & { id: number };

// A worker has no page: all it does is run the code it is sent, and send back what came of it.
self.addEventListener('message', (event: MessageEvent<Request>) => {
  const { id, code, samples } = event.data;
  const reply: Reply = { ...runScript(code, samples), id };
  self.postMessage(reply);
});

Ersetze in src/runner.ts run(). Es nimmt die Namen entgegen und legt sie in die Anfrage:

src/runner.ts
/** Runs the code away from the page, in a worker. Always answers, even if the code never ends. */
export function run(code: string, samples: string[]): Promise<Outcome> {
  lastId += 1;
  const id = lastId;
  return new Promise((resolve) => {
    const timer = window.setTimeout(() => {
      // The only way to stop code that doesn't end: end the worker it runs in. The next
      // run starts a new one.
      worker?.terminate();
      worker = undefined;
      const seconds = TIMEOUT / 1000;
      for (const answer of waiting.values()) {
        answer({
          ok: false,
          message: `The code ran for more than ${seconds} seconds and was stopped. Is there a loop that never ends?`,
          line: undefined,
          logs: [],
        });
      }
    }, TIMEOUT);

    waiting.set(id, (outcome) => {
      window.clearTimeout(timer);
      waiting.delete(id);
      resolve(outcome);
    });
    const request: Request = { id, code, samples };
    getWorker().postMessage(request);
  });
}

Importiere in src/main.ts addSample, loadSamples, removeSample und sampleNames aus ./samples.ts, und übergib die Namen in der ersten Zeile von run(). Der Durchlauf wartet auf loaded, ein Promise, das am Ende dieser Datei entsteht: Die Samples früherer Besuche müssen erst dekodiert sein, sonst fände ein schneller Klick auf Play sie nicht:

src/main.ts
const outcome = await loaded.then(() => runCode(editor.state.doc.toString(), sampleNames()));

Die Leiste der Samples

Die Namen müssen getippt werden, also zeigt die Seite sie an. Ergänze in index.html eine Leiste zwischen dem Header und dem Editor:

index.html
<div class="samples">
  <span>samples</span>
  <span id="samples" class="chips"></span>
  <label class="add">+ add<input id="files" type="file" accept="audio/*" multiple hidden /></label>
</div>

Das Dateifeld ist versteckt und sitzt in einem Label. Ein Klick auf ein Label zählt als Klick auf sein Eingabefeld, also ist das Label der Button, und es lässt sich gestalten wie die Chips daneben. accept bittet den Dialog, Audiodateien zu zeigen, und multiple erlaubt mehrere auf einmal. Ergänze in src/style.css nach der Regel für .tempo:

src/style.css
.samples {
  display: flex;
  flex-wrap: wrap;
  align-items: center;
  gap: 8px;
  padding: 4px 12px;
  background: var(--night);
  border-bottom: 2px solid var(--edge);
  color: var(--muted);
  font-size: 12px;
}

.chips {
  display: contents;
}

.chip,
.add {
  padding: 1px 8px;
  border: 1px solid var(--edge);
  border-radius: 10px;
  color: var(--text);
}

.chip button {
  margin-left: 6px;
  padding: 0;
  border: none;
  background: none;
  color: var(--muted);
}

.chip button:hover {
  background: none;
  color: var(--orange);
}

.add {
  border-style: dashed;
  cursor: pointer;
}

.add:hover {
  border-color: var(--lilac);
}

display: contents nimmt dem Span, der die Chips hält, seine Box, sodass die Chips selbst in der Leiste stehen, mit demselben Abstand wie alles andere darin.

Ergänze in src/main.ts die Liste der Chips nach dem Listener des Run-Buttons:

src/main.ts
// ---------------------------------------------------------------------------
// Samples: the bar above the code lists them. Files are added with the button, or by
// dropping them anywhere on the page.

const chips = document.querySelector<HTMLElement>('#samples')!;

function showSamples() {
  chips.replaceChildren(
    ...sampleNames().map((name) => {
      const chip = document.createElement('span');
      chip.className = 'chip';
      chip.textContent = name;
      // The bell is made by the app and can't be removed.
      if (name !== 'bell') {
        const remove = document.createElement('button');
        remove.textContent = '×';
        remove.title = `Remove ${name}`;
        remove.addEventListener('click', async () => {
          await removeSample(name);
          showSamples();
        });
        chip.append(remove);
      }
      return chip;
    }),
  );
}

Jedes Sample bekommt einen Chip mit seinem Namen und einem ×, das es entfernt. Nur die Glocke hat kein ×: Die App macht sie bei jedem Besuch neu. Darunter kommen die Dateien:

src/main.ts
async function addFiles(files: Iterable<File>) {
  const lines: string[] = [];
  let failed = false;
  for (const file of files) {
    try {
      const name = await addSample(file);
      lines.push(`Added the sample "${name}". Play it with sampler({ sample: '${name}' })`);
    } catch {
      lines.push(`${file.name} is not an audio file this browser can read`);
      failed = true;
    }
  }
  status.textContent = lines.join('\n');
  status.classList.toggle('error', failed);
  showSamples();
}

const files = document.querySelector<HTMLInputElement>('#files')!;
files.addEventListener('change', async () => {
  await addFiles(files.files ?? []);
  files.value = '';
});

addFiles() sagt in der Zeile unter dem Editor, was aus jeder Datei geworden ist: der Name für den Code, oder dass die Datei nicht gelesen werden konnte. Danach wird das Dateifeld geleert. Sonst würde es nicht als Änderung zählen, dieselbe Datei noch einmal zu wählen.

Dateien auf die Seite ziehen

Eine Datei aus einem Ordner auf die Seite zu ziehen, geht schneller als ein Dialog. Ein Browser erlaubt das Ablegen nur dort, wo dragover mit preventDefault() beantwortet wurde. Der Listener tut das nur für Dateien, sodass das Ziehen von Text im Editor funktioniert wie bisher.

Der Editor füllt den größten Teil der Seite, und er hat einen eigenen Drop-Handler, der eine abgelegte Datei als Text für den Code behandelt. Ein Event reist vom Fenster hinunter zu dem Element, auf dem es passiert ist, und dann wieder hinauf. Ein Listener mit capture: true wird auf dem Weg hinunter aufgerufen. Am Fenster ist das vor allen anderen, und stopPropagation() beendet die Reise dort. Ergänze unter den Dateien:

src/main.ts
// Dropped files are caught before the editor sees them: it would put their text into the code.
window.addEventListener('dragover', (event) => {
  if (!event.dataTransfer?.types.includes('Files')) return;
  event.preventDefault();
  document.body.classList.add('dropping');
});
window.addEventListener('dragleave', () => document.body.classList.remove('dropping'));
window.addEventListener(
  'drop',
  (event) => {
    document.body.classList.remove('dropping');
    if (!event.dataTransfer?.files.length) return;
    event.preventDefault();
    event.stopPropagation();
    void addFiles(event.dataTransfer.files);
  },
  { capture: true },
);

const loaded = loadSamples().then(showSamples);

Die Klasse dropping am Body zeigt, dass die Seite die Datei annehmen wird. dragleave wird auch ausgelöst, wenn der Zeiger von einem Element der Seite zum nächsten wandert, und das nächste dragover setzt die Klasse gleich wieder. Die letzte Zeile lädt die Samples, wenn die Seite geöffnet wird, und füllt dann die Leiste. Ihr Promise ist das loaded, auf das run() wartet. Der Rahmen kommt in src/style.css, nach der Regel für button:hover:

src/style.css
body.dropping {
  outline: 3px dashed var(--orange);
  outline-offset: -3px;
}

Eine Glocke im Song

Ersetze in src/song.ts die drei Zeilen der Keys am Ende des Songs durch:

src/song.ts
const keys = polySynth({ release: 0.6, cutoff: 1800 })
pattern('<[a3,c4,e4] [f3,a3,c4] [c3,e3,g3] [g3,b3,d4]>').to(keys)
const echo = delay({ time: 0.75, feedback: 0.5 })
keys.to(echo).to(reverb({ size: 3 })).to(out)

const bell = sampler({ sample: 'bell', volume: 0.3 })
pattern('~ e5 ~ [a5 g5]?').to(bell)
bell.to(echo)

Das Delay hat jetzt einen Namen, echo, weil zwei Bausteine hineingehen: die Akkorde und die Glocke. Ein Eingang addiert, was in ihm steckt, also teilen sich beide die Echos und den Raum dahinter. Die Glocke spielt e5 auf dem zweiten Schlag jedes Takts und zwei schnelle Noten auf dem vierten, von denen jede in der Hälfte der Fälle ausgelassen wird: das ? aus Teil 6.

Probier es aus

Drück auf Play. Die Glocke klingt auf dem zweiten Schlag, mit denselben Echos wie die Akkorde. Um zu hören, was die Abspielgeschwindigkeit tut, ersetze den Song durch die Glocke allein:

javascript
const bell = sampler()
pattern('c4 c5 c3 x').to(bell)
bell.to(out)

c4 ist die Glocke, wie sie gerendert wurde. c5 ist eine Oktave höher und halb so lang. c3 ist eine Oktave tiefer und doppelt so lang, drei Sekunden, also klingt sie noch, wenn der nächste Takt beginnt. x ist keine Note und spielt die Glocke wieder so, wie sie gerendert wurde. Bring dann einen eigenen Sound mit:

  • Klick auf + add und wähle eine Audiodatei, oder zieh eine auf die Seite. Ein Chip mit ihrem Namen erscheint, in Kleinbuchstaben und mit Bindestrichen für alles, was kein Buchstabe und keine Ziffer ist, und die Zeile unter dem Editor sagt, wie du ihn benutzt.

  • Schreib diesen Namen in den Code, wie in sampler({ sample: 'test-tone' }), und führe ihn aus. Ist die Aufnahme eine einzelne Note, setz root auf diese Note, 57 für ein A3, und die Notennamen des Patterns erklingen in der richtigen Tonhöhe. Ist sie ein Geräusch oder ein Wort, schreib x ins Pattern.

  • Lade die Seite neu. Der Chip ist noch da.

  • Schreib den Namen falsch und führe den Code aus. Die Meldung zählt die Samples auf, die es gibt, und die Musik spielt weiter.

  • Klick auf das × am Chip. Das Sample ist aus der Leiste und aus der Datenbank verschwunden, und der nächste Durchlauf des Codes meldet den fehlenden Namen.

Der Song mit einer Glocke. Drück Play, füge mit „+ add“ über dem Code eine Audiodatei hinzu, schreib ihren Namen in sampler({ sample: … }) und drück Strg+Enter (Cmd+Enter auf einem Mac).
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.