logan/drb-client-discord-bot
1
0
Fork 0
Code Issues 3 Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Revert voice activity changes

Browse Source
This commit is contained in:
Logan Cusano
2025-07-14 22:25:36 -04:00
parent 84cef3119f
commit aee6e40792
2 changed files with 32 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

119
app/internal/NoiseGatev2.py
View File

@@ -3,6 +3,9 @@ import math
import pyaudio
import asyncio
from internal.logger import create_logger
# You need to import the base AudioSource class from your specific library.
# This is a common path, but yours might be different.
from discord import AudioSource
LOGGER = create_logger(__name__)
@@ -33,7 +36,7 @@ class NoiseGateSource(AudioSource):
# Ensure we have a full frame of data.
if len(pcm_data) != FRAME_SIZE:
return
return SILENT_FRAME
# Calculate volume to check against the threshold.
rms = audioop.rms(pcm_data, 2)
@@ -42,7 +45,7 @@ class NoiseGateSource(AudioSource):
if self.ng_fadeout_count > 0:
self.ng_fadeout_count -= 1
return pcm_data # Return the (silent) data to complete the fade
return
return SILENT_FRAME
db = 20 * math.log10(rms)
@@ -56,8 +59,8 @@ class NoiseGateSource(AudioSource):
self.ng_fadeout_count -= 1
return pcm_data
# Otherwise, the gate is closed.
return
# Otherwise, the gate is closed. Send silence.
return SILENT_FRAME
except Exception as e:
LOGGER.error(f"Error in NoiseGateSource.read: {e}", exc_info=True)
@@ -65,10 +68,9 @@ class NoiseGateSource(AudioSource):
def cleanup(self) -> None:
"""Called when the player stops."""
if self.audio_stream:
self.audio_stream.stop_stream()
self.audio_stream.close()
LOGGER.info("Audio stream cleaned up.")
# The AudioStreamManager now handles cleanup.
LOGGER.info("Audio source cleanup called.")
pass
class AudioStreamManager:
"""Manages the PyAudio instance and input stream."""
@@ -92,102 +94,5 @@ class AudioStreamManager:
if self.stream and self.stream.is_active():
self.stream.stop_stream()
self.stream.close()
LOGGER.debug("[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):
LOGGER.info('Getting a list of the devices connected')
info = self.paInstance.get_host_api_info_by_index(0)
numdevices = info.get('deviceCount')
devices = {'Input': {}, 'Output': {}}
for i in range(0, numdevices):
device_info = self.paInstance.get_device_info_by_host_api_device_index(0, i)
if (device_info.get('maxInputChannels')) > 0:
input_device = device_info.get('name')
devices['Input'][i] = input_device
if _display_input_devices:
LOGGER.debug(f"Input Device id {i} - {input_device}")
if (device_info.get('maxOutputChannels')) > 0:
output_device = device_info.get('name')
devices['Output'][i] = output_device
if _display_output_devices:
LOGGER.debug(f"Output Device id {i} - {output_device}")
return devices
# noinspection PyUnresolvedReferences
class NoiseGate(AudioStream):
def __init__(self, _voice_connection, _noise_gate_threshold: int, **kwargs):
super(NoiseGate, self).__init__(_init_on_startup=True, **kwargs)
self.voice_connection = _voice_connection
self.THRESHOLD = _noise_gate_threshold
self.NGStream = NoiseGateStream(self)
def run(self) -> None:
LOGGER.debug("Starting stream")
self.stream.start_stream()
self.core()
def core(self):
if self.voice_connection.is_connected() and not self.voice_connection.is_playing():
LOGGER.debug("Playing stream to discord")
self.voice_connection.play(self.NGStream)
async def close(self):
LOGGER.debug("Closing NoiseGate resources...")
if self.voice_connection and self.voice_connection.is_connected():
self.voice_connection.stop()
self.close_if_open()
if self.paInstance:
self.paInstance.terminate()
LOGGER.debug("NoiseGate resources closed.")
# noinspection PyUnresolvedReferences
class NoiseGateStream(discord.AudioSource):
def __init__(self, noise_gate_instance: NoiseGate):
super(NoiseGateStream, self).__init__()
self.noise_gate = noise_gate_instance
self.NG_fadeout = 12
self.NG_fadeout_count = 0
self.process_set_count = 0
def read(self):
try:
if not self.noise_gate.voice_connection.is_connected():
return SILENT_FRAME
curr_buffer = self.noise_gate.stream.read(960, exception_on_overflow=False)
if len(curr_buffer) != DISCORD_FRAME_SIZE:
return SILENT_FRAME
buffer_rms = audioop.rms(curr_buffer, 2)
if buffer_rms > 0:
buffer_decibel = 20 * math.log10(buffer_rms)
if self.process_set_count % 10 == 0:
log_msg = f"[{'Open' if buffer_decibel >= self.noise_gate.THRESHOLD else 'Closed'}]"
LOGGER.debug(f"[NoiseGate {log_msg}] {buffer_decibel:.2f} dB")
if buffer_decibel >= self.noise_gate.THRESHOLD:
self.NG_fadeout_count = self.NG_fadeout
self.process_set_count += 1
return bytes(curr_buffer)
elif self.NG_fadeout_count > 0:
self.NG_fadeout_count -= 1
self.process_set_count += 1
return bytes(curr_buffer)
return SILENT_FRAME
except IOError as e:
LOGGER.error(f"PyAudio IOError in read(): {e}")
return SILENT_FRAME
except Exception as e:
LOGGER.error(f"Unhandled exception in NoiseGateStream.read: {e}", exc_info=True)
return SILENT_FRAME
self.pa.terminate()
LOGGER.info("PyAudio instance terminated.")

54
app/internal/bot_manager.py
View File

@@ -4,12 +4,11 @@ import os
from discord import VoiceClient, VoiceChannel, opus, Activity, ActivityType, Intents
from discord.ext import commands
from typing import Optional, Dict
from internal.NoiseGatev2 import AudioStreamManager, NoiseGateSource
from internal.logger import create_logger
from internal.NoiseGatev2 import AudioStreamManager, NoiseGateSource
LOGGER = create_logger(__name__)
# Configure discord intents
intents = Intents.default()
intents.voice_states = True
intents.guilds = True
@@ -42,18 +41,13 @@ class DiscordBotManager:
@self.bot.event
async def on_voice_state_update(member, before, after):
if member != self.bot.user:
return
if member != self.bot.user: return
if before.channel is None and after.channel is not None:
LOGGER.info(f"{member.name} joined voice channel {after.channel.name}")
self._voice_ready_event.set()
elif before.channel is not None and after.channel is not None and before.channel != after.channel:
LOGGER.info(f"{member.name} was moved to voice channel {after.channel.name}")
if not self._voice_ready_event.is_set():
self._voice_ready_event.set()
if not self._voice_ready_event.is_set(): self._voice_ready_event.set()
elif before.channel is not None and after.channel is None:
LOGGER.warning(f"{member.name} left voice channel {before.channel.name}")
guild_id = before.channel.guild.id
@@ -75,8 +69,7 @@ class DiscordBotManager:
LOGGER.info("Bot is ready.")
except asyncio.TimeoutError:
LOGGER.error("Timeout waiting for bot to become ready.")
if self.bot_task and not self.bot_task.done():
self.bot_task.cancel()
if self.bot_task and not self.bot_task.done(): self.bot_task.cancel()
raise RuntimeError("Bot failed to become ready within timeout.")
async def stop_bot(self):
@@ -107,14 +100,10 @@ class DiscordBotManager:
voice_client = await channel.connect(timeout=60.0, reconnect=True)
await asyncio.wait_for(self._voice_ready_event.wait(), timeout=15.0)
# Create a single audio manager for this connection
audio_manager = AudioStreamManager(input_device_index=device_id)
# Create the noise-gated audio source
audio_source = NoiseGateSource(audio_manager.get_stream(), threshold=ng_threshold)
# Play the source
voice_client.play(audio_source, after=lambda e: print(f'Player error: {e}') if e else None)
voice_client.play(audio_source, after=lambda e: LOGGER.error(f'Player error: {e}') if e else None)
self.voice_connections[guild_id] = {
"client": voice_client,
@@ -124,6 +113,8 @@ class DiscordBotManager:
except Exception as e:
LOGGER.error(f"Failed to connect to voice channel: {e}", exc_info=True)
if guild_id in self.voice_connections: # Cleanup if join fails midway
await self.leave_voice_channel(guild_id)
raise
async def leave_voice_channel(self, guild_id: int):
@@ -137,19 +128,23 @@ class DiscordBotManager:
voice_client.stop()
await voice_client.disconnect()
# Terminate the audio manager to release PyAudio resources
audio_manager = connection_info.get("audio_manager")
if audio_manager:
audio_manager.terminate()
del self.voice_connections[guild_id]
# Use pop to safely remove the key
self.voice_connections.pop(guild_id, None)
LOGGER.info(f"Left guild {guild_id} voice channel.")
async def load_opus(self):
# ... this method is unchanged ...
if opus.is_loaded():
LOGGER.info("Opus library is already loaded.")
return
processor = platform.machine()
script_dir = os.path.dirname(os.path.abspath(__file__))
LOGGER.debug(f"Processor: {processor}, OS: {os.name}")
LOGGER.debug(f"Attempting to load Opus. Processor: {processor}, OS: {os.name}")
try:
if os.name == 'nt':
if processor == "AMD64":
@@ -164,20 +159,11 @@ class DiscordBotManager:
LOGGER.info("Loaded OPUS library for armv7l")
else:
opus.load_opus('libopus.so.0')
LOGGER.info(f"Loaded system OPUS library for {processor}")
LOGGER.info(f"Attempted to load system OPUS library for {processor}")
except Exception as e:
LOGGER.error(f"Failed to load OPUS library: {e}")
raise RuntimeError("Could not load a valid Opus library. Voice functionality will fail.")
async def set_presence(self, system_name: str):
# ... this method is unchanged ...
if not self.bot or not self.bot.is_ready():
LOGGER.warning("Bot is not ready, cannot set presence.")
return
try:
activity = Activity(type=ActivityType.listening, name=system_name)
await self.bot.change_presence(activity=activity)
LOGGER.info(f"Bot presence set to 'Listening to {system_name}'")
except Exception as pe:
LOGGER.error(f"Unable to set presence: '{pe}'")
if not opus.is_loaded():
raise RuntimeError("Opus library could not be loaded. Please ensure it is installed correctly.")