@hraness/dawg 0.3.0 → 0.4.1

package/src/audio/effects/space.ts

@@ -0,0 +1,394 @@
+/**
+ * Send effects on the stereo pair: delay and reverb. Without their
+ * optional parameters both render exactly as the original renderer did.
+ */
+import type { Track } from "../../../core/score.ts";
+import type { DecodedSample } from "../samples.ts";
+import {
+  addConvolved,
+  builtinImpulse,
+  convolveRaw,
+  sampleImpulse,
+  type Impulse,
+} from "./convolution.ts";
+import {
+  CONTROL_SAMPLES,
+  OnePole,
+  Param,
+  interpolateAutomation,
+  type EffectContext,
+} from "./common.ts";
+
+/** Delay length in seconds: `time` when set, otherwise `beats` at the tempo. */
+export function delaySeconds(track: Track, tempoBpm: number): number {
+  const delay = track.delay;
+  if (!delay) return 0;
+  return delay.time !== undefined && delay.time > 0
+    ? delay.time
+    : (delay.beats * 60) / tempoBpm;
+}
+
+/**
+ * Stereo feedback delay. Absent `pingpong`, each side echoes its own input
+ * and feeds back into the opposite side (the original sound). With
+ * `pingpong`, the mono sum enters the left line only and every repeat
+ * crosses over, so echoes alternate left, right, left. `highcut` runs a
+ * one-pole low-pass on everything written into the lines, so each repeat
+ * is darker than the last. Feedback and mix follow their lanes. `wetOnly`
+ * (a shared orbit bus) replaces the input with the repeats alone.
+ */
+export function applyDelay(
+  left: Float64Array,
+  right: Float64Array,
+  track: Track,
+  context: EffectContext,
+  wetOnly = false,
+): void {
+  const delay = track.delay;
+  if (!delay) return;
+  const feedbackLane = track.delayFeedbackAutomation ?? [];
+  const mixLane = track.delayMixAutomation ?? [];
+  if (delay.mix <= 0 && mixLane.length === 0) return;
+  const { sampleRate, samplesPerTick } = context;
+  const length = Math.max(
+    1,
+    Math.round(delaySeconds(track, context.tempoBpm) * sampleRate),
+  );
+  const lineL = new Float64Array(length);
+  const lineR = new Float64Array(length);
+  let feedback = delay.feedback;
+  let mix = delay.mix;
+  const automated = feedbackLane.length > 0 || mixLane.length > 0;
+  const pingpong = delay.pingpong === true;
+  const highcut =
+    delay.highcut === undefined
+      ? undefined
+      : [
+          new OnePole(delay.highcut, sampleRate),
+          new OnePole(delay.highcut, sampleRate),
+        ];
+  for (let index = 0; index < left.length; index += 1) {
+    if (automated && index % CONTROL_SAMPLES === 0) {
+      const tick = index / samplesPerTick;
+      feedback = interpolateAutomation(feedbackLane, tick, delay.feedback);
+      mix = interpolateAutomation(mixLane, tick, delay.mix);
+    }
+    const slot = index % length;
+    const wetL = lineL[slot]!;
+    const wetR = lineR[slot]!;
+    const dryL = left[index]!;
+    const dryR = right[index]!;
+    let writeL: number;
+    let writeR: number;
+    if (pingpong) {
+      writeL = (dryL + dryR) * 0.5 + wetR * feedback;
+      writeR = wetL * feedback;
+    } else {
+      writeL = dryL + wetR * feedback;
+      writeR = dryR + wetL * feedback;
+    }
+    if (highcut) {
+      writeL = highcut[0]!.process(writeL);
+      writeR = highcut[1]!.process(writeR);
+    }
+    lineL[slot] = writeL;
+    lineR[slot] = writeR;
+    left[index] = (wetOnly ? 0 : dryL) + wetL * mix;
+    right[index] = (wetOnly ? 0 : dryR) + wetR * mix;
+  }
+}
+
+/** Seconds until the track's delay decays below -60 dB, bounded. */
+export function delayTailFor(track: Track, tempoBpm: number): number {
+  if (!track.delay) return 0;
+  const feedback = Math.max(
+    track.delay.feedback,
+    ...(track.delayFeedbackAutomation ?? []).map((point) => point.value),
+  );
+  const repeats =
+    feedback <= 0.001 ? 1 : Math.min(64, Math.log(0.001) / Math.log(feedback));
+  return delaySeconds(track, tempoBpm) * (repeats + 1);
+}
+
+/** Freeverb comb and allpass tunings at 44.1 kHz; the right side is spread. */
+const COMB_TUNING = [1116, 1188, 1277, 1356, 1422, 1491, 1557, 1617] as const;
+const ALLPASS_TUNING = [556, 441, 341, 225] as const;
+const STEREO_SPREAD = 23;
+const REVERB_INPUT_GAIN = 0.015;
+const REVERB_WET_SCALE = 3;
+
+/**
+ * Convolution wet level: an energy-normalized impulse on the summed pair,
+ * scaled so `mix` sounds as loud as the algorithmic tail at the same mix.
+ */
+const IR_WET_SCALE = 2.1;
+
+/** Impulses decoded from samples, by sha256 and rate (small: a few IRs). */
+const SAMPLE_IMPULSES = new Map<string, Impulse>();
+const MAX_SAMPLE_IMPULSES = 8;
+
+/**
+ * The impulse a track's `reverb.ir` names at this rate: a generated
+ * built-in, or the decoded sample in `irs`. Undefined when the track has no
+ * `ir` or its sample did not load (the algorithmic reverb then plays).
+ */
+export function reverbImpulse(
+  track: Track,
+  sampleRate: number,
+  irs?: ReadonlyMap<string, DecodedSample>,
+): Impulse | undefined {
+  const ir = track.reverb?.ir;
+  if (!ir) return undefined;
+  if (ir.src.startsWith("builtin:"))
+    return builtinImpulse(ir.src.slice("builtin:".length), sampleRate);
+  const sample = irs?.get(track.id);
+  if (!sample) return undefined;
+  const key = `${sample.sha256}@${sampleRate}`;
+  let impulse = SAMPLE_IMPULSES.get(key);
+  if (!impulse) {
+    impulse = sampleImpulse(
+      `${ir.src}#${sample.sha256}`,
+      sample.mono,
+      sample.sampleRate,
+      sampleRate,
+    );
+    if (SAMPLE_IMPULSES.size >= MAX_SAMPLE_IMPULSES)
+      SAMPLE_IMPULSES.delete(SAMPLE_IMPULSES.keys().next().value!);
+    SAMPLE_IMPULSES.set(key, impulse);
+  }
+  return impulse;
+}
+
+/** Seconds of reverb tail a render keeps for this track. */
+export function reverbTailFor(
+  track: Track,
+  sampleRate = 44_100,
+  irs?: ReadonlyMap<string, DecodedSample>,
+): number {
+  const reverb = track.reverb;
+  const lane = track.fxAutomation?.["reverb-mix"] ?? [];
+  if (!reverb || (reverb.mix <= 0 && lane.length === 0)) return 0;
+  const impulse = reverbImpulse(track, sampleRate, irs);
+  const decay = impulse
+    ? impulse.left.length / sampleRate
+    : (reverb.fade ?? 1 + 3 * reverb.size);
+  return Math.min(20, decay + (reverb.predelay ?? 0));
+}
+
+/**
+ * Schroeder–Moorer reverb in the Freeverb arrangement: eight damped
+ * feedback combs then four allpasses per side, the right side detuned.
+ * `size` sets comb feedback and damping; `fade` instead sets each comb's
+ * feedback for an exact -60 dB decay time; `dim` sets the in-loop damping
+ * frequency, `lowpass` filters the input and `predelay` delays it.
+ * `wetOnly` (a shared orbit bus) replaces the input with the tail alone.
+ *
+ * It runs in two steps: `reverbWet` (the tail before its mix gain, which
+ * does not depend on `mix`) and `addReverbWet`. The stem cache keeps the
+ * first, so a mix-only edit skips the room entirely.
+ */
+export function applyReverb(
+  left: Float64Array,
+  right: Float64Array,
+  track: Track,
+  context: EffectContext,
+  wetOnly = false,
+): void {
+  const wet = reverbWet(left, right, track, context);
+  if (wet) addReverbWet(left, right, wet, track, context, wetOnly);
+}
+
+/** A reverb's tail before its mix gain (`scale` for an impulse response). */
+export type ReverbWet = Readonly<{
+  left: Float64Array;
+  right: Float64Array;
+  /** The convolution's inverse-FFT scale; absent for the algorithmic room. */
+  scale?: number;
+}>;
+
+function mixParamOf(track: Track, context: EffectContext): Param {
+  return new Param(
+    track.reverb?.mix ?? 0,
+    track.fxAutomation?.["reverb-mix"],
+    context.samplesPerTick,
+  );
+}
+
+/** Whether the track's reverb sounds at all (a mix above 0, or a lane). */
+export function reverbActive(track: Track): boolean {
+  const reverb = track.reverb;
+  if (!reverb) return false;
+  return (
+    reverb.mix > 0 || (track.fxAutomation?.["reverb-mix"] ?? []).length > 0
+  );
+}
+
+/**
+ * The reverb tail of the pair, before the mix gain; `left`/`right` are
+ * read, not changed. Undefined when the reverb is off.
+ */
+export function reverbWet(
+  left: Float64Array,
+  right: Float64Array,
+  track: Track,
+  context: EffectContext,
+): ReverbWet | undefined {
+  const reverb = track.reverb;
+  if (!reverb || !reverbActive(track)) return undefined;
+  const { sampleRate } = context;
+  const impulse = reverbImpulse(track, sampleRate, context.irs);
+  if (impulse) return convolutionWet(left, right, track, context, impulse);
+  const scale = sampleRate / 44_100;
+  const sizeFeedback = 0.7 + 0.28 * reverb.size;
+  const damp =
+    reverb.dim === undefined
+      ? 0.2 + 0.3 * reverb.size
+      : Math.exp(
+          (-2 * Math.PI * Math.min(reverb.dim, sampleRate * 0.45)) / sampleRate,
+        );
+  const channel = (spread: number) => ({
+    combs: COMB_TUNING.map((tuning) => {
+      const length = Math.max(1, Math.round((tuning + spread) * scale));
+      return {
+        buffer: new Float64Array(length),
+        index: 0,
+        store: 0,
+        feedback:
+          reverb.fade === undefined
+            ? sizeFeedback
+            : Math.min(0.995, 10 ** ((-3 * length) / sampleRate / reverb.fade)),
+      };
+    }),
+    allpasses: ALLPASS_TUNING.map((tuning) => ({
+      buffer: new Float64Array(
+        Math.max(1, Math.round((tuning + spread) * scale)),
+      ),
+      index: 0,
+    })),
+  });
+  const sides = [channel(0), channel(STEREO_SPREAD)] as const;
+  const process = (side: (typeof sides)[number], input: number): number => {
+    let output = 0;
+    for (const comb of side.combs) {
+      const delayed = comb.buffer[comb.index]!;
+      comb.store = delayed * (1 - damp) + comb.store * damp;
+      comb.buffer[comb.index] = input + comb.store * comb.feedback;
+      comb.index = comb.index + 1 === comb.buffer.length ? 0 : comb.index + 1;
+      output += delayed;
+    }
+    for (const allpass of side.allpasses) {
+      const delayed = allpass.buffer[allpass.index]!;
+      allpass.buffer[allpass.index] = output + delayed * 0.5;
+      output = delayed - output;
+      allpass.index =
+        allpass.index + 1 === allpass.buffer.length ? 0 : allpass.index + 1;
+    }
+    return output;
+  };
+  const inputFilter =
+    reverb.lowpass === undefined
+      ? undefined
+      : new OnePole(reverb.lowpass, sampleRate);
+  const predelaySamples = Math.round((reverb.predelay ?? 0) * sampleRate);
+  const predelay =
+    predelaySamples > 0 ? new Float64Array(predelaySamples) : undefined;
+  const wetL = new Float64Array(left.length);
+  const wetR = new Float64Array(left.length);
+  for (let index = 0; index < left.length; index += 1) {
+    let input = (left[index]! + right[index]!) * REVERB_INPUT_GAIN;
+    if (inputFilter) input = inputFilter.process(input);
+    if (predelay) {
+      const slot = index % predelaySamples;
+      const delayed = predelay[slot]!;
+      predelay[slot] = input;
+      input = delayed;
+    }
+    wetL[index] = process(sides[0], input);
+    wetR[index] = process(sides[1], input);
+  }
+  return { left: wetL, right: wetR };
+}
+
+/**
+ * Add (or with `wetOnly`, write) a tail from `reverbWet` at the track's
+ * mix and mix lane, in the order the one-pass reverb always used, so a
+ * cached tail mixes to the same samples.
+ */
+export function addReverbWet(
+  left: Float64Array,
+  right: Float64Array,
+  tail: ReverbWet,
+  track: Track,
+  context: EffectContext,
+  wetOnly = false,
+): void {
+  const mixParam = mixParamOf(track, context);
+  if (tail.scale !== undefined) {
+    if (wetOnly) {
+      left.fill(0);
+      right.fill(0);
+    }
+    if (tail.scale === 0) return;
+    let wet = mixParam.fallback * IR_WET_SCALE;
+    addConvolved(
+      tail.left,
+      tail.right,
+      tail.scale,
+      left,
+      right,
+      wet,
+      mixParam.automated
+        ? (index) => {
+            if (index % CONTROL_SAMPLES === 0)
+              wet = mixParam.at(index) * IR_WET_SCALE;
+            return wet;
+          }
+        : undefined,
+    );
+    return;
+  }
+  let wet = mixParam.fallback * REVERB_WET_SCALE;
+  for (let index = 0; index < left.length; index += 1) {
+    if (mixParam.automated && index % CONTROL_SAMPLES === 0)
+      wet = mixParam.at(index) * REVERB_WET_SCALE;
+    if (wetOnly) {
+      left[index] = tail.left[index]! * wet;
+      right[index] = tail.right[index]! * wet;
+    } else {
+      left[index]! += tail.left[index]! * wet;
+      right[index]! += tail.right[index]! * wet;
+    }
+  }
+}
+
+/**
+ * `reverb.ir`: the summed pair (through `lowpass` and `predelay`, as the
+ * algorithmic reverb) convolved with the impulse and added at `mix`.
+ * `size`, `fade` and `dim` describe the algorithmic tail and do nothing
+ * here: the impulse is the room.
+ */
+function convolutionWet(
+  left: Float64Array,
+  right: Float64Array,
+  track: Track,
+  context: EffectContext,
+  impulse: Impulse,
+): ReverbWet {
+  const reverb = track.reverb!;
+  const { sampleRate } = context;
+  const input = new Float64Array(left.length);
+  const inputFilter =
+    reverb.lowpass === undefined
+      ? undefined
+      : new OnePole(reverb.lowpass, sampleRate);
+  const offset = Math.round((reverb.predelay ?? 0) * sampleRate);
+  for (let index = 0; index + offset < left.length; index += 1) {
+    let value = (left[index]! + right[index]!) * 0.5;
+    if (inputFilter) value = inputFilter.process(value);
+    input[index + offset] = value;
+  }
+  const wetL = new Float64Array(left.length);
+  const wetR = new Float64Array(left.length);
+  const scale = convolveRaw(input, impulse, wetL, wetR);
+  return { left: wetL, right: wetR, scale };
+}

