videosdk-plugins-rnnoise 0.0.47__tar.gz

videosdk_plugins_rnnoise-0.0.47/.gitignore

@@ -0,0 +1,19 @@
+myenv/
+venv/
+env/
+__pycache__/
+.venv/
+.env
+.env.local
+test_env/
+dist/
+.DS_Store
+node_modules/
+credentials.json
+.Python
+build/
+eggs/
+sdist/
+wheels/
+docs/
+agent-sdk-reference/

videosdk_plugins_rnnoise-0.0.47/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: videosdk-plugins-rnnoise
+Version: 0.0.47
+Summary: VideoSDK Agent Framework plugin for RNNoise.
+Author: videosdk
+License-Expression: Apache-2.0
+Keywords: ai,audio,lmnt,rime,tts,video,videosdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Communications :: Conferencing
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Requires-Dist: numpy>=1.27
+Requires-Dist: resampy
+Requires-Dist: videosdk-agents>=0.0.47
+Description-Content-Type: text/markdown
+
+# VideoSDK RNNoise Plugin
+
+Agent Framework plugin for de-noising with RNNoise.
+
+## Installation
+
+```bash
+pip install videosdk-plugins-rnnoise
+```
+
+## Building RNNoise for your OS
+
+To avoid OS security issues with prebuilt libraries, build RNNoise locally:
+1. Ensure you have git and build tools (autoconf/make on Mac/Linux, Visual Studio with nmake on Windows).
+2. Run `python build_rnnoise.py` in the project root.
+3. This clones RNNoise, builds the library for your OS, and places it in videosdk/plugins/rnnoise/files/.

videosdk_plugins_rnnoise-0.0.47/README.md

@@ -0,0 +1,16 @@
+# VideoSDK RNNoise Plugin
+
+Agent Framework plugin for de-noising with RNNoise.
+
+## Installation
+
+```bash
+pip install videosdk-plugins-rnnoise
+```
+
+## Building RNNoise for your OS
+
+To avoid OS security issues with prebuilt libraries, build RNNoise locally:
+1. Ensure you have git and build tools (autoconf/make on Mac/Linux, Visual Studio with nmake on Windows).
+2. Run `python build_rnnoise.py` in the project root.
+3. This clones RNNoise, builds the library for your OS, and places it in videosdk/plugins/rnnoise/files/.

