@tensamin/audio 0.1.1 → 0.1.3

package/README.md

@@ -7,7 +7,7 @@ A audio processing library for the web, featuring RNNoise-based noise suppressio
 - **Noise Suppression**: Uses `@sapphi-red/web-noise-suppressor` (RNNoise) for high-quality noise reduction.
 - **Robust VAD**: Energy-based VAD with hysteresis, hangover, and pre-roll buffering to prevent cutting off speech onset.
 - **Intelligent Muting**: Automatically gates audio or mutes LiveKit tracks when silent.
-- **LiveKit Integration**: First-class support for `LocalAudioTrack`.
+- **LiveKit Integration**: Good support for `LocalAudioTrack`.
 - **Extensible**: Plugin system for custom WASM/Worklet processors.
 
 ## Installation
@@ -18,8 +18,45 @@ bun add @tensamin/audio livekit-client
 pnpm install @tensamin/audio livekit-client
 ```
 
+## Setup Assets
+
+This library uses WASM and AudioWorklets for processing. **Asset setup is optional** - the pipeline can run in passthrough mode without them.
+
+### For Noise Suppression (Optional)
+
+If you want to enable noise suppression, download these files from `https://unpkg.com/@sapphi-red/web-noise-suppressor@0.3.5/dist/`:
+
+- `rnnoise.wasm`
+- `rnnoise_simd.wasm`
+- `noise-suppressor-worklet.min.js`
+
+Place them in your project's public directory (e.g., `public/audio-processor/`).
+
+**Note:** The pipeline will automatically disable noise suppression if these URLs are not provided, and will use passthrough mode instead.
+
 ## Usage
 