package/src/audio/engine.ts

@@ -4,6 +4,7 @@ import { LoopPlayer } from "./player.ts";
 import { LoopRenderer, type LoopRender } from "./renderer.ts";
 import { clickSounds, clicksIn, type ClickLevel } from "./click.ts";
 import type { LiveNotePcm } from "./live.ts";
+import { levelOf, type SoundLevel } from "./preview.ts";
 import { DEFAULT_SAMPLE_RATE, RENDER_CHANNELS } from "./wav.ts";
 
 /**
@@ -169,6 +170,17 @@ function parseCommand(value: string): string[] {
   return parts;
 }
 
+/**
+ * Swaps crossfade old to new over this window with equal-power gains
+ * (cos/sin), reading both loops at the same beat. 20 ms is long enough that
+ * the step a hard cut makes is spread below ~50 Hz (no click, even on a
+ * full-scale low bass), short enough to sit inside the transport's 30 ms
+ * resync tolerance and below the shortest audible echo (~30-50 ms), so an
+ * edit never sounds smeared or doubled. Playback only: renders, exports and
+ * the loop buffers themselves never pass through it.
+ */
+export const SWAP_FADE_SECONDS = 0.02;
+
 /** Swaps re-anchor to the transport only past this disagreement. */
 const RESYNC_SECONDS = 0.03;
 
