@hraness/dawg 0.4.0 → 0.5.0

package/src/audio/clock.ts

@@ -1,7 +1,40 @@
+import { loopTicksOf, timeMapFor, type TimeScore } from "../../core/tempo.ts";
+
+/**
+ * Beats and seconds through a song's tempo map, one loop at a time: the
+ * transport runs in score beats, and the map says how long each loop pass
+ * takes. Absent, the clock keeps its constant-tempo arithmetic.
+ */
+export type TransportMap = Readonly<{
+  loopBeats: number;
+  loopSeconds: number;
+  /** Seconds into a loop pass at `beat` (0..loopBeats). */
+  seconds(beat: number): number;
+  /** Beat inside a loop pass at `seconds` (0..loopSeconds). */
+  beat(seconds: number): number;
+}>;
+
+/** The transport map for a score, or undefined at a constant tempo. */
+export function transportMapFor(score: TimeScore): TransportMap | undefined {
+  const map = timeMapFor(score);
+  if (!map) return undefined;
+  const tpb = score.ticksPerBeat;
+  const loopBeats = loopTicksOf(score) / tpb;
+  const loopSeconds = map.seconds(loopTicksOf(score));
+  if (!(loopBeats > 0) || !(loopSeconds > 0)) return undefined;
+  return Object.freeze({
+    loopBeats,
+    loopSeconds,
+    seconds: (beat: number) => map.seconds(beat * tpb),
+    beat: (seconds: number) => map.tick(seconds) / tpb,
+  });
+}
+
 export class TransportClock {
   private startedAtMs: number | undefined;
   private pausedBeat = 0;
   private bpm: number;
+  private map: TransportMap | undefined;
 
   constructor(bpm = 120) {
     this.bpm = bpm;
@@ -24,6 +57,7 @@ export class TransportClock {
 
   beatAt(nowMs = performance.now()): number {
     if (this.startedAtMs === undefined) return this.pausedBeat;
+    if (this.map) return Math.max(0, this.msToBeat(nowMs - this.startedAtMs));
     return Math.max(0, (nowMs - this.startedAtMs) / this.beatToMs(1));
   }
 
@@ -40,6 +74,25 @@ export class TransportClock {
     else this.pausedBeat = beat;
   }
 
+  /**
+   * Follow a song's tempo map (`transportMapFor`), keeping the current
+   * beat; undefined returns to the constant `bpm`.
+   */
+  setTimeMap(map: TransportMap | undefined, nowMs = performance.now()): void {
+    if (map === this.map) return;
+    const beat = this.beatAt(nowMs);
+    this.map = map;
+    if (this.startedAtMs !== undefined)
+      this.startedAtMs = nowMs - this.beatToMs(beat);
+    else this.pausedBeat = beat;
+  }
+
+  /** Follow a score's start tempo and tempo map. */
+  follow(score: TimeScore, nowMs = performance.now()): void {
+    this.setTempo(score.tempoBpm, nowMs);
+    this.setTimeMap(transportMapFor(score), nowMs);
+  }
+
   /** Converge to a timestamped transport event from another TUI process. */
   sync(
     beat: number,
@@ -50,10 +103,10 @@ export class TransportClock {
   ): void {
     if (!Number.isFinite(beat) || beat < 0) return;
     if (!Number.isFinite(eventAtMs) || !Number.isFinite(nowWallMs)) return;
-    const elapsed = playing
-      ? Math.max(0, nowWallMs - eventAtMs) / this.beatToMs(1)
-      : 0;
-    const currentBeat = beat + elapsed;
+    const elapsedMs = playing ? Math.max(0, nowWallMs - eventAtMs) : 0;
+    const currentBeat = this.map
+      ? this.msToBeat(this.beatToMs(beat) + elapsedMs)
+      : beat + elapsedMs / this.beatToMs(1);
     if (playing) {
       this.startedAtMs = nowMonotonicMs - this.beatToMs(currentBeat);
     } else {
@@ -63,6 +116,19 @@ export class TransportClock {
   }
 
   private beatToMs(beats: number): number {
-    return (beats * 60_000) / this.bpm;
+    const map = this.map;
+    if (!map) return (beats * 60_000) / this.bpm;
+    const loops = Math.floor(beats / map.loopBeats);
+    const inner = beats - loops * map.loopBeats;
+    return (loops * map.loopSeconds + map.seconds(inner)) * 1000;
+  }
+
+  private msToBeat(ms: number): number {
+    const map = this.map;
+    if (!map) return ms / this.beatToMs(1);
+    const seconds = ms / 1000;
+    const loops = Math.floor(seconds / map.loopSeconds);
+    const inner = seconds - loops * map.loopSeconds;
+    return loops * map.loopBeats + map.beat(inner);
   }
 }

package/src/audio/effects/bus.ts

@@ -17,6 +17,7 @@ import type { Track } from "../../../core/score.ts";
 import {
   CONTROL_SAMPLES,
   interpolateAutomation,
+  tickAtSample,
   type EffectContext,
 } from "./common.ts";
 import { applyDelay, applyReverb } from "./space.ts";
@@ -58,13 +59,13 @@ function send(
   stemR: Float64Array,
   base: number,
   lane: readonly Readonly<{ tick: number; value: number }>[],
-  samplesPerTick: number,
+  context: Pick<EffectContext, "samplesPerTick" | "warp">,
 ): void {
   if (base <= 0 && lane.length === 0) return;
   let level = base;
   for (let index = 0; index < outL.length; index += 1) {
     if (lane.length > 0 && index % CONTROL_SAMPLES === 0)
-      level = interpolateAutomation(lane, index / samplesPerTick, base);
+      level = interpolateAutomation(lane, tickAtSample(context, index), base);
     outL[index]! += stemL[index]! * level;
     outR[index]! += stemR[index]! * level;
   }
@@ -89,7 +90,7 @@ export function sendToBus(
       stemR,
       track.delay.mix,
       track.delayMixAutomation ?? [],
-      context.samplesPerTick,
+      context,
     );
   }
   if (track.reverb) {
@@ -101,7 +102,7 @@ export function sendToBus(
       stemR,
       track.reverb.mix,
       track.fxAutomation?.["reverb-mix"] ?? [],
-      context.samplesPerTick,
+      context,
     );
   }
 }

package/src/audio/effects/chain.ts

@@ -21,7 +21,15 @@ import {
 import { applyChorus, applyLeslie, applyPhaser } from "./modulation.ts";
 import { applyDelay, applyReverb } from "./space.ts";
 
-export { delayTailFor, reverbImpulse, reverbTailFor } from "./space.ts";
+export {
+  addReverbWet,
+  delayTailFor,
+  reverbActive,
+  reverbImpulse,
+  reverbTailFor,
+  reverbWet,
+  type ReverbWet,
+} from "./space.ts";
 export { interpolateAutomation, type EffectContext } from "./common.ts";
 
 type MonoStage = (
@@ -77,6 +85,7 @@ export function applyMonoChain(
 /**
  * Stereo stages, in chain order, after pan. A track on a shared orbit bus
  * (`sends: false`) skips delay and reverb: the bus applies them to the sum.
+ * `reverb: false` stops before the reverb (the stem cache runs it apart).
  */
 export function applyStereoChain(
   left: Float64Array,
@@ -84,12 +93,13 @@ export function applyStereoChain(
   track: Track,
   context: EffectContext,
   sends = true,
+  reverb = sends,
 ): void {
   for (const stage of FX_CHAIN.slice(PAN_INDEX + 1)) {
     if (stage === "delay") {
       if (sends) applyDelay(left, right, track, context);
     } else if (stage === "reverb") {
-      if (sends) applyReverb(left, right, track, context);
+      if (reverb) applyReverb(left, right, track, context);
     } else {
       const values = track.fx?.[stage as FxName];
       const apply = STEREO[stage as FxName];

package/src/audio/effects/common.ts

@@ -12,6 +12,7 @@
 import type { AutomationPoint, Track } from "../../../core/score.ts";
 import type { FxLane, FxValues } from "../../../core/fx.ts";
 import type { DecodedSample } from "../samples.ts";
+import type { SampleWarp } from "../warp.ts";
 
 /** Effect parameters are refreshed at this sample interval. */
 export const CONTROL_SAMPLES = 32;
@@ -22,8 +23,34 @@ export type EffectContext = Readonly<{
   tempoBpm: number;
   /** Decoded `reverb.ir` samples by track id (built-in impulses need none). */
   irs?: ReadonlyMap<string, DecodedSample>;
+  /** The song's tempo map in samples; absent: constant tempo. */
+  warp?: SampleWarp;
 }>;
 
+/** Score tick at sample `index`, through the tempo map when there is one. */
+export function tickAtSample(
+  context: Pick<EffectContext, "samplesPerTick" | "warp">,
+  index: number,
+): number {
+  return context.warp
+    ? context.warp.tick(index)
+    : index / context.samplesPerTick;
+}
+
+/**
+ * Tempo at sample `index` for tempo-synced LFOs and delays: through the
+ * tempo map when there is one (ramps, steps and fermata holds included),
+ * else the song's constant tempo.
+ */
+export function tempoAtSample(
+  context: Pick<EffectContext, "tempoBpm" | "warp">,
+  index: number,
+): number {
+  return context.warp
+    ? context.warp.bpm(context.warp.tick(index))
+    : context.tempoBpm;
+}
+
 /** Resolve a piecewise-linear automation lane, holding the static value before its first point. */
 export function interpolateAutomation(
   points: readonly AutomationPoint[],
@@ -58,6 +85,7 @@ export class Param {
     readonly fallback: number,
     points: readonly AutomationPoint[] | undefined,
     private readonly samplesPerTick: number,
+    private readonly warp?: SampleWarp,
   ) {
     this.points = points ?? [];
     this.automated = this.points.length > 0;
@@ -67,7 +95,7 @@ export class Param {
     return this.automated
       ? interpolateAutomation(
           this.points,
-          index / this.samplesPerTick,
+          this.warp ? this.warp.tick(index) : index / this.samplesPerTick,
           this.fallback,
         )
       : this.fallback;
@@ -93,6 +121,7 @@ export function fxReader(
         values[name] as number,
         track.fxAutomation?.[`${effect}-${name}` as FxLane],
         context.samplesPerTick,
+        context.warp,
       );
     },
   };

package/src/audio/effects/convolution.ts

@@ -119,9 +119,48 @@ export function convolveStereo(
   gain: number,
   gainAt?: (index: number) => number,
 ): void {
+  const rawL = new Float64Array(input.length);
+  const rawR = new Float64Array(input.length);
+  const scale = convolveRaw(input, impulse, rawL, rawR);
+  if (scale === 0) return;
+  addConvolved(rawL, rawR, scale, outL, outR, gain, gainAt);
+}
+
+/**
+ * Adds the unscaled convolution from `convolveRaw` at `gain` (or `gainAt`
+ * per sample): `out += raw · (gain · scale)`, the order `convolveStereo`
+ * always used, so a cached raw signal mixes to the same samples.
+ */
+export function addConvolved(
+  rawL: Float64Array,
+  rawR: Float64Array,
+  scale: number,
+  outL: Float64Array,
+  outR: Float64Array,
+  gain: number,
+  gainAt?: (index: number) => number,
+): void {
+  for (let index = 0; index < rawL.length; index += 1) {
+    const g = (gainAt ? gainAt(index) : gain) * scale;
+    outL[index]! += rawL[index]! * g;
+    outR[index]! += rawR[index]! * g;
+  }
+}
+
+/**
+ * The convolution input ∗ impulse into `rawL`/`rawR` before its inverse-FFT
+ * scale, which it returns. Samples past the input are left as they were
+ * (zero for fresh arrays), as is everything when the impulse is empty.
+ */
+export function convolveRaw(
+  input: Float64Array,
+  impulse: Impulse,
+  rawL: Float64Array,
+  rawR: Float64Array,
+): number {
   const length = input.length;
   const irLength = impulse.left.length;
-  if (length === 0 || irLength === 0) return;
+  if (length === 0 || irLength === 0) return 0;
   const block = partitionSize(irLength);
   const n = block * 2;
   const partitions = Math.ceil(irLength / block);
@@ -179,12 +218,11 @@ export function convolveStereo(
     const outStart = k * block;
     const count = Math.min(block, length - outStart);
     for (let i = 0; i < count; i += 1) {
-      const index = outStart + i;
-      const g = (gainAt ? gainAt(index) : gain) * scale;
-      outL[index]! += accRe[block + i]! * g;
-      outR[index]! += accIm[block + i]! * g;
+      rawL[outStart + i] = accRe[block + i]!;
+      rawR[outStart + i] = accIm[block + i]!;
     }
   }
+  return scale;
 }
 
 /** Built-in impulse names (`builtin:<name>`). */

package/src/audio/effects/dynamics.ts

@@ -10,6 +10,7 @@ import {
   fxReader,
   lfo,
   lfoHz,
+  tempoAtSample,
   type EffectContext,
 } from "./common.ts";
 
@@ -42,7 +43,7 @@ export function applyTremolo(
   for (let index = 0; index < buffer.length; index += 1) {
     if (index % CONTROL_SAMPLES === 0) {
       phasor.setHz(
-        lfoHz(sync, rate.at(index), context.tempoBpm),
+        lfoHz(sync, rate.at(index), tempoAtSample(context, index)),
         context.sampleRate,
       );
       if (depth.automated) amount = depth.at(index);

package/src/audio/effects/filter.ts

@@ -15,7 +15,9 @@ import {
   interpolateAutomation,
   lfo,
   lfoHz,
+  tempoAtSample,
   resonanceQ,
+  tickAtSample,
   type EffectContext,
   type FilterType,
 } from "./common.ts";
@@ -99,7 +101,7 @@ export function applyTrackFilter(
   const resonanceLane = track.resonanceAutomation ?? [];
   if (!track.filter && automation.length === 0 && resonanceLane.length === 0)
     return;
-  const { sampleRate, samplesPerTick } = context;
+  const { sampleRate } = context;
   const staticCutoff = track.filter?.cutoff ?? SCORE_LIMITS.maxFilterCutoff;
   const staticResonance = track.filter?.resonance ?? 0;
   const automated = automation.length > 0 || resonanceLane.length > 0;
@@ -111,7 +113,7 @@ export function applyTrackFilter(
   filter.update(staticCutoff, staticResonance);
   for (let index = 0; index < buffer.length; index += 1) {
     if (automated && index % CONTROL_SAMPLES === 0) {
-      const tick = index / samplesPerTick;
+      const tick = tickAtSample(context, index);
       filter.update(
         interpolateAutomation(automation, tick, staticCutoff),
         interpolateAutomation(resonanceLane, tick, staticResonance),
@@ -205,7 +207,7 @@ export function applyAutoFilter(
         : release * envelope + (1 - release) * level;
     if (index % CONTROL_SAMPLES === 0) {
       phasor.setHz(
-        lfoHz(sync, rate.at(index), context.tempoBpm),
+        lfoHz(sync, rate.at(index), tempoAtSample(context, index)),
         context.sampleRate,
       );
       followOctaves = follow.at(index);

package/src/audio/effects/modulation.ts

@@ -9,6 +9,7 @@ import {
   clamp,
   fxReader,
   lfoHz,
+  tempoAtSample,
   readFractional,
   type EffectContext,
 } from "./common.ts";
@@ -57,7 +58,10 @@ export function applyPhaser(
   };
   for (let index = 0; index < left.length; index += 1) {
     if (index % CONTROL_SAMPLES === 0) {
-      phasor.setHz(lfoHz(sync, rate.at(index), context.tempoBpm), sampleRate);
+      phasor.setHz(
+        lfoHz(sync, rate.at(index), tempoAtSample(context, index)),
+        sampleRate,
+      );
       if (depth.automated) amount = depth.at(index);
       const frequency = clamp(
         center + (sweep / 2) * Math.sin(2 * Math.PI * phasor.phase),