@effetune/dsp 0.1.0 → 0.5.0

package/dist/internal/dsp-wasm-loader.js

@@ -174,6 +174,7 @@ export function createDspParamPackers(generatedModule, kernels = null, warning =
             const byteCapacity = Number.isInteger(value?.byteCapacity) ? value.byteCapacity : 0;
             const hash = Number.isInteger(value?.hash) ? value.hash >>> 0 : findHash(generatedModule, typeName);
             if (typeof pack !== 'function' || hash === null) continue;
+            if (kernelHashes && !kernelHashes.has(typeName)) continue;
             if (kernelHashes && (kernelHashes.get(typeName) !== hash ||
                 kernelByteCapacities.get(typeName) !== byteCapacity)) {
                 warn(warning, `${typeName} generated parameter layout does not match the loaded kernel`);
@@ -194,6 +195,7 @@ export function createDspParamPackers(generatedModule, kernels = null, warning =
         const typeName = match[1];
         const hash = findHash(generatedModule, typeName);
         if (hash === null) continue;
+        if (kernelHashes && !kernelHashes.has(typeName)) continue;
         if (kernelHashes && kernelHashes.get(typeName) !== hash) {
             warn(warning, `${typeName} generated parameter layout does not match the loaded kernel`);
             continue;

package/dist/preset.js

@@ -198,6 +198,24 @@ const LEGACY_OBJECT_ARRAYS_V1 = Object.freeze({
     count: 5,
     members: Object.freeze({ balance: 'balance' })
   }),
+  PhaseSelectEQ: Object.freeze({
+    effectLabel: 'Phase Select EQ',
+    arrayKey: 'regions',
+    count: 5,
+    members: Object.freeze({
+      en: 'regionEnabled',
+      ofl: 'outerFrequencyLow',
+      fl: 'coreFrequencyLow',
+      fh: 'coreFrequencyHigh',
+      ofh: 'outerFrequencyHigh',
+      opl: 'outerPhaseLow',
+      pl: 'corePhaseLow',
+      ph: 'corePhaseHigh',
+      oph: 'outerPhaseHigh',
+      gn: 'gain'
+    }),
+    itemLabel: 'region'
+  }),
   MultibandSaturation: Object.freeze({
     effectLabel: 'Multiband Saturation',
     arrayKey: 'bands',
@@ -254,6 +272,10 @@ const LEGACY_ECHOED_STRUCTURAL_KEYS_V1 = Object.freeze(['pluginType', 'ch', 'ib'
 // dropped for these two effects only.
 const LEGACY_ECHOED_ENABLED_EFFECTS_V1 = Object.freeze(['HornResonator', 'HornResonatorPlus']);
 
+// These analyzers persist their frequency-axis choice for display only. Validate
+// the known values before discarding it so other unknown parameters remain strict.
+const LEGACY_FREQUENCY_SCALE_EFFECTS_V1 = Object.freeze(['SpectrumAnalyzer', 'Spectrogram']);
+
 function dropEchoedStructuralKeysV1(parameters, effectType) {
   for (const key of LEGACY_ECHOED_STRUCTURAL_KEYS_V1) delete parameters[key];
   if (LEGACY_ECHOED_ENABLED_EFFECTS_V1.includes(effectType)) delete parameters.en;
@@ -339,6 +361,13 @@ function expandLegacyObjectArrayV1(parameters, {
 
 function prepareLegacyParametersV1(effectType, source) {
   const parameters = dropEchoedStructuralKeysV1({ ...source }, effectType);
+  if (LEGACY_FREQUENCY_SCALE_EFFECTS_V1.includes(effectType) &&
+      Object.hasOwn(parameters, 'sc')) {
+    if (parameters.sc !== 'log' && parameters.sc !== 'linear') {
+      throw new ValidationError(`Legacy ${effectType} contains invalid frequency scale display state.`);
+    }
+    delete parameters.sc;
+  }
   let processingEnabled = true;
   if (effectType === 'Matrix' && Object.hasOwn(parameters, 'mx')) {
     if (Object.hasOwn(parameters, 'matrixRoutes')) {

package/dist/runtime.js

@@ -4,6 +4,7 @@ import { createEngineSession } from './engine.js';
 import { StateError, ValidationError } from './errors.js';
 import {
   normalizeChainDocument,
+  canonicalizeEffectForProcessing,
   channelRange,
   packEffect,
   setEffectParameter,
@@ -90,18 +91,31 @@ function updateEffectParameters(effect, parameters) {
   return updated;
 }
 
+function updateProcessingEffectParameters(effect, parameters) {
+  return canonicalizeEffectForProcessing(updateEffectParameters(effect, parameters));
+}
+
+function canonicalizeDocumentForProcessing(document) {
+  return {
+    version: 1,
+    chain: document.chain.map(canonicalizeEffectForProcessing)
+  };
+}
+
 function replaceEffect(document, index, effect) {
   const chain = [...document.chain];
   chain[index] = effect;
   return { version: 1, chain };
 }
 
-function validateParameterEvents(events, document, frameCount) {
+function validateParameterEvents(events, document, processingDocument, frameCount) {
   if (events === undefined) return [];
   if (!Array.isArray(events)) {
     throw new ValidationError('events must be an array.');
   }
   let workingDocument = cloneDocument(document);
+  let workingProcessingDocument = cloneDocument(processingDocument);
+  const pendingPatches = new Map();
   let previousFrame = -1;
   return events.map((event, eventIndex) => {
     if (!isRecord(event)) {
@@ -123,12 +137,32 @@ function validateParameterEvents(events, document, frameCount) {
     previousFrame = event.frame;
     const index = effectIndex(workingDocument, event.effectId);
     const effect = updateEffectParameters(workingDocument.chain[index], event.parameters);
+    let pending = pendingPatches.get(event.effectId);
+    if (!pending || pending.frame !== event.frame) {
+      pending = {
+        frame: event.frame,
+        effect: workingProcessingDocument.chain[index],
+        parameters: {}
+      };
+      pendingPatches.set(event.effectId, pending);
+    }
+    Object.assign(pending.parameters, event.parameters);
+    const processingEffect = updateProcessingEffectParameters(
+      pending.effect,
+      pending.parameters
+    );
     workingDocument = replaceEffect(workingDocument, index, effect);
+    workingProcessingDocument = replaceEffect(
+      workingProcessingDocument,
+      index,
+      processingEffect
+    );
     return {
       frame: event.frame,
       effectId: event.effectId,
       effect,
-      packed: packEffect(effect)
+      processingEffect,
+      packed: packEffect(processingEffect)
     };
   });
 }
@@ -142,6 +176,9 @@ class ChainStream {
   }) {
     this._initialDocument = cloneDocument(document);
     this._document = cloneDocument(document);
+    this._initialProcessingDocument = canonicalizeDocumentForProcessing(document);
+    this._processingDocument = cloneDocument(this._initialProcessingDocument);
+    this._pendingProcessingPatches = new Map();
     this._session = session;
     this._sampleRate = sampleRate;
     this._channels = channels;
@@ -154,7 +191,7 @@ class ChainStream {
 
   get preset() {
     this._assertOpen();
-    return cloneDocument(this._document);
+    return cloneDocument(this._processingDocument);
   }
 
   get effects() {
@@ -180,9 +217,27 @@ class ChainStream {
     const index = effectIndex(this._document, effectId);
     validateStreamParameterUpdate(this._document.chain[index], parameterName);
     const effect = setEffectParameter(this._document.chain[index], parameterName, value);
-    const packed = packEffect(effect);
+    let pending = this._pendingProcessingPatches.get(effectId);
+    if (!pending) {
+      pending = {
+        effect: this._processingDocument.chain[index],
+        parameters: {}
+      };
+      this._pendingProcessingPatches.set(effectId, pending);
+    }
+    pending.parameters[parameterName] = value;
+    const processingEffect = updateProcessingEffectParameters(
+      pending.effect,
+      pending.parameters
+    );
+    const packed = packEffect(processingEffect);
     this._session?.setPacked(effectId, packed.values, packed.hash, packed.bytes);
     this._document = replaceEffect(this._document, index, effect);
+    this._processingDocument = replaceEffect(
+      this._processingDocument,
+      index,
+      processingEffect
+    );
     return this;
   }
 
@@ -211,9 +266,15 @@ class ChainStream {
         `Audio has ${layout.channels} channel(s); this stream requires ${this._channels}.`
       );
     }
-    const parameterEvents = validateParameterEvents(events, this._document, layout.frames);
+    const parameterEvents = validateParameterEvents(
+      events,
+      this._document,
+      this._processingDocument,
+      layout.frames
+    );
     const output = audio.map(channel => new Float32Array(channel));
     if (layout.frames === 0) return output;
+    this._pendingProcessingPatches.clear();
 
     let offset = 0;
     let eventIndex = 0;
@@ -228,6 +289,11 @@ class ChainStream {
         );
         const index = effectIndex(this._document, event.effectId);
         this._document = replaceEffect(this._document, index, event.effect);
+        this._processingDocument = replaceEffect(
+          this._processingDocument,
+          index,
+          event.processingEffect
+        );
         eventIndex += 1;
       }
       const nextEventFrame = parameterEvents[eventIndex]?.frame ?? layout.frames;
@@ -254,6 +320,8 @@ class ChainStream {
     this._assertOpen();
     this._session?.reset();
     this._document = cloneDocument(this._initialDocument);
+    this._processingDocument = cloneDocument(this._initialProcessingDocument);
+    this._pendingProcessingPatches.clear();
     this._processedFrames = 0;
     return this;
   }