@@ -227,6 +239,16 @@ type Loop = Readonly<{
   framesPerBeat: number;
 }>;
 
+/** A loop fading out after a swap, read on from where it was. */
+type FadeOut = {
+  loop: Loop;
+  cursor: number;
+  /** Its gain when the fade began (below 1 when swapped out mid-fade). */
+  from: number;
+  /** Frames of the fade already written. */
+  done: number;
+};
+
 /**
  * The click bus: the engine asks `beatAt` for the transport beat at a stream
  * frame's wall time (undefined while the transport is stopped; negative
@@ -292,6 +314,11 @@ export class AudioEngine {
   private child: PlayerProcess | undefined;
   private timer: ReturnType<typeof setInterval> | undefined;
   private loop: Loop | undefined;
+  /** Loops fading out after swaps (see `SWAP_FADE_SECONDS`). */
+  private fades: FadeOut[] = [];
+  /** Frames of the current loop's fade-in already written, while fading. */
+  private fadeIn: number | undefined;
+  private readonly fadeFrames: number;
   /** Monotonic ms that stream frame 0 belongs to. */
   private startMs = 0;
   /** Stream frames written since `startMs`. */
@@ -304,10 +331,15 @@ export class AudioEngine {
   private queued: PlayRequest | undefined;
   private draining = false;
   private lastRenderMs = 0;
+  /** The loop last swapped in, for `level` (measured on demand, once). */
+  private lastLoopPcm: Int16Array | undefined;
+  private measured: { pcm: Int16Array; level: SoundLevel } | undefined;
   private respawns = 0;
   private respawnTimer: ReturnType<typeof setTimeout> | undefined;
   /** Play mode: keep a player running without a loop for live voices. */
   private monitoring = false;
+  /** A lead set by `setLeadMs` (play mode, auditions) is not adapted. */
+  private leadPinned = false;
   private readonly voices = new Map<number, LiveVoice>();
   private click: ClickBus | undefined;
   private clickVoices: { sound: Float32Array; position: number }[] = [];
@@ -322,6 +354,10 @@ export class AudioEngine {
       ((options.leadMs ?? 200) * this.sampleRate) / 1000,
     );
     this.defaultLeadFrames = this.leadFrames;
+    this.fadeFrames = Math.max(
+      1,
+      Math.round(SWAP_FADE_SECONDS * this.sampleRate),
+    );
     this.tickMs = options.tickMs ?? 20;
     this.now = options.now ?? (() => performance.now());
     this.useTimer = options.timer ?? true;
@@ -359,6 +395,7 @@ export class AudioEngine {
    * after it is pressed); `undefined` restores the constructed lead.
    */
   public setLeadMs(ms: number | undefined): void {
+    this.leadPinned = ms !== undefined;
     this.leadFrames =
       ms === undefined
         ? this.defaultLeadFrames
@@ -371,6 +408,19 @@ export class AudioEngine {
   }
 
   /** Whether live voices and the click can sound (a streaming backend). */
+  /**
+   * RMS, peak and clips of the loop now playing (the audition meter);
+   * measured once per render, on first read. Undefined before any render
+   * or with no audio device.
+   */
+  public get level(): SoundLevel | undefined {
+    const pcm = this.lastLoopPcm;
+    if (!pcm) return undefined;
+    if (this.measured?.pcm !== pcm)
+      this.measured = { pcm, level: levelOf(pcm) };
+    return this.measured.level;
+  }
+
   public get canMonitor(): boolean {
     return this.info.backend !== "none" && !this.fallback;
   }
@@ -451,10 +501,10 @@ export class AudioEngine {
 
   /** Frames kept queued ahead of the clock right now. */
   public get lead(): number {
-    // Play mode keeps its short lead: renders run off-thread, so a slow
-    // render delays the swap, not the stream.
+    // Play mode and auditions keep their short lead: renders run
+    // off-thread, so a slow render delays the swap, not the stream.
     const adaptive =
-      this.monitoring && this.renderer.offThread
+      (this.monitoring || this.leadPinned) && this.renderer.offThread
         ? 0
         : Math.round(
             (LEAD_RENDER_FACTOR * this.lastRenderMs * this.sampleRate) / 1000,
@@ -499,8 +549,10 @@ export class AudioEngine {
           const render = await this.renderer.render(request.score);
           this.lastRenderMs = render.renderMs;
           // Stopped while rendering: the result is stale, not an error.
-          if (request.generation === this.generation)
+          if (request.generation === this.generation) {
             await this.apply(this.toLoop(render, request.score), request);
+            this.lastLoopPcm = render.pcm;
+          }
           for (const waiter of request.waiters) waiter.resolve();
         } catch (error) {
           for (const waiter of request.waiters)
@@ -569,6 +621,7 @@ export class AudioEngine {
 
   public async stopAsync(): Promise<void> {
     this.generation += 1;
+    this.lastLoopPcm = undefined;
     this.respawns = 0;
     if (this.respawnTimer) clearTimeout(this.respawnTimer);
     this.respawnTimer = undefined;
@@ -580,6 +633,7 @@ export class AudioEngine {
     if (this.monitoring && this.child) {
       // Play mode: the transport stopped, the live player keeps running.
       this.loop = undefined;
+      this.endFades();
       return;
     }
     if (this.timer) clearInterval(this.timer);
@@ -587,6 +641,7 @@ export class AudioEngine {
     const child = this.child;
     this.child = undefined;
     this.loop = undefined;
+    this.endFades();
     if (child) {
       try {
         child.stdin.end?.();
@@ -623,6 +678,7 @@ export class AudioEngine {
     if (remaining > this.sampleRate) {
       const skipped = remaining - this.sampleRate;
       if (loop) this.cursor = (this.cursor + skipped) % loop.frames;
+      this.endFades();
       this.written += skipped;
       remaining = this.sampleRate;
     }
@@ -640,6 +696,7 @@ export class AudioEngine {
       offset += take;
       this.cursor = (this.cursor + take) % loop.frames;
     }
+    if (loop) this.crossfade(out, remaining);
     this.mixLive(out, this.written, remaining);
     this.written += remaining;
     try {
@@ -650,6 +707,49 @@ export class AudioEngine {
     }
   }
 
+  /** Equal-power gain of a fade-in `done` frames along (0 to 1). */
+  private rampGain(done: number): number {
+    return Math.sin((Math.PI / 2) * Math.min(1, done / this.fadeFrames));
+  }
+
+  /**
+   * Blend the start of a block (already the current loop) with the loops
+   * fading out: new·sin + old·cos over `fadeFrames`, both read at the same
+   * beat, so a swap never steps the waveform.
+   */
+  private crossfade(out: Int16Array, frames: number): void {
+    if (this.fadeIn === undefined) return;
+    const start = this.fadeIn;
+    const count = Math.min(frames, this.fadeFrames - start);
+    for (let index = 0; index < count; index += 1) {
+      const gain = this.rampGain(start + index);
+      const at = index * RENDER_CHANNELS;
+      let left = out[at]! * gain;
+      let right = out[at + 1]! * gain;
+      for (const fade of this.fades) {
+        if (fade.done >= this.fadeFrames) continue;
+        const g =
+          fade.from * Math.cos((Math.PI / 2) * (fade.done / this.fadeFrames));
+        const from = fade.cursor * RENDER_CHANNELS;
+        left += fade.loop.pcm[from]! * g;
+        right += fade.loop.pcm[from + 1]! * g;
+        fade.cursor = (fade.cursor + 1) % fade.loop.frames;
+        fade.done += 1;
+      }
+      out[at] = clamp16(left);
+      out[at + 1] = clamp16(right);
+    }
+    this.fadeIn = start + count;
+    // Older fades that began earlier finish before the newest fade-in does.
+    this.fades = this.fades.filter((fade) => fade.done < this.fadeFrames);
+    if (this.fadeIn >= this.fadeFrames) this.endFades();
+  }
+
+  private endFades(): void {
+    this.fades = [];
+    this.fadeIn = undefined;
+  }
+
   /** Wall time (monotonic ms) stream frame `frame` sounds at. */
   private frameMs(frame: number): number {
     return this.startMs + (frame * 1000) / this.sampleRate;
@@ -740,6 +840,13 @@ export class AudioEngine {
       if (!previous || wrapped > this.sampleRate * RESYNC_SECONDS)
         cursor = anchored;
     }
+    if (previous && this.child) {
+      // The outgoing loop keeps its current gain (below 1 when it was
+      // itself still fading in) and fades from there.
+      const from = this.fadeIn === undefined ? 1 : this.rampGain(this.fadeIn);
+      this.fades.push({ loop: previous, cursor: this.cursor, from, done: 0 });
+      this.fadeIn = 0;
+    }
     this.cursor = cursor;
     this.loop = next;
   }
@@ -761,6 +868,7 @@ export class AudioEngine {
     this.spawns += 1;
     this.child = child;
     this.loop = loop;
+    this.endFades();
     this.startMs = this.now();
     this.written = 0;
     this.cursor = loop ? this.frameForBeat(loop, beat) : 0;