@hraness/dawg 0.2.0 → 0.4.0

package/src/audio/kits.ts

@@ -0,0 +1,200 @@
+/**
+ * Drum kits: the synthesized kits from `core/kits.ts` rendered sample by
+ * sample, and the one catalog `/kit`, `/menu` and the agent list.
+ *
+ * The renderer calls `kitDrumSample` only for a track with `kit` set, so the
+ * default voices in `wav.ts` stay byte-identical. Everything here is plain
+ * arithmetic on the seeded noise `wav.ts` passes in, so a kit renders the
+ * same buffer on every run.
+ */
+import type { DrumVoice } from "../../core/drums.ts";
+import {
+  SYNTH_KITS,
+  type DrumBodyParams,
+  type HatParams,
+  type SynthKit,
+  synthKit,
+} from "../../core/kits.ts";
+import type { TrackScore } from "../../core/score.ts";
+import { DEFAULT_KITS } from "./packs.ts";
+
+/** Per-hit oscillator and filter state. */
+export type KitVoiceState = {
+  phase: number;
+  band: number;
+  dark: number;
+  metalPrevious: number;
+  holdLeft: number;
+  held: number;
+};
+
+export function newKitVoiceState(): KitVoiceState {
+  return {
+    phase: 0,
+    band: 0,
+    dark: 0,
+    metalPrevious: 0,
+    holdLeft: 0,
+    held: 0,
+  };
+}
+
+/** 808 hi-hat oscillator frequencies (six detuned squares). */
+const METAL_HZ = [205.3, 304.4, 369.6, 522.7, 540, 800] as const;
+
+function body(
+  params: DrumBodyParams,
+  t: number,
+  noise: number,
+  state: KitVoiceState,
+  sampleRate: number,
+): number {
+  const frequency =
+    params.base + params.sweep * Math.exp(-t * params.sweepRate);
+  state.phase += frequency / sampleRate;
+  return (
+    Math.sin(2 * Math.PI * state.phase) *
+      Math.exp(-t * params.decay) *
+      params.level +
+    noise * params.click * Math.exp(-t * params.clickDecay)
+  );
+}
+
+function hat(
+  params: HatParams,
+  t: number,
+  noise: number,
+  bright: number,
+  state: KitVoiceState,
+): number {
+  state.dark += 0.3 * (noise - state.dark);
+  const noisy = params.tone * bright + (1 - params.tone) * state.dark * 0.8;
+  let source = noisy;
+  if (params.metal > 0) {
+    let square = 0;
+    for (const hz of METAL_HZ) square += (t * hz) % 1 < 0.5 ? 1 : -1;
+    // First difference: keep the metallic top end, drop the low beating.
+    const metal = (square / METAL_HZ.length - state.metalPrevious) * 1.6;
+    state.metalPrevious = square / METAL_HZ.length;
+    source = params.metal * metal + (1 - params.metal) * noisy;
+  }
+  return source * params.level * Math.exp(-t * params.decay);
+}
+
+/** One sample of `voice` in `kit` at `t` seconds after the hit. */
+export function kitDrumSample(
+  kit: SynthKit,
+  voice: DrumVoice,
+  t: number,
+  noise: number,
+  bright: number,
+  state: KitVoiceState,
+  sampleRate: number,
+): number {
+  let sample: number;
+  if (voice === "kick") sample = body(kit.kick, t, noise, state, sampleRate);
+  else if (voice === "tom") sample = body(kit.tom, t, noise, state, sampleRate);
+  else if (voice === "snare") {
+    const p = kit.snare;
+    state.phase += p.tone / sampleRate;
+    const wires = p.snap * bright + (1 - p.snap) * noise;
+    sample =
+      Math.sin(2 * Math.PI * state.phase) *
+        p.toneLevel *
+        Math.exp(-t * p.toneDecay) +
+      wires * p.noise * Math.exp(-t * p.noiseDecay);
+  } else if (voice === "clap") {
+    const p = kit.clap;
+    state.band += p.band * (bright - state.band);
+    const span = p.gap * 3;
+    const burst = t < span ? (Math.floor(t / p.gap) % 2 === 0 ? 1 : 0.35) : 0;
+    sample =
+      state.band *
+      p.level *
+      (burst + 0.8 * Math.exp(-(t - span) * p.tail) * +(t >= span));
+  } else if (voice === "hat") sample = hat(kit.hat, t, noise, bright, state);
+  else if (voice === "openhat")
+    sample = hat(kit.openhat, t, noise, bright, state);
+  else {
+    const p = kit.rim;
+    sample =
+      (Math.sin(2 * Math.PI * p.high * t) * 0.6 +
+        Math.sin(2 * Math.PI * p.low * t) * 0.4) *
+      Math.exp(-t * p.decay) *
+      p.level;
+  }
+  if (kit.drive > 0) {
+    const amount = 1 + kit.drive * 4;
+    sample = Math.tanh(sample * amount) / Math.tanh(amount);
+  }
+  if (kit.bits > 0) {
+    const steps = 2 ** (kit.bits - 1);
+    sample = Math.round(sample * steps) / steps;
+  }
+  if (kit.hold > 1) {
+    if (state.holdLeft <= 0) {
+      state.held = sample;
+      state.holdLeft = kit.hold;
+    }
+    state.holdLeft -= 1;
+    sample = state.held;
+  }
+  return sample * kit.gain;
+}
+
+/** Longest synth-kit one-shot in the score; 0 without kits (so renders without kits are unchanged). */
+export function kitTailSeconds(score: TrackScore): number {
+  let seconds = 0;
+  for (const track of score.tracks)
+    seconds = Math.max(seconds, synthKit(track.kit)?.seconds ?? 0);
+  return seconds;
+}
+
+// ── catalog ────────────────────────────────────────────────────────────
+
+/**
+ * One entry of the kit catalog. `synth` kits render offline from the
+ * parameters in `core/kits.ts`; `sample` kits are pack banks fetched on
+ * first use (`src/audio/packs.ts`). New kinds (a user's own folder of
+ * samples, more packs) slot in here without touching the pickers.
+ */
+export type KitEntry = Readonly<{
+  name: string;
+  kind: "synth" | "sample";
+  label: string;
+  detail: string;
+  /** The prompt command that puts this kit on the focused track. */
+  command: string;
+}>;
+
+/** The default synth voices, listed first. */
+export const DEFAULT_SYNTH_KIT = "default";
+
+export function kitCatalog(): readonly KitEntry[] {
+  const synth: KitEntry[] = [
+    {
+      name: DEFAULT_SYNTH_KIT,
+      kind: "synth",
+      label: "Default (synth)",
+      detail: "the built-in voices",
+      command: `/kit ${DEFAULT_SYNTH_KIT}`,
+    },
+    ...SYNTH_KITS.map((entry): KitEntry => ({
+      name: entry.name,
+      kind: "synth",
+      label: entry.label,
+      detail: entry.description,
+      command: `/kit ${entry.name}`,
+    })),
+  ];
+  const sample = Object.entries(DEFAULT_KITS).map(
+    ([name, entry]): KitEntry => ({
+      name,
+      kind: "sample",
+      label: `${name}  ${entry.bank || entry.pack}`,
+      detail: `${entry.pack} samples (fetched once)`,
+      command: `/kit ${name}`,
+    }),
+  );
+  return Object.freeze([...synth, ...sample]);
+}

