fixed performance issue

packages/superdough/worklets.mjs

@@ -1,23 +1,6 @@
-const processSample = (inputs, outputs, processBlock) => {
-  const input = inputs[0];
-  const output = outputs[0];
-  const blockSize = 128;
-  if (input == null || output == null) {
-    return false;
-  }
-
-  for (let n = 0; n < blockSize; n++) {
-    input.forEach((inChannel, i) => {
-      const outChannel = output[i % output.length];
-      const block = inChannel[n];
-      outChannel[n] = processBlock(block, n, inChannel, outChannel);
-    });
-  }
-  return true;
-};
-
 // coarse, crush, and shape processors adapted from dktr0's webdirt: https://github.com/dktr0/WebDirt/blob/5ce3d698362c54d6e1b68acc47eb2955ac62c793/dist/AudioWorklets.js
 // LICENSE GNU General Public License v3.0 see https://github.com/dktr0/WebDirt/blob/main/LICENSE
+
 class CoarseProcessor extends AudioWorkletProcessor {
   static get parameterDescriptors() {
     return [{ name: 'coarse', defaultValue: 1 }];
@@ -28,15 +11,24 @@ class CoarseProcessor extends AudioWorkletProcessor {
   }
 
   process(inputs, outputs, parameters) {
+    const input = inputs[0];
+    const output = outputs[0];
+    const blockSize = 128;
+
     let coarse = parameters.coarse[0] ?? 0;
     coarse = Math.max(1, coarse);
-    return processSample(inputs, outputs, (block, n, inChannel, outChannel) => {
+
-      const value = n % coarse === 0 ? block : outChannel[n - 1];
+    if (input[0] == null || output[0] == null) {
-      return value;
+      return false;
-    });
+    }
+    for (let n = 0; n < blockSize; n++) {
+      for (let i = 0; i < input.length; i++) {
+        output[i][n] = n % coarse === 0 ? input[i][n] : output[i][n - 1];
+      }
+    }
+    return true;
   }
 }
-
 registerProcessor('coarse-processor', CoarseProcessor);
 
 class CrushProcessor extends AudioWorkletProcessor {
@@ -49,13 +41,23 @@ class CrushProcessor extends AudioWorkletProcessor {
   }
 
   process(inputs, outputs, parameters) {
+    const input = inputs[0];
+    const output = outputs[0];
+    const blockSize = 128;
+
     let crush = parameters.crush[0] ?? 8;
     crush = Math.max(1, crush);
 
-    return processSample(inputs, outputs, (block) => {
+    if (input[0] == null || output[0] == null) {
-      const x = Math.pow(2, crush - 1);
+      return false;
-      return Math.round(block * x) / x;
+    }
-    });
+    for (let n = 0; n < blockSize; n++) {
+      for (let i = 0; i < input.length; i++) {
+        const x = Math.pow(2, crush - 1);
+        output[i][n] = Math.round(input[i][n] * x) / x;
+      }
+    }
+    return true;
   }
 }
 registerProcessor('crush-processor', CrushProcessor);
@@ -73,17 +75,26 @@ class ShapeProcessor extends AudioWorkletProcessor {
   }
 
   process(inputs, outputs, parameters) {
+    const input = inputs[0];
+    const output = outputs[0];
+    const blockSize = 128;
+
     let shape = parameters.shape[0];
-    const postgain = Math.max(0.001, Math.min(1, parameters.postgain[0]));
     shape = shape < 1 ? shape : 1.0 - 4e-10;
     shape = (2.0 * shape) / (1.0 - shape);
-    return processSample(inputs, outputs, (block) => {
+    const postgain = Math.max(0.001, Math.min(1, parameters.postgain[0]));
-      const val = ((1 + shape) * block) / (1 + shape * Math.abs(block));
+
-      return val * postgain;
+    if (input[0] == null || output[0] == null) {
-    });
+      return false;
+    }
+    for (let n = 0; n < blockSize; n++) {
+      for (let i = 0; i < input.length; i++) {
+        output[i][n] = (((1 + shape) * input[i][n]) / (1 + shape * Math.abs(input[i][n]))) * postgain;
+      }
+    }
+    return true;
   }
 }
-
 registerProcessor('shape-processor', ShapeProcessor);
 
 class DistortProcessor extends AudioWorkletProcessor {
@@ -99,14 +110,22 @@ class DistortProcessor extends AudioWorkletProcessor {
   }
 
   process(inputs, outputs, parameters) {
-    let shape = parameters.distort[0];
+    const input = inputs[0];
+    const output = outputs[0];
+    const blockSize = 128;
+
+    const shape = Math.expm1(parameters.distort[0]);
     const postgain = Math.max(0.001, Math.min(1, parameters.postgain[0]));
-    shape = Math.expm1(shape);
+
-    return processSample(inputs, outputs, (block) => {
+    if (input[0] == null || output[0] == null) {
-      const val = ((1 + shape) * block) / (1 + shape * Math.abs(block));
+      return false;
-      return val * postgain;
+    }
-    });
+    for (let n = 0; n < blockSize; n++) {
+      for (let i = 0; i < input.length; i++) {
+        output[i][n] = (((1 + shape) * input[i][n]) / (1 + shape * Math.abs(input[i][n]))) * postgain;
+      }
+    }
+    return true;
   }
 }
-
 registerProcessor('distort-processor', DistortProcessor);