@tensamin/audio 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -0,0 +1,370 @@
+// 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;
+}
+
+// src/pipeline/audio-pipeline.ts
+import mitt from "mitt";
+
+// src/noise-suppression/rnnoise-node.ts
+import {
+  RnnoiseWorkletNode,
+  loadRnnoise
+} from "@sapphi-red/web-noise-suppressor";
+var DEFAULT_WASM_URL = "https://unpkg.com/@sapphi-red/web-noise-suppressor@0.3.5/dist/rnnoise.wasm";
+var DEFAULT_SIMD_WASM_URL = "https://unpkg.com/@sapphi-red/web-noise-suppressor@0.3.5/dist/rnnoise_simd.wasm";
+var DEFAULT_WORKLET_URL = "https://unpkg.com/@sapphi-red/web-noise-suppressor@0.3.5/dist/noise-suppressor-worklet.min.js";
+var RNNoisePlugin = class {
+  name = "rnnoise-ns";
+  wasmBuffer = null;
+  async createNode(context, config) {
+    if (!config?.enabled) {
+      const pass = context.createGain();
+      return pass;
+    }
+    if (!this.wasmBuffer) {
+      this.wasmBuffer = await loadRnnoise({
+        url: config.wasmUrl || DEFAULT_WASM_URL,
+        simdUrl: DEFAULT_SIMD_WASM_URL
+        // We should probably allow config for this too, but for now default is fine.
+      });
+    }
+    const workletUrl = config.workletUrl || DEFAULT_WORKLET_URL;
+    try {
+      await context.audioWorklet.addModule(workletUrl);
+    } catch (e) {
+      console.warn("Failed to add RNNoise worklet module:", e);
+    }
+    const node = new RnnoiseWorkletNode(context, {
+      wasmBinary: this.wasmBuffer,
+      maxChannels: 1
+      // Mono for now
+    });
+    return node;
+  }
+};
+
+// 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) {
+    const blob = new Blob([energyVadWorkletCode], {
+      type: "application/javascript"
+    });
+    const url = URL.createObjectURL(blob);
+    try {
+      await context.audioWorklet.addModule(url);
+    } catch (e) {
+      console.warn("Failed to add Energy VAD worklet:", e);
+      throw e;
+    } finally {
+      URL.revokeObjectURL(url);
+    }
+    const node = new AudioWorkletNode(context, "energy-vad-processor");
+    node.port.onmessage = (event) => {
+      const { probability } = event.data;
+      onDecision(probability);
+    };
+    return node;
+  }
+};
+
+// 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;
+}
+
+// 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
+    };
+  }
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  processFrame(probability, timestamp) {
+    const { startThreshold, stopThreshold, hangoverMs } = 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;
+      } else {
+        newState = "silent";
+      }
+    } else if (this.currentState === "speech_starting" || this.currentState === "speaking") {
+      if (probability >= stopThreshold) {
+        newState = "speaking";
+        this.lastSpeechTime = timestamp;
+      } else {
+        const timeSinceSpeech = timestamp - this.lastSpeechTime;
+        if (timeSinceSpeech < hangoverMs) {
+          newState = "speaking";
+        } else {
+          newState = "speech_ending";
+        }
+      }
+    }
+    if (newState === "speech_starting") newState = "speaking";
+    if (newState === "speech_ending") newState = "silent";
+    this.currentState = newState;
+    return {
+      isSpeaking: newState === "speaking",
+      probability,
+      state: newState
+    };
+  }
+};
+
+// src/pipeline/audio-pipeline.ts
+async function createAudioPipeline(sourceTrack, config = {}) {
+  const context = getAudioContext();
+  registerPipeline();
+  const fullConfig = {
+    noiseSuppression: { enabled: true, ...config.noiseSuppression },
+    vad: { enabled: true, ...config.vad },
+    output: {
+      speechGain: 1,
+      silenceGain: 0,
+      gainRampTime: 0.02,
+      ...config.output
+    },
+    livekit: { manageTrackMute: false, ...config.livekit }
+  };
+  const sourceStream = new MediaStream([sourceTrack]);
+  const sourceNode = context.createMediaStreamSource(sourceStream);
+  const nsPlugin = getNoiseSuppressionPlugin(
+    fullConfig.noiseSuppression?.pluginName
+  );
+  const nsNode = await nsPlugin.createNode(
+    context,
+    fullConfig.noiseSuppression
+  );
+  const vadPlugin = getVADPlugin(fullConfig.vad?.pluginName);
+  const vadStateMachine = new VADStateMachine(fullConfig.vad);
+  const emitter = mitt();
+  const vadNode = await vadPlugin.createNode(
+    context,
+    fullConfig.vad,
+    (prob) => {
+      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);
+      }
+    }
+  );
+  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();
+  splitter.connect(delayNode);
+  delayNode.connect(gainNode);
+  gainNode.connect(destination);
+  function updateGain(state) {
+    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);
+  }
+  function dispose() {
+    sourceNode.disconnect();
+    nsNode.disconnect();
+    splitter.disconnect();
+    vadNode.disconnect();
+    delayNode.disconnect();
+    gainNode.disconnect();
+    destination.stream.getTracks().forEach((t) => t.stop());
+    unregisterPipeline();
+  }
+  return {
+    processedTrack: destination.stream.getAudioTracks()[0],
+    events: emitter,
+    get state() {
+      return lastVadState;
+    },
+    setConfig: (newConfig) => {
+      if (newConfig.vad) {
+        vadStateMachine.updateConfig(newConfig.vad);
+      }
+    },
+    dispose
+  };
+}
+
+// src/livekit/integration.ts
+async function attachProcessingToTrack(track, config = {}) {
+  const originalTrack = track.mediaStreamTrack;
+  const pipeline = await createAudioPipeline(originalTrack, config);
+  await track.replaceTrack(pipeline.processedTrack);
+  if (config.livekit?.manageTrackMute) {
+    let isVadMuted = false;
+    pipeline.events.on("vadChange", async (state) => {
+      if (state.isSpeaking) {
+        if (isVadMuted) {
+          await track.unmute();
+          isVadMuted = false;
+        }
+      } else {
+        if (!track.isMuted) {
+          await track.mute();
+          isVadMuted = true;
+        }
+      }
+    });
+  }
+  const originalDispose = pipeline.dispose;
+  pipeline.dispose = () => {
+    if (originalTrack.readyState === "live") {
+      track.replaceTrack(originalTrack).catch(console.error);
+    }
+    originalDispose();
+  };
+  return pipeline;
+}
+export {
+  EnergyVADPlugin,
+  RNNoisePlugin,
+  VADStateMachine,
+  attachProcessingToTrack,
+  closeAudioContext,
+  createAudioPipeline,
+  getAudioContext,
+  getNoiseSuppressionPlugin,
+  getVADPlugin,
+  registerNoiseSuppressionPlugin,
+  registerPipeline,
+  registerVADPlugin,
+  resumeAudioContext,
+  suspendAudioContext,
+  unregisterPipeline
+};

