Merge pull request 'Core Update' (#12) from core_update into master

Reviewed-on: #12

BotResources.py

@@ -3,7 +3,7 @@ import logging
 import os
 from datetime import date
 from os.path import exists
-from NoiseGatev2 import AudioStream, query_devices
+from NoiseGatev2 import AudioStream
 
 # Handler configs
 PDB_ACCEPTABLE_HANDLERS = {'gqrx': {
@@ -125,8 +125,7 @@ def write_config_file(**kwargs):
 
 
 def get_device_list():
-    list_of_devices = query_devices().items()
-    LOGGER.info("Returning queried device list:")
+    list_of_devices = AudioStream().list_devices()
     LOGGER.debug(list_of_devices)
     return list_of_devices
 

NoiseGatev2.py

@@ -2,58 +2,109 @@ import audioop
 import logging
 import math
 import time
-import sounddevice
+
 import pyaudio
 import discord
 import numpy
-from pprint import pformat
 
 voice_connection = None
 
 LOGGER = logging.getLogger("Discord_Radio_Bot.NoiseGateV2")
-DEFAULT = 0
 
 
 # noinspection PyUnresolvedReferences
 class AudioStream:
     def __init__(self, _channels: int = 2, _sample_rate: int = 48000, _frames_per_buffer: int = 1024,
-                 _device_index: int = None, _init_on_startup: bool = True):
-        self.sd_kwargs = {
-            'dtype': 'int16',
+                 _input_device_index: int = None, _output_device_index: int = None, _input: bool = True,
+                 _output: bool = True, _init_on_startup: bool = True):
+        self.paInstance_kwargs = {
+            'format': pyaudio.paInt16,
             'channels': _channels,
-            'samplerate': _sample_rate,
-            'blocksize': _frames_per_buffer
+            'rate': _sample_rate,
+            'input': _input,
+            'output': _output,
+            'frames_per_buffer': _frames_per_buffer
         }
 
-        if _device_index:
-            self.sd_kwargs['device'] = _device_index
+        if _input_device_index:
+            if _input:
+                self.paInstance_kwargs['input_device_index'] = _input_device_index
+            else:
+                LOGGER.warning(f"[AudioStream.__init__]:\tInput was not enabled."
+                               f" Reinitialize with '_input=True'")
 
-        # Define and initialize stream object if we have been passed a device ID (pyaudio.open)
-        self.stream = None
+        if _output_device_index:
+            if _output:
+                self.paInstance_kwargs['output_device_index'] = _output_device_index
+            else:
+                LOGGER.warning(f"[AudioStream.__init__]:\tOutput was not enabled."
+                               f" Reinitialize with '_output=True'")
 
-        if _device_index:
+        if _init_on_startup:
+            # Init PyAudio instance
+            LOGGER.info("Creating PyAudio instance")
+            self.paInstance = pyaudio.PyAudio()
+
+            # Define and initialize stream object if we have been passed a device ID (pyaudio.open)
+            self.stream = None
+
+        if _output_device_index or _input_device_index:
             if _init_on_startup:
                 LOGGER.info("Init stream")
                 self.init_stream()
 
-    def init_stream(self, _new_device_index: int = None):
+    def init_stream(self, _new_output_device_index: int = None, _new_input_device_index: int = None):
         # Check what device was asked to be changed (or set)
-        if _new_device_index:
-            self.sd_kwargs['device'] = _new_input_device_index
+        if _new_input_device_index:
+            if self.paInstance_kwargs['input']:
+                self.paInstance_kwargs['input_device_index'] = _new_input_device_index
+            else:
+                LOGGER.warning(f"[AudioStream.init_stream]:\tInput was not enabled when initialized."
+                               f" Reinitialize with '_input=True'")
+
+        if _new_output_device_index:
+            if self.paInstance_kwargs['output']:
+                self.paInstance_kwargs['output_device_index'] = _new_output_device_index
+            else:
+                LOGGER.warning(f"[AudioStream.init_stream]:\tOutput was not enabled when initialized."
+                               f" Reinitialize with '_output=True'")
 
         self.close_if_open()
 
         # Open the stream
-        self.stream = sounddevice.RawStream(**self.sd_kwargs)
+        self.stream = self.paInstance.open(**self.paInstance_kwargs)
 
     def close_if_open(self):
         # Stop the stream if it is started
         if self.stream:
-            if self.stream.active:
-                self.stream.stop()
+            if self.stream.is_active():
+                self.stream.stop_stream()
                 self.stream.close()
                 LOGGER.debug(f"[ReopenStream.close_if_open]:\t Stream was open; It was closed.")
 
+    def list_devices(self, _display_input_devices: bool = True, _display_output_devices: bool = True):
+        info = self.paInstance.get_host_api_info_by_index(0)
+        numdevices = info.get('deviceCount')
+
+        devices = {
+            'Input': {},
+            'Output': {}
+        }
+        for i in range(0, numdevices):
+            if (self.paInstance.get_device_info_by_host_api_device_index(0, i).get('maxInputChannels')) > 0:
+                input_device = self.paInstance.get_device_info_by_host_api_device_index(0, i).get('name')
+                devices['Input'][i] = input_device
+                if _display_input_devices:
+                    LOGGER.debug("Input Device id ", i, " - ", input_device)
+
+            if (self.paInstance.get_device_info_by_host_api_device_index(0, i).get('maxOutputChannels')) > 0:
+                output_device = self.paInstance.get_device_info_by_host_api_device_index(0, i).get('name')
+                devices['Output'][i] = output_device
+                if _display_output_devices:
+                    LOGGER.debug("Output Device id ", i, " - ", output_device)
+
+        return devices
+
     async def stop(self):
         await voice_connection.disconnect()
         self.close_if_open()
@@ -75,13 +126,12 @@ class NoiseGate(AudioStream):
         global voice_connection
         # Start the audio stream
         LOGGER.debug(f"Starting stream")
-        self.stream.start()
+        self.stream.start_stream()
         # Start the stream to discord
         self.core()
 
     def core(self, error=None):
         if error:
-            LOGGER.info('Error in the core')
             LOGGER.warning(error)
 
         while not voice_connection.is_connected():
@@ -89,16 +139,13 @@ class NoiseGate(AudioStream):
 
         if not voice_connection.is_playing():
             LOGGER.debug(f"Playing stream to discord")
-            voice_connection.play(discord.PCMAudio(self.NGStream), after=self.core)
-
-    def list_devices(self):
-        return query_devices()
+            voice_connection.play(self.NGStream, after=self.core)
 
     async def close(self):
         LOGGER.debug(f"Closing")
         await voice_connection.disconnect()
-        if self.stream.active:
-            self.stream.stop()
+        if self.stream.is_active:
+            self.stream.stop_stream()
             LOGGER.debug(f"Stopping stream")
 
 
@@ -111,11 +158,10 @@ class NoiseGateStream(discord.AudioSource):
         self.NG_fadeout_count = 0   # A count set when the noisegate is triggered and was de-triggered
         self.process_set_count = 0  # Counts how many processes have been made
 
-    def read(self, num_bytes):
-        num_frames = num_bytes / 4
+    def read(self):
         try:
             while voice_connection.is_connected():
-                curr_buffer = bytearray(self.stream.stream.read(num_frames))
+                curr_buffer = bytearray(self.stream.stream.read(960))
                 buffer_rms = audioop.rms(curr_buffer, 2)
                 if buffer_rms > 0:
                     buffer_decibel = 20 * math.log10(buffer_rms)
@@ -156,31 +202,6 @@ class NoiseGateStream(discord.AudioSource):
             datalist[i] = chunk.astype(numpy.int16)
 
 
-class DeviceNotFoundError(Exception):
-    def __init__(self):
-        self.devices = sounddevice.query_devices()
-        self.host_apis = sounddevice.query_hostapis()
-        super().__init__("No Devices Found")
-    def __str__(self):
-        return (
-            f"Devices \n"
-            f"{self.devices} \n "
-            f"Host APIs \n"
-            f"{pformat(self.host_apis)}"
-        )
-
-
-def query_devices():
-    options = {
-        device.get("name"): index
-        for index, device in enumerate(sounddevice.query_devices())
-        if (device.get("max_input_channels") > 0 and device.get("hostapi") == DEFAULT)
-    }
-    if not options:
-        raise DeviceNotFoundError()
-    return options
-
-
 if __name__ == '__main__':
 
     input_index = int(input("Input:\t"))

bot.py

@@ -39,7 +39,9 @@ class Bot(commands.Bot):
         self.Bot_Connected = False
 
         # Init the audio devices list
-        self.Devices_List = NoiseGatev2.query_devices().items()
+        #self.Devices_List = sound.query_devices().items()
+        self.Devices_List = NoiseGatev2.AudioStream().list_devices(_display_input_devices=False,
+                                                                   _display_output_devices=False)
 
         # Init radio parameters
         self.profile_name = BotResources.DEFAULT_RADIO_SETTINGS['profile_name']
@@ -106,7 +108,7 @@ class Bot(commands.Bot):
 
                     # Create an audio stream from selected device
                     self.logger.debug("Starting noisegate/stream handler")
-                    self.streamHandler = NoiseGatev2.NoiseGate(_device_index=self.DEVICE_ID,
+                    self.streamHandler = NoiseGatev2.NoiseGate(_input_device_index=self.DEVICE_ID,
                                                                _voice_connection=voice_connection,
                                                                _noise_gate_threshold=self.noisegate_sensitivity)
                     # Start the audio stream