videosdk_plugins_rnnoise-0.0.47/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "videosdk-plugins-rnnoise"
+dynamic = ["version"]
+description = "VideoSDK Agent Framework plugin for RNNoise."
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.11"
+authors = [{ name = "videosdk" }]
+keywords = ["video", "audio", "ai", "lmnt", "tts", "videosdk", "rime"]
+classifiers = [
+    "Intended Audience :: Developers",
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Communications :: Conferencing",
+    "Topic :: Multimedia :: Sound/Audio",
+    "Topic :: Multimedia :: Video",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = ["videosdk-agents>=0.0.47", "resampy", "numpy>=1.27"]
+
+[tool.hatch.version]
+path = "videosdk/plugins/rnnoise/version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["videosdk"]
+
+[tool.hatch.build.targets.sdist]
+include = ["/videosdk"]

videosdk_plugins_rnnoise-0.0.47/videosdk/plugins/rnnoise/__init__.py

@@ -0,0 +1,3 @@
+from .denoise import RNNoise
+
+__all__ = ["RNNoise"]

videosdk_plugins_rnnoise-0.0.47/videosdk/plugins/rnnoise/build_rnnoise.py

@@ -0,0 +1,76 @@
+import os
+import platform
+import subprocess
+import shutil
+import tempfile
+
+import sys
+from shutil import which
+
+def check_command(cmd, install_tip):
+    if not which(cmd):
+        raise EnvironmentError(f"{cmd} not found. Install it: {install_tip}")
+
+def run_subprocess(cmd, cwd=None):
+    print(f"Running: {' '.join(cmd)}")
+    try:
+        result = subprocess.run(cmd, cwd=cwd, check=True, capture_output=True, text=True)
+        print(result.stdout)
+        if result.stderr:
+            print(f"Warnings/Errors: {result.stderr}")
+        return result
+    except subprocess.CalledProcessError as e:
+        print(f"Command failed with code {e.returncode}: {e.stderr}")
+        raise
+
+def build_rnnoise():
+    os_sys = platform.system()
+    repo_url = "https://github.com/xiph/rnnoise.git"
+    
+    git_tip = "Install git (e.g., apt install git on Debian/Ubuntu, brew install git on macOS, or Chocolatey on Windows)."
+    check_command("git", git_tip)
+    
+    with tempfile.TemporaryDirectory() as tmpdir:
+        run_subprocess(["git", "clone", repo_url, tmpdir])
+        os.chdir(tmpdir)
+        if os_sys == "Darwin" or os_sys == "Linux":
+            # Check required Unix build tools
+            unix_tip = "Install build tools (e.g., apt install build-essential autoconf automake libtool on Debian/Ubuntu; brew install autoconf automake libtool on macOS)."
+            for tool in ["autoconf", "automake", "libtool", "make"]:
+                check_command(tool, unix_tip)
+            
+            # Generate build files and compile
+            run_subprocess(["./autogen.sh"])
+            run_subprocess(["./configure"])
+            run_subprocess(["make"])
+            lib_dir = ".libs"
+            lib_file = "librnnoise.dylib" if os_sys == "Darwin" else "librnnoise.so"
+            built_lib = os.path.join(lib_dir, lib_file)
+        elif os_sys == "Windows":
+            # Check nmake for Visual Studio-based build
+            nmake_tip = "Install Visual Studio (community edition) and run this script from Developer Command Prompt. Alternatively, use MSYS2 (install via https://www.msys2.org/) and run make in the repo."
+            check_command("nmake", nmake_tip)
+            
+            os.chdir("msvc")
+            # Assumes Visual Studio is installed; run from Developer Command Prompt if needed
+            run_subprocess(["nmake", "/f", "Makefile.ms"])
+            built_lib = "rnnoise.dll"  # Adjust if name differs after build
+        else:
+            raise ValueError(f"Unsupported OS: {os_sys}. Manual build required (clone repo and follow README).")
+        
+        if not os.path.exists(built_lib):
+            raise FileNotFoundError(f"Build failed: {built_lib} not found. Ensure build tools are installed and environment is set up (e.g., in containers, add tools via Dockerfile/package manager).")
+        
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        target_dir = os.path.join(script_dir, "files")
+        os.makedirs(target_dir, exist_ok=True)
+        shutil.copy(built_lib, os.path.join(target_dir, os.path.basename(built_lib)))
+
+if __name__ == "__main__":
+    try:
+        build_rnnoise()
+        print("RNNoise library built successfully for your OS.")
+    except Exception as e:
+        print(f"Build failed: {e}")
+        print("If in a container/cloud/terminal, ensure tools are installed (e.g., via apt/brew/Chocolatey) or build manually per RNNoise README: https://github.com/xiph/rnnoise")
+        sys.exit(1)

videosdk_plugins_rnnoise-0.0.47/videosdk/plugins/rnnoise/denoise.py

@@ -0,0 +1,72 @@
+from typing import Any
+from videosdk.agents.denoise import Denoise
+from .rnnoise import RNN
+import numpy as np
+import resampy
+
+
+class RNNoise(Denoise):
+    def __init__(self):
+        """Initialize the RNNoise denoise plugin.
+        """
+        super().__init__()
+        self.rnnoise = RNN()
+        self._target_sample_rate = 48000
+        self._frame_duration_ms = 20
+        self._rnnoise_frame_size = 480
+
+    async def denoise(self, audio_frames: bytes, **kwargs: Any) -> bytes:
+        if not audio_frames:
+            return b""
+
+        audio_np = np.frombuffer(audio_frames, dtype=np.int16)
+        num_samples = len(audio_np)
+        original_sample_rate = int(
+            num_samples * 1000 / self._frame_duration_ms)
+
+        if original_sample_rate != self._target_sample_rate:
+            audio_float = audio_np.astype(np.float32) / 32767.0
+            resampled_audio_float = resampy.resample(
+                audio_float, sr_orig=original_sample_rate, sr_new=self._target_sample_rate)
+            resampled_audio_np = (resampled_audio_float *
+                                  32767.0).astype(np.int16)
+        else:
+            resampled_audio_np = audio_np
+
+        num_rnnoise_frames = len(
+            resampled_audio_np) // self._rnnoise_frame_size
+        denoised_chunks = []
+
+        for i in range(num_rnnoise_frames):
+            start = i * self._rnnoise_frame_size
+            end = start + self._rnnoise_frame_size
+            chunk = resampled_audio_np[start:end]
+
+            if len(chunk) != self._rnnoise_frame_size:
+                continue
+
+            chunk_bytes = chunk.tobytes()
+            _vod_prob, denoised_chunk_bytes = self.rnnoise.process_frame(
+                chunk_bytes)
+            denoised_chunk_np = np.frombuffer(
+                denoised_chunk_bytes, dtype=np.int16)
+            denoised_chunks.append(denoised_chunk_np)
+
+        if not denoised_chunks:
+            return b""
+
+        denoised_audio_np = np.concatenate(denoised_chunks)
+
+        if original_sample_rate != self._target_sample_rate:
+            denoised_float = denoised_audio_np.astype(np.float32) / 32767.0
+            original_format_float = resampy.resample(
+                denoised_float, sr_orig=self._target_sample_rate, sr_new=original_sample_rate)
+            final_audio_np = (original_format_float * 32767.0).astype(np.int16)
+        else:
+            final_audio_np = denoised_audio_np
+
+        return final_audio_np.tobytes()
+
+    async def aclose(self) -> None:
+        self.rnnoise.destroy()
+        await super().aclose()

videosdk_plugins_rnnoise-0.0.47/videosdk/plugins/rnnoise/files/librnnoise.dylib

@@ -0,0 +1 @@
+librnnoise.0.dylib

videosdk_plugins_rnnoise-0.0.47/videosdk/plugins/rnnoise/rnnoise.py

@@ -0,0 +1,43 @@
+import ctypes,numpy,os
+import platform
+
+script_dir = os.path.dirname(os.path.abspath(__file__))
+
+
+sys_name = platform.system()
+if sys_name == "Darwin":
+    lib_name = "librnnoise.dylib"
+elif sys_name == "Linux":
+    lib_name = "librnnoise.so"
+elif sys_name == "Windows":
+    lib_name = "rnnoise.dll"
+else:
+    raise OSError(f"Unsupported OS: {sys_name}")
+
+lib_path = os.path.join(script_dir, "files", lib_name)
+
+try:
+    lib = ctypes.cdll.LoadLibrary(lib_path)
+except OSError as e:
+    raise OSError(
+        f"Error loading rnnoise library at {lib_path}. "
+        f"It may be corrupted or incompatible with your platform. "
+        f"Original error: {e}"
+    ) from e
+
+lib.rnnoise_process_frame.argtypes = [ctypes.c_void_p,ctypes.POINTER(ctypes.c_float),ctypes.POINTER(ctypes.c_float)]
+lib.rnnoise_process_frame.restype = ctypes.c_float
+lib.rnnoise_create.restype = ctypes.c_void_p
+lib.rnnoise_destroy.argtypes = [ctypes.c_void_p]
+
+class RNN(object):
+	def __init__(self):
+		self.obj = lib.rnnoise_create()
+	def process_frame(self,inbuf):
+		outbuf = numpy.ndarray((480,), 'h', inbuf).astype(ctypes.c_float)
+		outbuf_ptr = outbuf.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
+		VodProb =  lib.rnnoise_process_frame(self.obj,outbuf_ptr,outbuf_ptr)
+		return (VodProb,outbuf.astype(ctypes.c_short).tobytes())
+
+	def destroy(self):
+		lib.rnnoise_destroy(self.obj)

videosdk_plugins_rnnoise-0.0.47/videosdk/plugins/rnnoise/version.py

@@ -0,0 +1 @@
+__version__ = "0.0.47"