package/package.json

@@ -1,35 +1,30 @@
 {
   "name": "@tensamin/audio",
-  "version": "0.1.0",
+  "version": "0.1.1",
+  "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
-  "type": "module",
   "author": {
     "email": "aloisianer@proton.me",
     "name": "Alois"
   },
   "publishConfig": {
-    "registry": "https://registry.npmjs.org",
     "access": "public"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/Tensamin/Audio"
   },
-  "exports": {
-    ".": {
-      "import": "./dist/index.mjs",
-      "types": "./dist/index.d.ts"
-    }
-  },
+  "license": "MIT",
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
-    "dev": "tsup src/index.ts --format esm --dts --watch",
-    "format": "bunx prettier --write ."
+    "build": "tsup src/index.ts --format cjs,esm --dts --out-dir dist --clean",
+    "format": "bunx prettier --write .",
+    "lint": "tsc"
   },
   "dependencies": {
     "@sapphi-red/web-noise-suppressor": "^0.3.5",
-    "mitt": "^3.0.1"
+    "mitt": "^3.0.1",
+    "tsup": "^8.5.1"
   },
   "peerDependencies": {
     "livekit-client": "^2.0.0"
@@ -38,7 +33,6 @@
     "@types/bun": "latest",
     "@types/web": "^0.0.298",
     "livekit-client": "^2.16.0",
-    "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   }
 }

package/tsconfig.json

@@ -1,29 +1,46 @@
 {
+  // Visit https://aka.ms/tsconfig to read more about this file
   "compilerOptions": {
-    // Environment setup & latest features
-    "lib": ["ESNext", "DOM", "DOM.Iterable"],
-    "target": "ESNext",
-    "module": "Preserve",
-    "moduleDetection": "force",
-    "jsx": "react-jsx",
-    "allowJs": true,
+    // File Layout
+    "rootDir": "./src",
+    "outDir": "./dist",
 
-    // Bundler mode
+    // Environment Settings
+    // See also https://aka.ms/tsconfig/module
     "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "noEmit": true,
+    "module": "esnext",
+    "target": "esnext",
+    "types": [],
+    // For nodejs:
+    // "lib": ["esnext"],
+    // "types": ["node"],
+    // and npm install -D @types/node
 
-    // Best practices
-    "strict": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
+    // Other Outputs
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+
+    // Stricter Typechecking Options
     "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
+    "exactOptionalPropertyTypes": true,
 
-    // Some stricter flags (disabled by default)
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
+    // Style Options
+    // "noImplicitReturns": true,
+    // "noImplicitOverride": true,
+    // "noUnusedLocals": true,
+    // "noUnusedParameters": true,
+    // "noFallthroughCasesInSwitch": true,
+    // "noPropertyAccessFromIndexSignature": true,
+
+    // Recommended Options
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+    "noEmit": true
   }
 }