Merge pull request #40 from gituser12981u2/v5.0.0

V5.0.0

Author: gituser12981u2

README.md

@@ -63,16 +63,24 @@ Download and install the PortAudio library from [here](https://files.portaudio.c
     # On Windows, use '.venv\Scripts\activate'
     ```
 
-3. Install the dependencies:
-
-    ```bash
-    pip install -r requirements.txt
-    ```
+3. Install the package:
 
     ```bash
     pip install .
     ```
 
+### Optional GPU Acceleration
+
+If your system has a compatible Nvidia or AMD GPU, you can enable GPU acceleration by installing an additional dependency:
+
+```bash
+pip install .[gpu]
+```
+
+**Note**: GPU acceleration is not recommended if your system supports AMX or uses an Apple M-series chip, as native operations may be more efficient.
+
+Then follow these [instructions](https://docs.cupy.dev/en/stable/install.html#using-cupy-on-amd-gpu-experimental) to install the CUDA--for Nvidia--or ROCm--for AMD--toolkit.
+
 ## Usage
 
 ### Running the Visualizer

audio_visualizer/__init__.py

@@ -3,16 +3,36 @@
 import logging
 import time
 import os
+import sys
 from sys import platform
 from lupa import LuaRuntime
 
+# Clear existing handlers
+for handler in logging.root.handlers[:]:
+    logging.root.removeHandler(handler)
 
 # Configure logging
-logging.basicConfig(level=logging.DEBUG,
-                    format='%(asctime)s - %(levelname)s - %(message)s',
-                    handlers=[
-                        logging.FileHandler("debug.log"),
-                    ])
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    filename='debug.log',
+    filemode='a'  # Append mode
+)
+
+# Create a console handler to log ERROR
+# and higher level messages to the console
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.ERROR)
+console_formatter = logging.Formatter(
+    '%(asctime)s - %(levelname)s - %(message)s')
+console_handler.setFormatter(console_formatter)
+
+# Get the root logger and add the console handler
+logger = logging.getLogger()
+logger.addHandler(console_handler)
+
+# Disable propagation for the logger to prevent duplicate logging in console
+logger.propagate = False
 
 
 def load_config():
@@ -51,24 +71,23 @@ def load_config():
     # If no config file is found, log the error and return default settings
     logging.warning(f"No configuration file found in expected locations: {
                     paths}. Using default settings.")
+
+    # Alt works better for windows and ctrl works better for unix based
+    default_modifier = 'alt' if sys.platform == 'win32' else 'ctrl'
     return {
         'key_binds': {
-            'modifier_key': 'ctrl',
+            'modifier_key': default_modifier,
             'keys': {
-                'v': 'vertical',
-                'l': 'horizontal-ltr',
-                'r': 'horizontal-rtl'
+                'j': 'vertical',
+                'h': 'horizontal-ltr',
+                'l': 'horizontal-rtl'
             }
         },
         'settings': {
             'default_mode': 'vertical',
             'alpha': 0.4,
             'chunk_size': 2048,
             'sample_rate': 44100
-        },
-        'themes': {
-            'background_color': 'default',  # RGB for black
-            'bar_color': 'default'  # RGB for white
         }
     }
 
@@ -109,8 +128,9 @@ def main():
         alpha=args.alpha,
         chunk=args.chunk,
         rate=args.rate,
-        config=config['key_binds'],
-        theme=config['themes']
+        key_binds=config['key_binds'],
+        theme=config['themes'],
+        audio_source=config['settings']['audio_source']
     )
     visualizer.start()
 

audio_visualizer/audio_capture.py

@@ -14,59 +14,77 @@ class AudioCapture:
     A class to handle audio capture using PyAudio.
 
     Attributes:
+        FORMAT (int): Audio format (16-bit PCM).
         chunk (int): Number of audio samples per buffer.
         rate (int): Sample rate (samples per second).
         channels (int): Number of audio channels
-        FORMAT (int): Audio format (16-bit PCM).
+        audio_source (str): The name of the audio input device to use.
         audio (pyaudio.PyAudio): PyAudio object for audio streaming.
         stream (pyaudio.Stream): Stream object for audio input.
     """
 
-    def __init__(self, chunk=2048, rate=44100, channels=2):
+    def __init__(self, chunk, rate, channels=2, device_name=None):
         self.FORMAT = pyaudio.paInt16
-        self.CHANNELS = channels
-        self.RATE = rate
         self.CHUNK = chunk
+        self.RATE = rate
+        self.CHANNELS = channels
+        self.device_name = device_name
         self.audio = pyaudio.PyAudio()
         self.stream = None
 
-    def start_stream(self, device_name=None):
+    def start_stream(self):
         """
         Starts the audio stream. Selects the specified device if provided.
-
-        Args:
-            device_name (str): The name of the audio input device to use.
         """
-        # Handle default device selection based on platform
-        if platform.system() == 'Darwin' and device_name is None:
-            device_name = 'BlackHole 2ch'
+        device_index = None
+
+        logging.info(f"Specified device name {self.device_name}")
 
-        # List available audio devices
-        self.device_index = None
         for i in range(self.audio.get_device_count()):
             info = self.audio.get_device_info_by_index(i)
             logging.info(f"Device {i}: {info['name']}")
-            if device_name and device_name in info['name']:
-                self.device_index = i
-                logging.info(f"Selected Device {i}: {info['name']}")
-                logging.info(f"Device {i} Max Input Channels: {
-                             info['maxInputChannels']}")
-                logging.info(f"Device {i} Max Output Channels: {
-                             info['maxOutputChannels']}")
+
+        # List available audio devices
+        if self.device_name:
+            # Attempt to find specified device
+            for i in range(self.audio.get_device_count()):
+                info = self.audio.get_device_info_by_index(i)
+                if self.device_name in info['name']:
+                    logging.info(f"Selected Device {i}: {info['name']}")
+                    device_index = i
+                    break
+            if device_index is None:
+                logging.error(f"Device '{self.device_name}' not found.")
+
+        if device_index is None and platform.system() == 'Darwin':
+            # Specific handling for macOS
+            for i in range(self.audio.get_device_count()):
+                info = self.audio.get_device_info_by_index(i)
+                if 'BlackHole 2ch' in info['name']:
+                    logging.info(f"Selected Device {i}: {info['name']}")
+                    device_index = i
+                    break
+            if device_index is None:
+                logging.error(
+                    "BlackHole 2ch not found on this system.")
 
         # Use the default input device if no specific device name is provided
-        if self.device_index is None:
-            logging.info(
-                "No specific device selected, using default input device.")
-            self.device_index = self.audio.get_default_input_device_info()[
+        if device_index is None:
+            # Fallback to default input device
+            device_index = self.audio.get_default_input_device_info()[
                 'index']
+            default_device_info = self.audio.get_device_info_by_index(
+                device_index)
+            logging.info(
+                f"No specific device selected, using default input device: {
+                    default_device_info['name']}")
 
         try:
             self.stream = self.audio.open(format=self.FORMAT,
                                           channels=self.CHANNELS,
                                           rate=self.RATE,
                                           input=True,
-                                          input_device_index=self.device_index,
+                                          input_device_index=device_index,
                                           frames_per_buffer=self.CHUNK)
         except Exception as e:
             logging.error(f"Failed to open stream: {e}")
@@ -81,9 +99,8 @@ def read_data(self):
         """
         if self.stream is not None:
             try:
-                data = self.stream.read(
+                return self.stream.read(
                     self.CHUNK, exception_on_overflow=False)
-                return data
             except IOError as e:
                 logging.warning(f"Input overflowed: {e}")
                 return None