@tensamin/audio 0.1.3 → 0.1.4

package/dist/pipeline/audio-pipeline.js

@@ -121,13 +121,25 @@ To disable noise suppression, set noiseSuppression.enabled to false.`
 };
 
 // src/vad/vad-node.ts
-var energyVadWorkletCode = `
+var createEnergyVadWorkletCode = (vadConfig) => {
+  const energyParams = vadConfig?.energyVad || {};
+  const smoothing = energyParams.smoothing ?? 0.95;
+  const initialNoiseFloor = energyParams.initialNoiseFloor ?? 1e-3;
+  const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 0.01;
+  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 1e-3;
+  const minSNR = energyParams.minSNR ?? 2;
+  const snrRange = energyParams.snrRange ?? 8;
+  return `
 class EnergyVadProcessor extends AudioWorkletProcessor {
   constructor() {
     super();
-    this.smoothing = 0.95;
+    this.smoothing = ${smoothing};
     this.energy = 0;
-    this.noiseFloor = 0.001;
+    this.noiseFloor = ${initialNoiseFloor};
+    this.noiseFloorAdaptRateQuiet = ${noiseFloorAdaptRateQuiet};
+    this.noiseFloorAdaptRateLoud = ${noiseFloorAdaptRateLoud};
+    this.minSNR = ${minSNR};
+    this.snrRange = ${snrRange};
   }
 
   process(inputs, outputs, parameters) {
@@ -135,32 +147,39 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     if (!input || !input.length) return true;
     const channel = input[0];
     
-    // Calculate RMS
+    // Calculate RMS (Root Mean Square) energy
     let sum = 0;
     for (let i = 0; i < channel.length; i++) {
       sum += channel[i] * channel[i];
     }
     const rms = Math.sqrt(sum / channel.length);
 
-    // Simple adaptive noise floor (very basic)
+    // Adaptive noise floor estimation
+    // When signal is quiet, adapt quickly to find new noise floor
+    // When signal is loud (speech), adapt slowly to avoid raising noise floor
     if (rms < this.noiseFloor) {
-      this.noiseFloor = this.noiseFloor * 0.99 + rms * 0.01;
+      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + rms * this.noiseFloorAdaptRateQuiet;
     } else {
-      this.noiseFloor = this.noiseFloor * 0.999 + rms * 0.001;
+      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + rms * this.noiseFloorAdaptRateLoud;
     }
 
-    // Calculate "probability" based on SNR
-    // This is a heuristic mapping from energy to 0-1
+    // Calculate Signal-to-Noise Ratio (SNR)
     const snr = rms / (this.noiseFloor + 1e-6);
-    const probability = Math.min(1, Math.max(0, (snr - 1.5) / 10)); // Arbitrary scaling
+    
+    // Map SNR to probability (0-1)
+    // Probability is 0 when SNR <= minSNR
+    // Probability scales linearly from 0 to 1 between minSNR and (minSNR + snrRange)
+    // Probability is 1 when SNR >= (minSNR + snrRange)
+    const probability = Math.min(1, Math.max(0, (snr - this.minSNR) / this.snrRange));
 
-    this.port.postMessage({ probability });
+    this.port.postMessage({ probability, snr, noiseFloor: this.noiseFloor, rms });
 
     return true;
   }
 }
 registerProcessor('energy-vad-processor', EnergyVadProcessor);
 `;
+};
 var EnergyVADPlugin = class {
   name = "energy-vad";
   async createNode(context, config, onDecision) {
@@ -169,7 +188,8 @@ var EnergyVADPlugin = class {
       const pass = context.createGain();
       return pass;
     }
-    const blob = new Blob([energyVadWorkletCode], {
+    const workletCode = createEnergyVadWorkletCode(config);
+    const blob = new Blob([workletCode], {
       type: "application/javascript"
     });
     const url = URL.createObjectURL(blob);
@@ -249,31 +269,60 @@ var VADStateMachine = class {
   currentState = "silent";
   lastSpeechTime = 0;
   speechStartTime = 0;
+  lastSilenceTime = 0;
   frameDurationMs = 20;
   // Assumed frame duration, updated by calls
   constructor(config) {
     this.config = {
       enabled: config?.enabled ?? true,
       pluginName: config?.pluginName ?? "energy-vad",
-      startThreshold: config?.startThreshold ?? 0.5,
-      stopThreshold: config?.stopThreshold ?? 0.4,
-      hangoverMs: config?.hangoverMs ?? 300,
-      preRollMs: config?.preRollMs ?? 200
+      // Voice-optimized defaults
+      startThreshold: config?.startThreshold ?? 0.6,
+      // Higher threshold to avoid noise
+      stopThreshold: config?.stopThreshold ?? 0.45,
+      // Balanced for voice
+      hangoverMs: config?.hangoverMs ?? 400,
+      // Smooth for natural speech
+      preRollMs: config?.preRollMs ?? 250,
+      // Generous pre-roll
+      minSpeechDurationMs: config?.minSpeechDurationMs ?? 100,
+      minSilenceDurationMs: config?.minSilenceDurationMs ?? 150,
+      energyVad: {
+        smoothing: config?.energyVad?.smoothing ?? 0.95,
+        initialNoiseFloor: config?.energyVad?.initialNoiseFloor ?? 1e-3,
+        noiseFloorAdaptRateQuiet: config?.energyVad?.noiseFloorAdaptRateQuiet ?? 0.01,
+        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 1e-3,
+        minSNR: config?.energyVad?.minSNR ?? 2,
+        snrRange: config?.energyVad?.snrRange ?? 8
+      }
     };
+    this.lastSilenceTime = Date.now();
   }
   updateConfig(config) {
     this.config = { ...this.config, ...config };
   }
   processFrame(probability, timestamp) {
-    const { startThreshold, stopThreshold, hangoverMs } = this.config;
+    const {
+      startThreshold,
+      stopThreshold,
+      hangoverMs,
+      minSpeechDurationMs,
+      minSilenceDurationMs
+    } = this.config;
     let newState = this.currentState;
     if (this.currentState === "silent" || this.currentState === "speech_ending") {
       if (probability >= startThreshold) {
-        newState = "speech_starting";
-        this.speechStartTime = timestamp;
-        this.lastSpeechTime = timestamp;
+        const silenceDuration = timestamp - this.lastSilenceTime;
+        if (silenceDuration >= minSilenceDurationMs) {
+          newState = "speech_starting";
+          this.speechStartTime = timestamp;
+          this.lastSpeechTime = timestamp;
+        } else {
+          newState = "silent";
+        }
       } else {
         newState = "silent";
+        this.lastSilenceTime = timestamp;
       }
     } else if (this.currentState === "speech_starting" || this.currentState === "speaking") {
       if (probability >= stopThreshold) {
@@ -281,10 +330,15 @@ var VADStateMachine = class {
         this.lastSpeechTime = timestamp;
       } else {
         const timeSinceSpeech = timestamp - this.lastSpeechTime;
+        const speechDuration = timestamp - this.speechStartTime;
         if (timeSinceSpeech < hangoverMs) {
           newState = "speaking";
+        } else if (speechDuration < minSpeechDurationMs) {
+          newState = "silent";
+          this.lastSilenceTime = timestamp;
         } else {
           newState = "speech_ending";
+          this.lastSilenceTime = timestamp;
         }
       }
     }
@@ -303,7 +357,9 @@ var VADStateMachine = class {
 async function createAudioPipeline(sourceTrack, config = {}) {
   const context = getAudioContext();
   registerPipeline();
-  const nsEnabled = config.noiseSuppression?.enabled !== false && Boolean(config.noiseSuppression?.wasmUrl && config.noiseSuppression?.simdUrl && config.noiseSuppression?.workletUrl);
+  const nsEnabled = config.noiseSuppression?.enabled !== false && Boolean(
+    config.noiseSuppression?.wasmUrl && config.noiseSuppression?.simdUrl && config.noiseSuppression?.workletUrl
+  );
   const vadEnabled = config.vad?.enabled !== false;
   const fullConfig = {
     noiseSuppression: {
@@ -312,13 +368,38 @@ async function createAudioPipeline(sourceTrack, config = {}) {
     },
     vad: {
       enabled: vadEnabled,
+      // Voice-optimized defaults (will be overridden by config)
+      startThreshold: 0.6,
+      stopThreshold: 0.45,
+      hangoverMs: 400,
+      preRollMs: 250,
+      minSpeechDurationMs: 100,
+      minSilenceDurationMs: 150,
+      energyVad: {
+        smoothing: 0.95,
+        initialNoiseFloor: 1e-3,
+        noiseFloorAdaptRateQuiet: 0.01,
+        noiseFloorAdaptRateLoud: 1e-3,
+        minSNR: 2,
+        snrRange: 8
+      },
       ...config.vad
     },
     output: {
       speechGain: 1,
-      silenceGain: vadEnabled ? 0 : 1,
-      // If no VAD, always output audio
-      gainRampTime: 0.02,
+      silenceGain: 0,
+      // Full mute for voice-only
+      gainRampTime: 0.015,
+      // Fast but smooth transitions
+      smoothTransitions: true,
+      maxGainDb: 6,
+      enableCompression: false,
+      compression: {
+        threshold: -24,
+        ratio: 3,
+        attack: 3e-3,
+        release: 0.05
+      },
       ...config.output
     },
     livekit: { manageTrackMute: false, ...config.livekit }
@@ -329,7 +410,9 @@ async function createAudioPipeline(sourceTrack, config = {}) {
     output: fullConfig.output
   });
   if (!sourceTrack || sourceTrack.kind !== "audio") {
-    throw new Error("createAudioPipeline requires a valid audio MediaStreamTrack");
+    throw new Error(
+      "createAudioPipeline requires a valid audio MediaStreamTrack"
+    );
   }
   if (sourceTrack.readyState === "ended") {
     throw new Error("Cannot create pipeline from an ended MediaStreamTrack");
@@ -343,10 +426,7 @@ async function createAudioPipeline(sourceTrack, config = {}) {
     const nsPlugin = getNoiseSuppressionPlugin(
       fullConfig.noiseSuppression?.pluginName
     );
-    nsNode = await nsPlugin.createNode(
-      context,
-      fullConfig.noiseSuppression
-    );
+    nsNode = await nsPlugin.createNode(context, fullConfig.noiseSuppression);
   } catch (error) {
     const err = error instanceof Error ? error : new Error(String(error));
     console.error("Failed to create noise suppression node:", err);
@@ -356,25 +436,21 @@ async function createAudioPipeline(sourceTrack, config = {}) {
   const vadStateMachine = new VADStateMachine(fullConfig.vad);
   try {
     const vadPlugin = getVADPlugin(fullConfig.vad?.pluginName);
-    vadNode = await vadPlugin.createNode(
-      context,
-      fullConfig.vad,
-      (prob) => {
-        try {
-          const timestamp = context.currentTime * 1e3;
-          const newState = vadStateMachine.processFrame(prob, timestamp);
-          if (newState.state !== lastVadState.state || Math.abs(newState.probability - lastVadState.probability) > 0.1) {
-            emitter.emit("vadChange", newState);
-            lastVadState = newState;
-            updateGain(newState);
-          }
-        } catch (vadError) {
-          const err = vadError instanceof Error ? vadError : new Error(String(vadError));
-          console.error("Error in VAD callback:", err);
-          emitter.emit("error", err);
+    vadNode = await vadPlugin.createNode(context, fullConfig.vad, (prob) => {
+      try {
+        const timestamp = context.currentTime * 1e3;
+        const newState = vadStateMachine.processFrame(prob, timestamp);
+        if (newState.state !== lastVadState.state || Math.abs(newState.probability - lastVadState.probability) > 0.1) {
+          emitter.emit("vadChange", newState);
+          lastVadState = newState;
+          updateGain(newState);
         }
+      } catch (vadError) {
+        const err = vadError instanceof Error ? vadError : new Error(String(vadError));
+        console.error("Error in VAD callback:", err);
+        emitter.emit("error", err);
       }
-    );
+    });
   } catch (error) {
     const err = error instanceof Error ? error : new Error(String(error));
     console.error("Failed to create VAD node:", err);
@@ -391,15 +467,31 @@ async function createAudioPipeline(sourceTrack, config = {}) {
   nsNode.connect(splitter);
   splitter.connect(vadNode);
   const delayNode = context.createDelay(1);
-  const preRollSeconds = (fullConfig.vad?.preRollMs ?? 200) / 1e3;
+  const preRollSeconds = (fullConfig.vad?.preRollMs ?? 250) / 1e3;
   delayNode.delayTime.value = preRollSeconds;
   const gainNode = context.createGain();
   gainNode.gain.value = fullConfig.output?.silenceGain ?? 0;
+  let compressor = null;
+  if (fullConfig.output?.enableCompression) {
+    compressor = context.createDynamicsCompressor();
+    const comp = fullConfig.output.compression;
+    compressor.threshold.value = comp.threshold ?? -24;
+    compressor.ratio.value = comp.ratio ?? 3;
+    compressor.attack.value = comp.attack ?? 3e-3;
+    compressor.release.value = comp.release ?? 0.05;
+    compressor.knee.value = 10;
+  }
   const destination = context.createMediaStreamDestination();
   try {
     splitter.connect(delayNode);
     delayNode.connect(gainNode);
-    gainNode.connect(destination);
+    if (compressor) {
+      gainNode.connect(compressor);
+      compressor.connect(destination);
+      console.log("Compression enabled:", fullConfig.output?.compression);
+    } else {
+      gainNode.connect(destination);
+    }
   } catch (error) {
     const err = error instanceof Error ? error : new Error(String(error));
     console.error("Failed to wire audio pipeline:", err);
@@ -408,10 +500,24 @@ async function createAudioPipeline(sourceTrack, config = {}) {
   }
   function updateGain(state) {
     try {
-      const { speechGain, silenceGain, gainRampTime } = fullConfig.output;
-      const targetGain = state.isSpeaking ? speechGain ?? 1 : silenceGain ?? 0;
+      const {
+        speechGain = 1,
+        silenceGain = 0,
+        gainRampTime = 0.015,
+        smoothTransitions = true,
+        maxGainDb = 6
+      } = fullConfig.output;
+      const maxGainLinear = Math.pow(10, maxGainDb / 20);
+      const limitedSpeechGain = Math.min(speechGain, maxGainLinear);
+      const targetGain = state.isSpeaking ? limitedSpeechGain : silenceGain;
       const now = context.currentTime;
-      gainNode.gain.setTargetAtTime(targetGain, now, gainRampTime ?? 0.02);
+      if (smoothTransitions) {
+        gainNode.gain.cancelScheduledValues(now);
+        gainNode.gain.setValueAtTime(gainNode.gain.value, now);
+        gainNode.gain.setTargetAtTime(targetGain, now, gainRampTime / 3);
+      } else {
+        gainNode.gain.setValueAtTime(targetGain, now);
+      }
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
       console.error("Failed to update gain:", err);
@@ -467,6 +573,9 @@ async function createAudioPipeline(sourceTrack, config = {}) {
       vadNode.disconnect();
       delayNode.disconnect();
       gainNode.disconnect();
+      if (compressor) {
+        compressor.disconnect();
+      }
       destination.stream.getTracks().forEach((t) => t.stop());
       unregisterPipeline();
     } catch (error) {
@@ -483,7 +592,47 @@ async function createAudioPipeline(sourceTrack, config = {}) {
       try {
         if (newConfig.vad) {
           vadStateMachine.updateConfig(newConfig.vad);
+          Object.assign(fullConfig.vad, newConfig.vad);
+          if (newConfig.vad.preRollMs !== void 0) {
+            const preRollSeconds2 = newConfig.vad.preRollMs / 1e3;
+            delayNode.delayTime.setValueAtTime(
+              preRollSeconds2,
+              context.currentTime
+            );
+          }
+        }
+        if (newConfig.output) {
+          Object.assign(fullConfig.output, newConfig.output);
+          updateGain(lastVadState);
+          if (compressor && newConfig.output.compression) {
+            const comp = newConfig.output.compression;
+            if (comp.threshold !== void 0) {
+              compressor.threshold.setValueAtTime(
+                comp.threshold,
+                context.currentTime
+              );
+            }
+            if (comp.ratio !== void 0) {
+              compressor.ratio.setValueAtTime(comp.ratio, context.currentTime);
+            }
+            if (comp.attack !== void 0) {
+              compressor.attack.setValueAtTime(
+                comp.attack,
+                context.currentTime
+              );
+            }
+            if (comp.release !== void 0) {
+              compressor.release.setValueAtTime(
+                comp.release,
+                context.currentTime
+              );
+            }
+          }
+        }
+        if (newConfig.livekit) {
+          Object.assign(fullConfig.livekit, newConfig.livekit);
         }
+        console.log("Pipeline config updated:", newConfig);
       } catch (error) {
         const err = error instanceof Error ? error : new Error(String(error));
         console.error("Failed to update config:", err);

package/dist/pipeline/audio-pipeline.mjs

@@ -1,11 +1,11 @@
 import {
   createAudioPipeline
-} from "../chunk-EXH2PNUE.mjs";
-import "../chunk-JJASCVEW.mjs";
+} from "../chunk-AHBRT4RD.mjs";
+import "../chunk-N553RHTI.mjs";
 import "../chunk-OZ7KMC4S.mjs";
-import "../chunk-6P2RDBW5.mjs";
+import "../chunk-YOSTLLCS.mjs";
 import "../chunk-XO6B3D4A.mjs";
-import "../chunk-R5JVHKWA.mjs";
+import "../chunk-NMHKX64G.mjs";
 export {
   createAudioPipeline
 };

package/dist/types.d.mts

@@ -35,46 +35,154 @@ interface AudioProcessingConfig {
     vad?: {
         enabled: boolean;
         /**
-         * Plugin name to use. Defaults to 'rnnoise-vad' or 'energy-vad'.
+         * Plugin name to use. Defaults to 'energy-vad'.
          */
         pluginName?: string;
         /**
          * Probability threshold for speech onset (0-1).
-         * Default: 0.5
+         * When VAD probability rises above this, audio is unmuted.
+         * Lower = more sensitive (catches quiet speech, may include noise)
+         * Higher = less sensitive (only confident speech, may clip quiet parts)
+         * Default: 0.6 (optimized for voice-only)
          */
         startThreshold?: number;
         /**
          * Probability threshold for speech offset (0-1).
-         * Default: 0.4
+         * When VAD probability drops below this (after hangover), audio is muted.
+         * Lower = keeps audio on longer (less aggressive gating)
+         * Higher = mutes faster (more aggressive noise suppression)
+         * Default: 0.45 (balanced voice detection)
          */
         stopThreshold?: number;
         /**
-         * Time in ms to wait after speech stops before considering it silent.
-         * Default: 300ms
+         * Time in ms to wait after speech stops before muting.
+         * Prevents rapid on/off toggling during pauses.
+         * Lower = more aggressive gating, may clip between words
+         * Higher = smoother but may let trailing noise through
+         * Default: 400ms (optimized for natural speech)
          */
         hangoverMs?: number;
         /**
-         * Time in ms of audio to buffer before speech onset to avoid cutting the start.
-         * Default: 200ms
+         * Time in ms of audio to buffer before speech onset.
+         * Prevents cutting off the beginning of speech.
+         * Default: 250ms (generous pre-roll for voice)
          */
         preRollMs?: number;
+        /**
+         * Minimum speech duration in ms to consider it valid speech.
+         * Filters out very brief noise spikes.
+         * Default: 100ms
+         */
+        minSpeechDurationMs?: number;
+        /**
+         * Minimum silence duration in ms before allowing another speech segment.
+         * Prevents false positives from quick noise bursts.
+         * Default: 150ms
+         */
+        minSilenceDurationMs?: number;
+        /**
+         * Advanced: Energy VAD specific parameters
+         */
+        energyVad?: {
+            /**
+             * Smoothing factor for energy calculation (0-1).
+             * Higher = more smoothing, slower to react
+             * Default: 0.95
+             */
+            smoothing?: number;
+            /**
+             * Initial noise floor estimate.
+             * Default: 0.001
+             */
+            initialNoiseFloor?: number;
+            /**
+             * Rate at which noise floor adapts to quiet signals (0-1).
+             * Default: 0.01
+             */
+            noiseFloorAdaptRateQuiet?: number;
+            /**
+             * Rate at which noise floor adapts to loud signals (0-1).
+             * Default: 0.001 (slower adaptation for speech)
+             */
+            noiseFloorAdaptRateLoud?: number;
+            /**
+             * Minimum SNR (Signal-to-Noise Ratio) for speech detection.
+             * Default: 2.0 (voice is 2x louder than noise floor)
+             */
+            minSNR?: number;
+            /**
+             * SNR range for probability scaling.
+             * Default: 8.0 (probability scales from minSNR to minSNR+snrRange)
+             */
+            snrRange?: number;
+        };
     };
     /**
      * Output gain and muting configuration.
      */
     output?: {
         /**
-         * Gain to apply when speaking (0-1+). Default: 1.0
+         * Gain to apply when speaking (0-infinity).
+         * Values > 1.0 will amplify the voice.
+         * Default: 1.0 (unity gain)
          */
         speechGain?: number;
         /**
-         * Gain to apply when silent (0-1). Default: 0.0 (mute)
+         * Gain to apply when silent (0-1).
+         * 0.0 = complete mute (recommended for voice-only)
+         * 0.1-0.3 = allow some background ambience
+         * Default: 0.0 (full mute for voice-only)
          */
         silenceGain?: number;
         /**
-         * Time in seconds to ramp gain changes. Default: 0.02
+         * Time in seconds to ramp gain changes.
+         * Lower = faster transitions (may cause clicks)
+         * Higher = smoother transitions (may sound sluggish)
+         * Default: 0.015 (fast but smooth for voice)
          */
         gainRampTime?: number;
+        /**
+         * Apply additional gain reduction during the transition to silence.
+         * Helps create cleaner cutoffs without abrupt clicks.
+         * Default: true
+         */
+        smoothTransitions?: boolean;
+        /**
+         * Maximum gain in dB to apply (prevents clipping).
+         * Default: 6.0 dB (roughly 2x amplitude)
+         */
+        maxGainDb?: number;
+        /**
+         * Apply dynamic range compression when speaking.
+         * Makes quiet parts louder and loud parts quieter.
+         * Default: false (transparent audio)
+         */
+        enableCompression?: boolean;
+        /**
+         * Compression settings (when enabled)
+         */
+        compression?: {
+            /**
+             * Threshold in dB above which compression starts.
+             * Default: -24.0 dB
+             */
+            threshold?: number;
+            /**
+             * Compression ratio (1:N).
+             * Default: 3.0 (3:1 ratio)
+             */
+            ratio?: number;
+            /**
+             * Attack time in seconds.
+             * Default: 0.003 (3ms)
+             */
+            attack?: number;
+            /**
+             * Release time in seconds.
+             * Default: 0.05 (50ms)
+             */
+            release?: number;
+        };
     };
     /**
      * LiveKit integration configuration.