+### Minimal Setup (Passthrough Mode)
+
+If you want to use the pipeline without noise suppression or VAD (e.g., for testing or when features are not needed), you can disable them:
+
+```ts
+import { createAudioPipeline } from "@tensamin/audio";
+
+// Get a stream
+const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+const track = stream.getAudioTracks()[0];
+
+// Create pipeline
+const pipeline = await createAudioPipeline(track, {
+  noiseSuppression: { enabled: false },
+  vad: { enabled: false },
+});
+
+// Use the processed track
+const processedStream = new MediaStream([pipeline.processedTrack]);
+```
+
 ### Basic Usage (Raw MediaStream)
 
 ```ts
@@ -31,7 +68,12 @@ const track = stream.getAudioTracks()[0];
 
 // Create pipeline
 const pipeline = await createAudioPipeline(track, {
-  noiseSuppression: { enabled: true },
+  noiseSuppression: {
+    enabled: true,
+    wasmUrl: "/audio-processor/rnnoise.wasm",
+    simdUrl: "/audio-processor/rnnoise_simd.wasm",
+    workletUrl: "/audio-processor/noise-suppressor-worklet.min.js",
+  },
   vad: { enabled: true },
 });
 
@@ -56,7 +98,12 @@ const localTrack = await LocalAudioTrack.create();
 
 // Attach processing (replaces the underlying track)
 const pipeline = await attachProcessingToTrack(localTrack, {
-  noiseSuppression: { enabled: true },
+  noiseSuppression: {
+    enabled: true,
+    wasmUrl: "/audio-processor/rnnoise.wasm",
+    simdUrl: "/audio-processor/rnnoise_simd.wasm",
+    workletUrl: "/audio-processor/noise-suppressor-worklet.min.js",
+  },
   vad: { enabled: true },
   livekit: { manageTrackMute: true }, // Optional: mute the track object itself
 });

package/dist/chunk-6P2RDBW5.mjs

@@ -0,0 +1,47 @@
+import {
+  RNNoisePlugin
+} from "./chunk-XO6B3D4A.mjs";
+import {
+  EnergyVADPlugin
+} from "./chunk-R5JVHKWA.mjs";
+
+// src/extensibility/plugins.ts
+var nsPlugins = /* @__PURE__ */ new Map();
+var vadPlugins = /* @__PURE__ */ new Map();
+var defaultNs = new RNNoisePlugin();
+nsPlugins.set(defaultNs.name, defaultNs);
+var defaultVad = new EnergyVADPlugin();
+vadPlugins.set(defaultVad.name, defaultVad);
+function registerNoiseSuppressionPlugin(plugin) {
+  nsPlugins.set(plugin.name, plugin);
+}
+function registerVADPlugin(plugin) {
+  vadPlugins.set(plugin.name, plugin);
+}
+function getNoiseSuppressionPlugin(name) {
+  if (!name) return defaultNs;
+  const plugin = nsPlugins.get(name);
+  if (!plugin) {
+    console.warn(
+      `Noise suppression plugin '${name}' not found, falling back to default.`
+    );
+    return defaultNs;
+  }
+  return plugin;
+}
+function getVADPlugin(name) {
+  if (!name) return defaultVad;
+  const plugin = vadPlugins.get(name);
+  if (!plugin) {
+    console.warn(`VAD plugin '${name}' not found, falling back to default.`);
+    return defaultVad;
+  }
+  return plugin;
+}
+
+export {
+  registerNoiseSuppressionPlugin,
+  registerVADPlugin,
+  getNoiseSuppressionPlugin,
+  getVADPlugin
+};

package/dist/chunk-EXH2PNUE.mjs

@@ -0,0 +1,212 @@
+import {
+  VADStateMachine
+} from "./chunk-JJASCVEW.mjs";
+import {
+  getAudioContext,
+  registerPipeline,
+  unregisterPipeline
+} from "./chunk-OZ7KMC4S.mjs";
+import {
+  getNoiseSuppressionPlugin,
+  getVADPlugin
+} from "./chunk-6P2RDBW5.mjs";
+
+// src/pipeline/audio-pipeline.ts
+import mitt from "mitt";
+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 vadEnabled = config.vad?.enabled !== false;
+  const fullConfig = {
+    noiseSuppression: {
+      enabled: nsEnabled,
+      ...config.noiseSuppression
+    },
+    vad: {
+      enabled: vadEnabled,
+      ...config.vad
+    },
+    output: {
+      speechGain: 1,
+      silenceGain: vadEnabled ? 0 : 1,
+      // If no VAD, always output audio
+      gainRampTime: 0.02,
+      ...config.output
+    },
+    livekit: { manageTrackMute: false, ...config.livekit }
+  };
+  console.log("Audio pipeline config:", {
+    noiseSuppression: fullConfig.noiseSuppression?.enabled,
+    vad: fullConfig.vad?.enabled,
+    output: fullConfig.output
+  });
+  if (!sourceTrack || sourceTrack.kind !== "audio") {
+    throw new Error("createAudioPipeline requires a valid audio MediaStreamTrack");
+  }
+  if (sourceTrack.readyState === "ended") {
+    throw new Error("Cannot create pipeline from an ended MediaStreamTrack");
+  }
+  const sourceStream = new MediaStream([sourceTrack]);
+  const sourceNode = context.createMediaStreamSource(sourceStream);
+  let nsNode;
+  let vadNode;
+  const emitter = mitt();
+  try {
+    const nsPlugin = getNoiseSuppressionPlugin(
+      fullConfig.noiseSuppression?.pluginName
+    );
+    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);
+    emitter.emit("error", err);
+    throw err;
+  }
+  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);
+        }
+      }
+    );
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    console.error("Failed to create VAD node:", err);
+    emitter.emit("error", err);
+    throw err;
+  }
+  let lastVadState = {
+    isSpeaking: false,
+    probability: 0,
+    state: "silent"
+  };
+  const splitter = context.createGain();
+  sourceNode.connect(nsNode);
+  nsNode.connect(splitter);
+  splitter.connect(vadNode);
+  const delayNode = context.createDelay(1);
+  const preRollSeconds = (fullConfig.vad?.preRollMs ?? 200) / 1e3;
+  delayNode.delayTime.value = preRollSeconds;
+  const gainNode = context.createGain();
+  gainNode.gain.value = fullConfig.output?.silenceGain ?? 0;
+  const destination = context.createMediaStreamDestination();
+  try {
+    splitter.connect(delayNode);
+    delayNode.connect(gainNode);
+    gainNode.connect(destination);
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    console.error("Failed to wire audio pipeline:", err);
+    emitter.emit("error", err);
+    throw err;
+  }
+  function updateGain(state) {
+    try {
+      const { speechGain, silenceGain, gainRampTime } = fullConfig.output;
+      const targetGain = state.isSpeaking ? speechGain ?? 1 : silenceGain ?? 0;
+      const now = context.currentTime;
+      gainNode.gain.setTargetAtTime(targetGain, now, gainRampTime ?? 0.02);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      console.error("Failed to update gain:", err);
+      emitter.emit("error", err);
+    }
+  }
+  const audioTracks = destination.stream.getAudioTracks();
+  console.log("Destination stream tracks:", {
+    count: audioTracks.length,
+    tracks: audioTracks.map((t) => ({
+      id: t.id,
+      label: t.label,
+      enabled: t.enabled,
+      readyState: t.readyState
+    }))
+  });
+  if (audioTracks.length === 0) {
+    const err = new Error(
+      "Failed to create processed audio track: destination stream has no audio tracks. This may indicate an issue with the audio graph connection."
+    );
+    console.error(err);
+    emitter.emit("error", err);
+    throw err;
+  }
+  const processedTrack = audioTracks[0];
+  if (!processedTrack || processedTrack.readyState === "ended") {
+    const err = new Error("Processed audio track is invalid or ended");
+    console.error(err);
+    emitter.emit("error", err);
+    throw err;
+  }
+  console.log("Audio pipeline created successfully:", {
+    sourceTrack: {
+      id: sourceTrack.id,
+      label: sourceTrack.label,
+      readyState: sourceTrack.readyState
+    },
+    processedTrack: {
+      id: processedTrack.id,
+      label: processedTrack.label,
+      readyState: processedTrack.readyState
+    },
+    config: {
+      noiseSuppression: fullConfig.noiseSuppression?.enabled,
+      vad: fullConfig.vad?.enabled
+    }
+  });
+  function dispose() {
+    try {
+      sourceNode.disconnect();
+      nsNode.disconnect();
+      splitter.disconnect();
+      vadNode.disconnect();
+      delayNode.disconnect();
+      gainNode.disconnect();
+      destination.stream.getTracks().forEach((t) => t.stop());
+      unregisterPipeline();
+    } catch (error) {
+      console.error("Error during pipeline disposal:", error);
+    }
+  }
+  return {
+    processedTrack,
+    events: emitter,
+    get state() {
+      return lastVadState;
+    },
+    setConfig: (newConfig) => {
+      try {
+        if (newConfig.vad) {
+          vadStateMachine.updateConfig(newConfig.vad);
+        }
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        console.error("Failed to update config:", err);
+        emitter.emit("error", err);
+      }
+    },
+    dispose
+  };
+}
+
+export {
+  createAudioPipeline
+};

package/{src/vad/vad-state.ts → dist/chunk-JJASCVEW.mjs}

@@ -1,36 +1,28 @@
-import type { AudioProcessingConfig, VADState } from "../types.js";
-
-export class VADStateMachine {
-  private config: Required<NonNullable<AudioProcessingConfig["vad"]>>;
-  private currentState: VADState["state"] = "silent";
-  private lastSpeechTime = 0;
-  private speechStartTime = 0;
-  private frameDurationMs = 20; // Assumed frame duration, updated by calls
-
-  constructor(config: AudioProcessingConfig["vad"]) {
+// src/vad/vad-state.ts
+var VADStateMachine = class {
+  config;
+  currentState = "silent";
+  lastSpeechTime = 0;
+  speechStartTime = 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,
+      preRollMs: config?.preRollMs ?? 200
     };
   }
-
-  updateConfig(config: Partial<AudioProcessingConfig["vad"]>) {
+  updateConfig(config) {
     this.config = { ...this.config, ...config };
   }
-
-  processFrame(probability: number, timestamp: number): VADState {
+  processFrame(probability, timestamp) {
     const { startThreshold, stopThreshold, hangoverMs } = this.config;
-
     let newState = this.currentState;
-
-    if (
-      this.currentState === "silent" ||
-      this.currentState === "speech_ending"
-    ) {
+    if (this.currentState === "silent" || this.currentState === "speech_ending") {
       if (probability >= startThreshold) {
         newState = "speech_starting";
         this.speechStartTime = timestamp;
@@ -38,34 +30,30 @@ export class VADStateMachine {
       } else {
         newState = "silent";
       }
-    } else if (
-      this.currentState === "speech_starting" ||
-      this.currentState === "speaking"
-    ) {
+    } else if (this.currentState === "speech_starting" || this.currentState === "speaking") {
       if (probability >= stopThreshold) {
         newState = "speaking";
         this.lastSpeechTime = timestamp;
       } else {
-        // Check hangover
         const timeSinceSpeech = timestamp - this.lastSpeechTime;
         if (timeSinceSpeech < hangoverMs) {
-          newState = "speaking"; // Still in hangover
+          newState = "speaking";
         } else {
           newState = "speech_ending";
         }
       }
     }
-
-    // Transition from starting/ending to stable states
     if (newState === "speech_starting") newState = "speaking";
     if (newState === "speech_ending") newState = "silent";
-
     this.currentState = newState;
-
     return {
       isSpeaking: newState === "speaking",
       probability,
-      state: newState,
+      state: newState
     };
   }
-}
+};
+
+export {
+  VADStateMachine
+};

package/dist/chunk-OZ7KMC4S.mjs

@@ -0,0 +1,46 @@
+// src/context/audio-context.ts
+var sharedContext = null;
+var activePipelines = 0;
+function getAudioContext(options) {
+  if (typeof window === "undefined" || typeof AudioContext === "undefined") {
+    throw new Error(
+      "AudioContext is not supported in this environment (browser only)."
+    );
+  }
+  if (!sharedContext || sharedContext.state === "closed") {
+    sharedContext = new AudioContext(options);
+  }
+  return sharedContext;
+}
+function registerPipeline() {
+  activePipelines++;
+}
+function unregisterPipeline() {
+  activePipelines = Math.max(0, activePipelines - 1);
+}
+async function resumeAudioContext() {
+  if (sharedContext && sharedContext.state === "suspended") {
+    await sharedContext.resume();
+  }
+}
+async function suspendAudioContext() {
+  if (sharedContext && sharedContext.state === "running") {
+    await sharedContext.suspend();
+  }
+}
+async function closeAudioContext() {
+  if (sharedContext && sharedContext.state !== "closed") {
+    await sharedContext.close();
+  }
+  sharedContext = null;
+  activePipelines = 0;
+}
+
+export {
+  getAudioContext,
+  registerPipeline,
+  unregisterPipeline,
+  resumeAudioContext,
+  suspendAudioContext,
+  closeAudioContext
+};

package/dist/chunk-R5JVHKWA.mjs

@@ -0,0 +1,98 @@
+// src/vad/vad-node.ts
+var energyVadWorkletCode = `
+class EnergyVadProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.smoothing = 0.95;
+    this.energy = 0;
+    this.noiseFloor = 0.001;
+  }
+
+  process(inputs, outputs, parameters) {
+    const input = inputs[0];
+    if (!input || !input.length) return true;
+    const channel = input[0];
+    
+    // Calculate RMS
+    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)
+    if (rms < this.noiseFloor) {
+      this.noiseFloor = this.noiseFloor * 0.99 + rms * 0.01;
+    } else {
+      this.noiseFloor = this.noiseFloor * 0.999 + rms * 0.001;
+    }
+
+    // Calculate "probability" based on SNR
+    // This is a heuristic mapping from energy to 0-1
+    const snr = rms / (this.noiseFloor + 1e-6);
+    const probability = Math.min(1, Math.max(0, (snr - 1.5) / 10)); // Arbitrary scaling
+
+    this.port.postMessage({ probability });
+
+    return true;
+  }
+}
+registerProcessor('energy-vad-processor', EnergyVadProcessor);
+`;
+var EnergyVADPlugin = class {
+  name = "energy-vad";
+  async createNode(context, config, onDecision) {
+    if (!config?.enabled) {
+      console.log("VAD disabled, using passthrough node");
+      const pass = context.createGain();
+      return pass;
+    }
+    const blob = new Blob([energyVadWorkletCode], {
+      type: "application/javascript"
+    });
+    const url = URL.createObjectURL(blob);
+    try {
+      await context.audioWorklet.addModule(url);
+      console.log("Energy VAD worklet loaded successfully");
+    } catch (e) {
+      const error = new Error(
+        `Failed to load Energy VAD worklet: ${e instanceof Error ? e.message : String(e)}`
+      );
+      console.error(error.message);
+      URL.revokeObjectURL(url);
+      throw error;
+    }
+    URL.revokeObjectURL(url);
+    let node;
+    try {
+      node = new AudioWorkletNode(context, "energy-vad-processor");
+      console.log("Energy VAD node created successfully");
+    } catch (e) {
+      const error = new Error(
+        `Failed to create Energy VAD node: ${e instanceof Error ? e.message : String(e)}`
+      );
+      console.error(error.message);
+      throw error;
+    }
+    node.port.onmessage = (event) => {
+      try {
+        const { probability } = event.data;
+        if (typeof probability === "number" && !isNaN(probability)) {
+          onDecision(probability);
+        } else {
+          console.warn("Invalid VAD probability received:", event.data);
+        }
+      } catch (error) {
+        console.error("Error in VAD message handler:", error);
+      }
+    };
+    node.port.onmessageerror = (event) => {
+      console.error("VAD port message error:", event);
+    };
+    return node;
+  }
+};
+
+export {
+  EnergyVADPlugin
+};

package/dist/chunk-XMTQPMQ6.mjs

@@ -0,0 +1,91 @@
+import {
+  createAudioPipeline
+} from "./chunk-EXH2PNUE.mjs";
+
+// src/livekit/integration.ts
+async function attachProcessingToTrack(track, config = {}) {
+  if (!track) {
+    throw new Error("attachProcessingToTrack requires a valid LocalAudioTrack");
+  }
+  const originalTrack = track.mediaStreamTrack;
+  if (!originalTrack) {
+    throw new Error("LocalAudioTrack has no underlying MediaStreamTrack");
+  }
+  if (originalTrack.readyState === "ended") {
+    throw new Error("Cannot attach processing to an ended MediaStreamTrack");
+  }
+  let pipeline;
+  try {
+    console.log("Creating audio processing pipeline...");
+    pipeline = await createAudioPipeline(originalTrack, config);
+    console.log("Audio processing pipeline created successfully");
+  } catch (error) {
+    const err = new Error(
+      `Failed to create audio pipeline: ${error instanceof Error ? error.message : String(error)}`
+    );
+    console.error(err);
+    throw err;
+  }
+  if (!pipeline.processedTrack) {
+    throw new Error("Pipeline did not return a processed track");
+  }
+  try {
+    console.log("Replacing LiveKit track with processed track...");
+    await track.replaceTrack(pipeline.processedTrack);
+    console.log("LiveKit track replaced successfully");
+  } catch (error) {
+    pipeline.dispose();
+    const err = new Error(
+      `Failed to replace LiveKit track: ${error instanceof Error ? error.message : String(error)}`
+    );
+    console.error(err);
+    throw err;
+  }
+  if (config.livekit?.manageTrackMute) {
+    let isVadMuted = false;
+    pipeline.events.on("vadChange", async (state) => {
+      try {
+        if (state.isSpeaking) {
+          if (isVadMuted) {
+            await track.unmute();
+            isVadMuted = false;
+          }
+        } else {
+          if (!track.isMuted) {
+            await track.mute();
+            isVadMuted = true;
+          }
+        }
+      } catch (error) {
+        console.error("Error handling VAD-based track muting:", error);
+      }
+    });
+  }
+  pipeline.events.on("error", (error) => {
+    console.error("Audio pipeline error:", error);
+  });
+  const originalDispose = pipeline.dispose;
+  pipeline.dispose = () => {
+    try {
+      if (originalTrack.readyState === "live") {
+        console.log("Restoring original track...");
+        track.replaceTrack(originalTrack).catch((error) => {
+          console.error("Failed to restore original track:", error);
+        });
+      }
+      originalDispose();
+    } catch (error) {
+      console.error("Error during pipeline disposal:", error);
+      try {
+        originalDispose();
+      } catch (disposeError) {
+        console.error("Error calling original dispose:", disposeError);
+      }
+    }
+  };
+  return pipeline;
+}
+
+export {
+  attachProcessingToTrack
+};