@weasel-js/audio 1.11.1 → 1.12.0

package/dist/index.d.ts

@@ -133,8 +133,9 @@ interface GraphNodeDef {
     readonly output: AudioNode;
     /** `rampMs` is always passed; the graph supplies its fade when the caller gives none. */
     readonly params: Readonly<Record<string, (value: number, rampMs: number) => void>>;
-    /** Sources only. `when` is context seconds. Called when the graph starts, or on add/replace while it runs. A source must be startable again after `stop`. */
-    start?(when: number): void;
+    /** Sources only. `when` is context seconds. Called when the graph starts, or on add/replace while it runs. A source must be startable again after `stop`.
+     *  A source that stops on its own, as a non-looping file reaching its end does, calls `ended` so the graph can start it again. */
+    start?(when: number, ended?: () => void): void;
     /** Sources only. Stop at `when` (context seconds). */
     stop?(when: number): void;
     /** Called once, after the node has faded out of the graph. */

package/dist/index.js

@@ -425,7 +425,9 @@ function createFader(ctx, timers, from, to) {
   gain.connect(to);
   let cancel = null;
   let closing = false;
+  let closed = false;
   let cutDone = false;
+  const dones = /* @__PURE__ */ new Set();
   const cut = () => {
     cancel?.();
     cancel = null;
@@ -440,14 +442,20 @@ function createFader(ctx, timers, from, to) {
       writeParam(ctx, gain.gain, 1, ms);
     },
     close(ms, done) {
-      if (closing || cutDone) return;
+      if (closed) done?.();
+      if (closed || cutDone) return;
+      if (done) dones.add(done);
+      if (closing) return;
       closing = true;
       const length = ctx.state === "running" ? ms : 0;
       writeParam(ctx, gain.gain, 0, length);
       cancel = atAudioTime(ctx, timers, ctx.currentTime + length / 1e3, () => {
         cancel = null;
         cut();
-        done?.();
+        closed = true;
+        const all = [...dones];
+        dones.clear();
+        for (const d of all) d();
       });
     },
     cut
@@ -481,11 +489,18 @@ function tapWrapper(ctx, w, opts) {
   return t;
 }
 function startWrapper(w, when) {
-  if (w.running || !w.def.start) return;
+  const { def } = w;
+  if (w.running || !def.start) return;
   w.running = true;
-  w.def.start(when);
+  def.start(when, () => {
+    if (w.def === def) w.running = false;
+  });
 }
 function stopWrapper(w, when) {
+  for (const o of w.outgoing) {
+    if (o.running) o.def.stop?.(when);
+    o.running = false;
+  }
   if (!w.running) return;
   w.running = false;
   w.def.stop?.(when);
@@ -528,10 +543,7 @@ function replaceDef(ctx, timers, w, next, ms, playing, hooks) {
   w.outFader = openFader(ctx, timers, next.output, w.out, ms);
   w.def = next;
   w.running = false;
-  if (playing && next.start) {
-    w.running = true;
-    next.start(ctx.currentTime);
-  }
+  if (playing) startWrapper(w, ctx.currentTime);
   let open = old.faders.length;
   for (const f of old.faders) {
     f.close(ms, () => {
@@ -3043,13 +3055,67 @@ function impulseResponse(ctx, seconds, opts = {}) {
   return buffer;
 }
 
+// src/graph/playhead.ts
+function createPlayhead(duration, loop, initialRate) {
+  let pos = 0;
+  let from = 0;
+  let until = 0;
+  let t0 = 0;
+  let r0 = initialRate;
+  let t1 = 0;
+  let r1 = initialRate;
+  const rateAt = (t) => {
+    if (t >= t1) return r1;
+    return t <= t0 ? r0 : r0 + (r1 - r0) * (t - t0) / (t1 - t0);
+  };
+  const distance = (t) => t <= t1 ? (t - t0) * (r0 + rateAt(t)) / 2 : (t1 - t0) * (r0 + r1) / 2 + (t - t1) * r1;
+  const wrap = (p) => loop ? (p % duration + duration) % duration : Math.min(Math.max(p, 0), duration);
+  const at = (t) => {
+    const x = Math.min(Math.max(t, from), until);
+    return x <= from ? wrap(pos) : wrap(pos + distance(x) - distance(from));
+  };
+  const hold = (t, rate) => {
+    t0 = t;
+    t1 = t;
+    r0 = rate;
+    r1 = rate;
+  };
+  return {
+    start(when, now) {
+      pos = at(until);
+      from = Math.max(when, now);
+      until = Infinity;
+      hold(now, r1);
+      return pos;
+    },
+    stop(when, now) {
+      until = Math.max(when, now, from);
+    },
+    rate(value, rampMs, now) {
+      pos = at(now);
+      from = Math.min(Math.max(now, from), until);
+      r0 = rateAt(now);
+      t0 = now;
+      t1 = now + Math.max(0, rampMs) / 1e3;
+      r1 = value;
+    },
+    rewind(now) {
+      pos = 0;
+      from = now;
+      until = now;
+    }
+  };
+}
+
 // src/graph/sources.ts
 function sourceShell(ctx, make) {
   const output = ctx.createGain();
   let live = null;
+  const ending = /* @__PURE__ */ new Set();
   return {
     output,
     live: () => live,
+    sounding: () => live ? [live, ...ending] : [...ending],
     /** `onEnd` runs if the node ends while it is still the live one: it played out. */
     begin(when, setup, offset, onEnd) {
       const node = make();
@@ -3070,7 +3136,11 @@ function sourceShell(ctx, make) {
       if (!live) return;
       const node = live;
       live = null;
-      node.onended = () => node.disconnect();
+      ending.add(node);
+      node.onended = () => {
+        ending.delete(node);
+        node.disconnect();
+      };
       node.stop(when);
     },
     dispose() {
@@ -3088,42 +3158,34 @@ function createFileSourceNode(ctx, opts) {
   const { buffer } = opts;
   const loop = opts.loop ?? true;
   let rate = 1;
-  let offset = 0;
-  let startedAt = 0;
+  const head = createPlayhead(buffer.duration, loop, rate);
   const shell = sourceShell(ctx, () => ctx.createBufferSource());
-  const advance = (to) => {
-    const next = offset + Math.max(0, to - startedAt) * rate;
-    offset = loop ? next % buffer.duration : Math.min(next, buffer.duration);
-    startedAt = to;
-  };
   return {
     inputs: {},
     output: shell.output,
     params: {
       rate(value, rampMs) {
-        const src = shell.live();
-        if (src) {
-          advance(ctx.currentTime);
-          writeParam(ctx, src.playbackRate, value, rampMs);
-        }
+        for (const src of shell.sounding()) writeParam(ctx, src.playbackRate, value, rampMs);
+        head.rate(value, rampMs, ctx.currentTime);
         rate = value;
       },
       level: shell.level
     },
-    start(when) {
+    start(when, ended) {
       if (shell.live()) return;
-      startedAt = when;
+      const offset = head.start(when, ctx.currentTime);
       shell.begin(when, (s) => {
         s.buffer = buffer;
         s.loop = loop;
         initParam(ctx, s.playbackRate, rate);
       }, offset, () => {
-        offset = 0;
+        head.rewind(ctx.currentTime);
+        ended?.();
       });
     },
     stop(when) {
       if (!shell.live()) return;
-      advance(when);
+      head.stop(when, ctx.currentTime);
       shell.end(when);
     },
     dispose: shell.dispose
@@ -3139,25 +3201,23 @@ function createOscillatorNode(ctx, opts) {
     output: shell.output,
     params: {
       frequency(value, rampMs) {
-        const osc = shell.live();
-        if (osc) writeParam(ctx, osc.frequency, value, rampMs);
+        for (const osc of shell.sounding()) writeParam(ctx, osc.frequency, value, rampMs);
         frequency = value;
       },
       detune(value, rampMs) {
-        const osc = shell.live();
-        if (osc) writeParam(ctx, osc.detune, value, rampMs);
+        for (const osc of shell.sounding()) writeParam(ctx, osc.detune, value, rampMs);
         detune = value;
       },
       level: shell.level
     },
-    start(when) {
+    start(when, ended) {
       if (shell.live()) return;
       shell.begin(when, (osc) => {
         if (typeof wave === "string") osc.type = wave;
         else osc.setPeriodicWave(periodicWave(ctx, wave));
         initParam(ctx, osc.frequency, frequency);
         initParam(ctx, osc.detune, detune);
-      });
+      }, void 0, ended);
     },
     stop: shell.end,
     dispose: shell.dispose
@@ -3169,12 +3229,12 @@ function createNoiseNode(ctx, opts) {
     inputs: {},
     output: shell.output,
     params: { level: shell.level },
-    start(when) {
+    start(when, ended) {
       if (shell.live()) return;
       shell.begin(when, (src) => {
         src.buffer = noiseBuffer(ctx, opts.color);
         src.loop = true;
-      });
+      }, void 0, ended);
     },
     stop: shell.end,
     dispose: shell.dispose