package/src/audio/live.ts

@@ -0,0 +1,152 @@
+/**
+ * Live voices for play mode: one note of one track, rendered through the
+ * same offline renderer the loop uses (`renderScorePcm`), so a key sounds
+ * exactly like the note it records as: the track's instrument voice (synth,
+ * drum kit or sampler), filter, pan, delay and reverb. Nothing is forked;
+ * this module only builds a one-note score and caches the result.
+ *
+ * The offline renderer is untouched, so loop renders and exports stay
+ * byte-identical. Live audio never reaches a render or an export: the engine
+ * mixes it into the stream only.
+ */
+import {
+  SCORE_LIMITS,
+  TrackScore,
+  isSamplerInstrument,
+  type Track,
+} from "../../core/score.ts";
+import { sampleKey, type SampleBank } from "./samples.ts";
+import { RENDER_CHANNELS, renderScorePcm } from "./wav.ts";
+
+/** A rendered live note: interleaved stereo 16-bit PCM. */
+export type LiveNotePcm = Readonly<{ pcm: Int16Array; frames: number }>;
+
+export type LiveNoteRequest = Readonly<{
+  score: TrackScore;
+  trackId: string;
+  pitch: number;
+  /** 0..1, as score notes store it. */
+  velocity: number;
+  /** How long the key is held. */
+  seconds: number;
+  /** Decoded sampler voices; without it sampler tracks are silent. */
+  samples?: SampleBank;
+}>;
+
+/** Longest a single live note is rendered for (a held sustain pedal). */
+export const MAX_LIVE_NOTE_SECONDS = 8;
+const CACHE_ENTRIES = 96;
+
+/**
+ * Renders and caches live notes. Repeated keys hit the cache, so the key
+ * handler only pays for a render the first time a pitch/length is played.
+ */
+export class LiveSynth {
+  private readonly cache = new Map<string, LiveNotePcm>();
+
+  public constructor(private readonly sampleRate: number) {}
+
+  public get rate(): number {
+    return this.sampleRate;
+  }
+
+  public get cached(): number {
+    return this.cache.size;
+  }
+
+  public render(request: LiveNoteRequest): LiveNotePcm | undefined {
+    const track = request.score.tracks.find(
+      (candidate) => candidate.id === request.trackId,
+    );
+    if (!track) return undefined;
+    const { score } = request;
+    const ticksPerSecond = (score.ticksPerBeat * score.tempoBpm) / 60;
+    const seconds = Math.max(
+      0.01,
+      Math.min(MAX_LIVE_NOTE_SECONDS, request.seconds),
+    );
+    const durationTicks = Math.max(
+      1,
+      Math.min(SCORE_LIMITS.maxTick, Math.round(seconds * ticksPerSecond)),
+    );
+    const velocity = Math.max(0, Math.min(1, request.velocity));
+    const pitch = Math.max(0, Math.min(127, Math.round(request.pitch)));
+    const key = JSON.stringify([
+      liveTrack(track),
+      pitch,
+      velocity,
+      durationTicks,
+      score.tempoBpm,
+      score.ticksPerBeat,
+      this.sampleRate,
+      samplerDigest(track, request.samples),
+    ]);
+    const hit = this.cache.get(key);
+    if (hit) {
+      // Refresh LRU order.
+      this.cache.delete(key);
+      this.cache.set(key, hit);
+      return hit;
+    }
+    const beats = durationTicks / score.ticksPerBeat;
+    const bars = Math.max(
+      1,
+      Math.min(SCORE_LIMITS.maxBars, Math.ceil(beats / score.beatsPerBar)),
+    );
+    const single = new TrackScore({
+      tempoBpm: score.tempoBpm,
+      beatsPerBar: score.beatsPerBar,
+      bars,
+      ticksPerBeat: score.ticksPerBeat,
+      tracks: [liveTrack(track)],
+      notes: [
+        {
+          id: "live",
+          trackId: track.id,
+          startTick: 0,
+          durationTicks,
+          pitch,
+          velocity,
+        },
+      ],
+    });
+    const audio = renderScorePcm(single, {
+      sampleRate: this.sampleRate,
+      maxSeconds: MAX_LIVE_NOTE_SECONDS + 4,
+      ...(request.samples ? { samples: request.samples } : {}),
+    });
+    const frames = audibleFrames(audio.pcm);
+    const rendered: LiveNotePcm = {
+      pcm: audio.pcm.subarray(0, frames * RENDER_CHANNELS),
+      frames,
+    };
+    this.cache.set(key, rendered);
+    while (this.cache.size > CACHE_ENTRIES) {
+      const oldest = this.cache.keys().next().value;
+      if (oldest === undefined) break;
+      this.cache.delete(oldest);
+    }
+    return rendered;
+  }
+}
+
+/** The track as it sounds live: audible regardless of mute and solo. */
+function liveTrack(track: Track): Track {
+  const { solo: _solo, ...rest } = track;
+  return { ...rest, muted: false };
+}
+
+function samplerDigest(track: Track, bank: SampleBank | undefined): string[] {
+  if (!isSamplerInstrument(track.instrument) || !track.sampler || !bank)
+    return [];
+  return Object.keys(track.sampler.voices)
+    .sort()
+    .map((voice) => bank.voices.get(sampleKey(track.id, voice))?.sha256 ?? "-");
+}
+
+/** Frames up to the last non-silent sample, so mixing skips the dead tail. */
+function audibleFrames(pcm: Int16Array): number {
+  let last = pcm.length - 1;
+  while (last >= 0 && pcm[last] === 0) last -= 1;
+  return Math.ceil((last + 1) / RENDER_CHANNELS);
+}