videosdk-plugins-rnnoise-dev 0.0.63.dev0__tar.gz → 0.0.63.dev2__tar.gz

{videosdk_plugins_rnnoise_dev-0.0.63.dev0 → videosdk_plugins_rnnoise_dev-0.0.63.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: videosdk-plugins-rnnoise-dev
-Version: 0.0.63.dev0
+Version: 0.0.63.dev2
 Summary: VideoSDK Agent Framework plugin for RNNoise.
 Author: videosdk
 License-Expression: Apache-2.0
@@ -12,9 +12,9 @@ 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: numpy>=1.27
 Requires-Dist: resampy
-Requires-Dist: videosdk-agents>=0.0.22
+Requires-Dist: videosdk-agents>=0.0.62
 Description-Content-Type: text/markdown
 
 # VideoSDK RNNoise Plugin

{videosdk_plugins_rnnoise_dev-0.0.63.dev0 → videosdk_plugins_rnnoise_dev-0.0.63.dev2}/pyproject.toml

@@ -9,7 +9,7 @@ description = "VideoSDK Agent Framework plugin for RNNoise."
 readme = "README.md"
 license = "Apache-2.0"
 requires-python = ">=3.11"
-authors = [{ name = "videosdk"}]
+authors = [{ name = "videosdk" }]
 keywords = ["video", "audio", "ai", "lmnt", "tts", "videosdk", "rime"]
 classifiers = [
     "Intended Audience :: Developers",
@@ -20,20 +20,13 @@ classifiers = [
     "Topic :: Multimedia :: Video",
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
 ]
-dependencies = [
-    "videosdk-agents>=0.0.22",
-    "resampy",
-    "numpy>=1.26"
-]
+dependencies = ["videosdk-agents>=0.0.62", "resampy", "numpy>=1.27"]
 
 [tool.hatch.version]
 path = "videosdk/plugins/rnnoise/version.py"
 
 [tool.hatch.build.targets.wheel]
 packages = ["videosdk"]
-include = [
-    "videosdk/plugins/rnnoise/files/*"
-]
 
 [tool.hatch.build.targets.sdist]
-include = ["/videosdk"] 
+include = ["/videosdk"]

videosdk_plugins_rnnoise_dev-0.0.63.dev2/videosdk/plugins/rnnoise/build_rnnoise.py

@@ -0,0 +1,71 @@
+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":
+            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)
+
+            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":
+            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")
+            run_subprocess(["nmake", "/f", "Makefile.ms"])
+            built_lib = "rnnoise.dll"
+        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.")
+
+        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_dev-0.0.63.dev0 → videosdk_plugins_rnnoise_dev-0.0.63.dev2}/videosdk/plugins/rnnoise/denoise.py

@@ -4,12 +4,15 @@ 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._frame_duration_ms = 20
         self._rnnoise_frame_size = 480
 
     async def denoise(self, audio_frames: bytes, **kwargs: Any) -> bytes:
@@ -18,29 +21,35 @@ class RNNoise(Denoise):
 
         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)
+        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)
+            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
+        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)
+            _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:
@@ -50,7 +59,8 @@ class RNNoise(Denoise):
 
         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)
+            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
@@ -59,4 +69,4 @@ class RNNoise(Denoise):
 
     async def aclose(self) -> None:
         self.rnnoise.destroy()
-        await super().aclose()
+        await super().aclose()

videosdk_plugins_rnnoise_dev-0.0.63.dev2/videosdk/plugins/rnnoise/files/librnnoise.dylib

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

videosdk_plugins_rnnoise_dev-0.0.63.dev2/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_dev-0.0.63.dev2/videosdk/plugins/rnnoise/version.py

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

videosdk_plugins_rnnoise_dev-0.0.63.dev0/videosdk/plugins/rnnoise/build_rnnoise.py

@@ -1,126 +0,0 @@
-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_dev-0.0.63.dev0/videosdk/plugins/rnnoise/rnnoise.py

@@ -1,77 +0,0 @@
-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_dev-0.0.63.dev0/videosdk/plugins/rnnoise/version.py

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