@onda-lang/webaudio 0.8.21 → 0.8.23

package/README.md

@@ -56,8 +56,14 @@ block, independently of Web Audio callback sizes; durations at most one block ar
 Integer, boolean, and stepped controls update directly. Initial parameters and reinitialization
 settle immediately. A new target restarts from the published value, while repeated writes of the
 same target preserve its deadline. Host ramps are excluded from processor snapshots. The browser
-playground uses `0.03` seconds (30 ms); explicit DSP smoothing can be used for interpolation within
-an audio block.
+playground defaults to `0.03` seconds (30 ms), with a live **Smooth** control in its Params header
+that remembers the duration in the browser. Explicit DSP smoothing can interpolate within a block.
+
+`setParamSmoothingSeconds(seconds)` changes the duration live without recompilation or
+reinitialization. Active ramps restart from the current published value with the new duration.
+Setting 0 (or a duration at most one block) settles active targets immediately and disables ramps;
+smoothing can be enabled later. The duration must be finite and nonnegative, and affects continuous
+float writes from UI controls and automation alike.
 
 `resetParams()` restores all declared defaults immediately and cancels host ramps without resetting
 DSP state.

package/api.md

@@ -223,6 +223,10 @@ The adapter exposes its `node` and validated `metadata`, plus these operations:
 - `setParam(nameOrIndex, plain)` and `setParamNormalized(nameOrIndex, normalized)` for whole
   parameters.
 - `resetParams()` to restore parameter defaults immediately and cancel host ramps, retaining DSP state.
+- `setParamSmoothingSeconds(seconds)` to change the host duration live without recompiling or
+  reinitializing DSP state. Finite, nonnegative durations are required. Active ramps restart from
+  their current values using the new duration; 0 (or a duration at most one block) settles their
+  targets immediately. Smoothing can be enabled after starting with 0.
 - `setParamElement(nameOrIndex, element, plain)` and
   `setParamElementNormalized(nameOrIndex, element, normalized)` for one scalar or fixed-array
   element.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onda-lang/webaudio",
-  "version": "0.8.21",
+  "version": "0.8.23",
   "type": "module",
   "description": "Optional Web Audio adapter for Onda processor WebAssembly artifacts",
   "license": "MIT",
