videosdk-plugins-rnnoise-dev 0.0.63.dev0__py3-none-any.whl

videosdk/plugins/rnnoise/__init__.py

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

videosdk/plugins/rnnoise/build_rnnoise.py

@@ -0,0 +1,126 @@
+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():
+    # Force Linux detection when running in Docker
+    if os.path.exists("/.dockerenv") or os.environ.get("DOCKER_CONTAINER"):
+        os_sys = "Linux"
+    else:
+        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"
+            
+            # Force Linux .so file when running in Docker container
+            if os.path.exists("/.dockerenv") or os.environ.get("DOCKER_CONTAINER"):
+                lib_file = "librnnoise.so"
+                print(f"🔧 Docker detected, forcing .so file: {lib_file}")
+            else:
+                lib_file = "librnnoise.dylib" if os_sys == "Darwin" else "librnnoise.so"
+                print(f"🔧 Host system detected: {os_sys}, using: {lib_file}")
+            
+            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)
+        
+        # Force .so files when running in Docker
+        if os.path.exists("/.dockerenv") or os.environ.get("DOCKER_CONTAINER"):
+            # Look for shared library specifically
+            shared_lib = os.path.join(lib_dir, "librnnoise.so")
+            static_lib = os.path.join(lib_dir, "librnnoise.a")
+            
+            if os.path.exists(shared_lib):
+                source_lib = shared_lib
+                print(f"🔧 Found shared library: {source_lib}")
+            elif os.path.exists(static_lib):
+                # If no shared library, create one from static library
+                print(f"🔧 Creating shared library from static library")
+                # Extract object files from static library
+                run_subprocess(["ar", "-x", static_lib])
+                # Create shared library from object files
+                obj_files = [f for f in os.listdir(".") if f.endswith(".o")]
+                run_subprocess(["gcc", "-shared", "-o", shared_lib] + obj_files + ["-lm"])
+                source_lib = shared_lib
+            else:
+                raise FileNotFoundError(f"No librnnoise library found in {lib_dir}")
+            
+            target_lib = os.path.join(target_dir, "librnnoise.so")
+            shutil.copy(source_lib, target_lib)
+            print(f"🔧 Copied {source_lib} to {target_lib}")
+            
+            # Also create a symlink for compatibility
+            symlink_path = os.path.join(target_dir, "librnnoise.dylib")
+            if os.path.exists(symlink_path):
+                os.remove(symlink_path)
+            os.symlink("librnnoise.so", symlink_path)
+            print(f"🔧 Created symlink: librnnoise.dylib -> librnnoise.so")
+            
+            # Copy to the mounted volume location
+            mounted_target = "/output/librnnoise.so"
+            shutil.copy(source_lib, mounted_target)
+            print(f"🔧 Copied to mounted volume: {mounted_target}")
+        else:
+            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/denoise.py

@@ -0,0 +1,62 @@
+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):
+        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/rnnoise.py

@@ -0,0 +1,77 @@
+import ctypes
+import numpy as np
+import 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
+
+# Define the correct function signatures
+lib.rnnoise_create.argtypes = [ctypes.c_void_p]  # RNNModel *model (can be NULL)
+lib.rnnoise_create.restype = ctypes.c_void_p
+lib.rnnoise_destroy.argtypes = [ctypes.c_void_p]
+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
+
+class RNN(object):
+	def __init__(self):
+		# Pass NULL (None) for the model parameter to use the default model
+		self.obj = lib.rnnoise_create(None)
+		if self.obj is None:
+			raise RuntimeError("Failed to create RNNoise instance")
+	
+	def process_frame(self, inbuf):
+		# Create a copy of the input buffer to avoid modifying the original
+		if isinstance(inbuf, bytes):
+			# Convert bytes to numpy array
+			audio_data = np.frombuffer(inbuf, dtype=np.int16)
+		else:
+			audio_data = np.array(inbuf, dtype=np.int16)
+		
+		# Ensure we have exactly 480 samples
+		if len(audio_data) != 480:
+			raise ValueError(f"Expected 480 samples, got {len(audio_data)}")
+		
+		# Convert to float32 and normalize
+		audio_float = audio_data.astype(np.float32) / 32767.0
+		
+		# Create output buffer
+		outbuf = np.zeros(480, dtype=np.float32)
+		
+		# Get pointers
+		in_ptr = audio_float.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
+		out_ptr = outbuf.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
+		
+		# Process the frame
+		VodProb = lib.rnnoise_process_frame(self.obj, out_ptr, in_ptr)
+		
+		# Convert back to int16
+		outbuf_int16 = (outbuf * 32767.0).astype(np.int16)
+		
+		return (VodProb, outbuf_int16.tobytes())
+
+	def destroy(self):
+		if self.obj is not None:
+			lib.rnnoise_destroy(self.obj)
+			self.obj = None

videosdk/plugins/rnnoise/version.py

@@ -0,0 +1 @@
+__version__ = "0.0.63.dev0"

videosdk_plugins_rnnoise_dev-0.0.63.dev0.dist-info/METADATA

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: videosdk-plugins-rnnoise-dev
+Version: 0.0.63.dev0
+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.26
+Requires-Dist: resampy
+Requires-Dist: videosdk-agents>=0.0.22
+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_dev-0.0.63.dev0.dist-info/RECORD

@@ -0,0 +1,11 @@
+videosdk/plugins/rnnoise/__init__.py,sha256=W1ioncb06WtjaxKXUuhQMsr6JHZmNTPeUOXqnRkQiuw,51
+videosdk/plugins/rnnoise/build_rnnoise.py,sha256=zzyoYX04IzHs8TWq_cEwVAbW8www20oe8ldAtGtXPWU,6004
+videosdk/plugins/rnnoise/denoise.py,sha256=t0Y8SjdRE2iVlrP3gfwmD_ArXwcBLBCi1V9-JryBJFI,2385
+videosdk/plugins/rnnoise/rnnoise.py,sha256=tzANc9FmNYaalcnhYwaQGVZPKTc4xBfwDAtXkPD0Bu8,2366
+videosdk/plugins/rnnoise/version.py,sha256=Q_1rx0vr-H8kMoyc5VNkl0Tdt8P1PyFB_NoS6uiUC9g,27
+videosdk/plugins/rnnoise/files/librnnoise.0.dylib,sha256=dQMzNPgGtW4QRECenEZi6LKvFYTSzZlgNYivy1taNGI,1048576
+videosdk/plugins/rnnoise/files/librnnoise.dylib,sha256=dQMzNPgGtW4QRECenEZi6LKvFYTSzZlgNYivy1taNGI,1048576
+videosdk/plugins/rnnoise/files/librnnoise.so,sha256=dpC40omPtQ5kr8Q6eiif8OkWVaz7DEpE2jhsGv76L9U,1048576
+videosdk_plugins_rnnoise_dev-0.0.63.dev0.dist-info/METADATA,sha256=RVFg8_MTthzbVvMZHjdbIsVIu2W32yAWuZ-C2xmhJ9o,1201
+videosdk_plugins_rnnoise_dev-0.0.63.dev0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+videosdk_plugins_rnnoise_dev-0.0.63.dev0.dist-info/RECORD,,

videosdk_plugins_rnnoise_dev-0.0.63.dev0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any