@@ -34,7 +34,7 @@
     "prepack": "node ../../scripts/stage-web-api-docs.mjs"
   },
   "dependencies": {
-    "@onda-lang/processor-abi": "0.8.21"
+    "@onda-lang/processor-abi": "0.8.23"
   },
   "publishConfig": {
     "access": "public"

package/src/index.d.ts

@@ -134,6 +134,8 @@ export class OndaAudioProcessor {
   setParam(param: string | number, value: unknown): Promise<any>;
   /** Restore all parameter defaults immediately, cancelling host ramps and retaining DSP state. */
   resetParams(): Promise<any>;
+  /** Change host smoothing live, restarting active ramps from their current values; 0 settles them immediately. */
+  setParamSmoothingSeconds(seconds: number): Promise<any>;
   /** Set one scalar or fixed-array parameter element without modifying its siblings. */
   setParamElement(param: string | number, element: number, value: unknown): Promise<any>;
   /** Map a host value in [0, 1] through the descriptor and set the resulting plain value. */

package/src/index.js

@@ -660,6 +660,16 @@ export class OndaAudioProcessor {
     }
   }
 
+  setParamSmoothingSeconds(seconds) {
+    try {
+      paramSmoothingSamples(seconds, this.metadata?.compile?.sample_rate ?? 1,
+        this.metadata?.compile?.block_size ?? 0);
+      return this.request("set-param-smoothing", { seconds });
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+
   resetParams() {
     return this.request("reset-params");
   }

package/src/param-metadata.js

@@ -48,29 +48,55 @@ export class ParamSmoothing {
     this.started = false;
     this.addresses = new Map();
     this.entries = [];
-    if (samples > 0) {
-      for (const param of params) {
-        if ((param.scalar !== "f32" && param.scalar !== "f64")
-          || param.param_control?.step_count != null) continue;
-        const elements = [];
-        const f32 = param.scalar === "f32";
-        for (let element = 0; element < param.array_len; element += 1) {
-          const offset = Number(param.byte_offset) + element * (f32 ? 4 : 8);
-          const value = f32 ? view.getFloat32(paramsPtr + offset, true)
-            : view.getFloat64(paramsPtr + offset, true);
-          elements.push(this.entries.length);
-          this.entries.push({ offset, f32, current: value, start: value,
-            target: value, elapsed: samples, active: false });
-        }
-        this.addresses.set(param, elements);
+    for (const param of params) {
+      if ((param.scalar !== "f32" && param.scalar !== "f64")
+        || param.param_control?.step_count != null) continue;
+      const elements = [];
+      const f32 = param.scalar === "f32";
+      for (let element = 0; element < param.array_len; element += 1) {
+        const offset = Number(param.byte_offset) + element * (f32 ? 4 : 8);
+        const value = f32 ? view.getFloat32(paramsPtr + offset, true)
+          : view.getFloat64(paramsPtr + offset, true);
+        elements.push(this.entries.length);
+        this.entries.push({ offset, f32, current: value, start: value,
+          target: value, elapsed: samples, active: false });
       }
+      this.addresses.set(param, elements);
     }
     this.active = new Uint32Array(this.entries.length);
     this.activeCount = 0;
   }
 
   isEnabledFor(param) {
-    return this.addresses.has(param);
+    return this.samples > 0 && this.addresses.has(param);
+  }
+
+  setDuration(samples, view, paramsPtr) {
+    if (samples === this.samples) return;
+    // Bulk writes bypass ramp state while disabled; read the actual DSP values.
+    if (this.samples === 0) this.readTargets(view, paramsPtr);
+    const previousSamples = this.samples;
+    this.samples = samples;
+    this.inverseSamples = 1 / Math.max(samples, 1);
+    for (let cursor = 0; cursor < this.activeCount; cursor += 1) {
+      const entry = this.entries[this.active[cursor]];
+      if (samples === 0) {
+        this.write(entry, entry.target, view, paramsPtr);
+        entry.active = false;
+      }
+      entry.start = entry.current;
+      entry.elapsed = entry.elapsed === previousSamples ? samples : 0;
+    }
+    if (samples === 0) this.activeCount = 0;
+  }
+
+  readTargets(view, paramsPtr) {
+    for (const entry of this.entries) {
+      entry.current = entry.target = entry.f32
+        ? view.getFloat32(paramsPtr + entry.offset, true)
+        : view.getFloat64(paramsPtr + entry.offset, true);
+      entry.start = entry.current;
+    }
   }
 
   setTarget(param, element, value, initialized) {
@@ -78,7 +104,7 @@ export class ParamSmoothing {
     if (id === undefined) return false;
     const entry = this.entries[id];
     const target = entry.f32 ? Math.fround(Number(value)) : Number(value);
-    if (!initialized || !this.started || !Number.isFinite(target) || !Number.isFinite(entry.current)) {
+    if (this.samples === 0 || !initialized || !this.started || !Number.isFinite(target) || !Number.isFinite(entry.current)) {
       entry.current = target;
       entry.target = target;
       entry.elapsed = this.samples;
@@ -123,6 +149,7 @@ export class ParamSmoothing {
   }
 
   settle(view, paramsPtr) {
+    if (this.samples === 0) this.readTargets(view, paramsPtr);
     this.activeCount = 0;
     this.started = false;
     for (const entry of this.entries) {
@@ -134,10 +161,7 @@ export class ParamSmoothing {
   }
 
   reset(view, paramsPtr) {
-    for (const entry of this.entries) {
-      entry.target = entry.f32 ? view.getFloat32(paramsPtr + entry.offset, true)
-        : view.getFloat64(paramsPtr + entry.offset, true);
-    }
+    this.readTargets(view, paramsPtr);
     this.settle(view, paramsPtr);
   }
 

package/src/worklet.js

@@ -748,6 +748,10 @@ class OndaWasmProcessor extends AudioWorkletProcessor {
           message.element ?? null,
         );
         this.postResponse(message, { type: "onda-ok", operation: message.type });
+      } else if (message.type === "set-param-smoothing") {
+        const samples = paramSmoothingSamples(message.seconds, this.compileSampleRate, this.blockSize);
+        this.paramSmoothing.setDuration(samples, this.memoryView(), this.paramsPtr);
+        this.postResponse(message, { type: "onda-ok", operation: message.type });
       } else if (message.type === "reset-params") {
         this.writeParamDefaults();
         this.paramSmoothing.reset(this.memoryView(), this.paramsPtr);