every_holiday/VRCT
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'auto_device_detect' into for_webui

Browse Source 
# Conflicts:
#	src-python/config.py
This commit is contained in:
misyaguziya
2024-10-04 16:47:05 +09:00
parent 47d0103dda b5db201e70
commit 9abf8742f7
6 changed files with 246 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src-python/config.py
View File

@@ -3,7 +3,8 @@ import inspect
from os import path as os_path, makedirs as os_makedirs
from json import load as json_load
from json import dump as json_dump
from models.transcription.transcription_utils import device_manager
from device_manager import device_manager
from models.transcription.transcription_languages import transcription_lang
from utils import generatePercentageStringsList, isUniqueStrings

157
src-python/models/transcription/transcription_utils.py → src-python/device_manager.py
View File

@@ -4,6 +4,7 @@ import comtypes
from pyaudiowpatch import PyAudio, paWASAPI
from pycaw.callbacks import MMNotificationClient
from pycaw.utils import AudioUtilities
from utils import printLog
class Client(MMNotificationClient):
def __init__(self):
@@ -22,8 +23,8 @@ class Client(MMNotificationClient):
def on_device_state_changed(self, device_id, state):
self.loop = False
def on_property_value_changed(self, device_id, key):
self.loop = False
# def on_property_value_changed(self, device_id, key):
# self.loop = False
class DeviceManager:
_instance = None
@@ -39,6 +40,7 @@ class DeviceManager:
self.default_mic_device = {"host": {"name": "NoHost"}, "device": {"name": "NoDevice"}}
self.speaker_devices = [{"name": "NoDevice"}]
self.default_speaker_device = {"device": {"name": "NoDevice"}}
self.update()
self.prev_mic_host = [host for host in self.mic_devices]
@@ -47,12 +49,19 @@ class DeviceManager:
self.prev_speaker_devices = self.speaker_devices
self.prev_default_speaker_device = self.default_speaker_device
self.update_flag_default_mic_device = False
self.update_flag_default_speaker_device = False
self.update_flag_host_list = False
self.update_flag_mic_device_list = False
self.update_flag_speaker_device_list = False
self.callback_default_mic_device = None
self.callback_default_speaker_device = None
self.callback_host_list = None
self.callback_mic_device_list = None
self.callback_speaker_device_list = None
self.callback_prev_update = None
self.callback_process_before_update_devices = None
self.callback_process_after_update_devices = None
self.monitoring_flag = False
self.startMonitoring()
@@ -130,30 +139,59 @@ class DeviceManager:
self.speaker_devices = buffer_speaker_devices
self.default_speaker_device = buffer_default_speaker_device
def checkUpdate(self):
if self.prev_default_mic_device["device"]["name"] != self.default_mic_device["device"]["name"]:
self.update_flag_default_mic_device = True
self.prev_default_mic_device = self.default_mic_device
if self.prev_default_speaker_device["device"]["name"] != self.default_speaker_device["device"]["name"]:
self.update_flag_default_speaker_device = True
self.prev_default_speaker_device = self.default_speaker_device
if self.prev_mic_host != [host for host in self.mic_devices]:
self.update_flag_host_list = True
self.prev_mic_host = [host for host in self.mic_devices]
if {key: [device['name'] for device in devices] for key, devices in self.prev_mic_devices.items()} != {key: [device['name'] for device in devices] for key, devices in self.mic_devices.items()}:
self.update_flag_mic_device_list = True
self.prev_mic_devices = self.mic_devices
if [device['name'] for device in self.prev_speaker_devices] != [device['name'] for device in self.speaker_devices]:
self.update_flag_speaker_device_list = True
self.prev_speaker_devices = self.speaker_devices
update_flag = (
self.update_flag_default_mic_device or
self.update_flag_default_speaker_device or
self.update_flag_host_list or
self.update_flag_mic_device_list or
self.update_flag_speaker_device_list
)
return update_flag
def monitoring(self):
comtypes.CoInitialize()
cb = Client()
enumerator = AudioUtilities.GetDeviceEnumerator()
enumerator.RegisterEndpointNotificationCallback(cb)
try:
while self.monitoring_flag is True:
try:
while cb.loop is True:
sleep(1)
enumerator.UnregisterEndpointNotificationCallback(cb)
self.runPrevUpdateDevices()
sleep(2)
self.update()
self.noticeDefaultDevice()
except Exception:
pass
finally:
comtypes.CoInitialize()
cb = Client()
enumerator = AudioUtilities.GetDeviceEnumerator()
enumerator.RegisterEndpointNotificationCallback(cb)
except Exception:
pass
comtypes.CoUninitialize()
while cb.loop is True:
sleep(1)
enumerator.UnregisterEndpointNotificationCallback(cb)
comtypes.CoUninitialize()
self.runProcessBeforeUpdateDevices()
sleep(2)
for _ in range(10):
self.update()
if self.checkUpdate():
break
sleep(2)
self.noticeUpdateDevices()
self.runProcessAfterUpdateDevices()
except Exception as e:
printLog("Device Monitoring: ", e)
finally:
pass
except Exception as e:
printLog("Device Monitoring End Exception: ", e)
def startMonitoring(self):
self.monitoring_flag = True
@@ -195,47 +233,57 @@ class DeviceManager:
def clearCallbackSpeakerDeviceList(self):
self.callback_speaker_device_list = None
def setCallbackPrevUpdateDevices(self, callback):
self.callback_prev_update = callback
def setCallbackProcessBeforeUpdateDevices(self, callback):
self.callback_process_before_update_devices = callback
def clearCallbackPrevUpdateDevices(self):
self.callback_prev_update = None
def clearCallbackProcessBeforeUpdateDevices(self):
self.callback_process_before_update_devices = None
def runPrevUpdateDevices(self):
self.callback_prev_update()
def runProcessBeforeUpdateDevices(self):
self.callback_process_before_update_devices()
def noticeDefaultDevice(self):
if self.callback_default_mic_device is not None:
if self.prev_default_mic_device["device"]["name"] != self.default_mic_device["device"]["name"]:
self.callback_default_mic_device(self.default_mic_device["host"]["name"], self.default_mic_device["device"]["name"])
self.prev_default_mic_device = self.default_mic_device
def setCallbackProcessAfterUpdateDevices(self, callback):
self.callback_process_after_update_devices = callback
if self.callback_default_speaker_device is not None:
if self.prev_default_speaker_device["device"]["name"] != self.default_speaker_device["device"]["name"]:
self.callback_default_speaker_device(self.default_speaker_device["device"]["name"])
self.prev_default_speaker_device = self.default_speaker_device
def clearCallbackProcessAfterUpdateDevices(self):
self.callback_process_after_update_devices = None
if self.callback_host_list is not None:
if self.prev_mic_host != [host for host in self.mic_devices]:
self.callback_host_list()
self.prev_mic_host = [host for host in self.mic_devices]
def runProcessAfterUpdateDevices(self):
self.callback_process_after_update_devices()
if self.callback_mic_device_list is not None:
if {key: [device['name'] for device in devices] for key, devices in self.prev_mic_devices.items()} != {key: [device['name'] for device in devices] for key, devices in self.mic_devices.items()}:
self.callback_mic_device_list()
self.prev_mic_devices = self.mic_devices
def noticeUpdateDevices(self):
if self.callback_default_mic_device is not None and self.update_flag_default_mic_device is True:
self.setMicDefaultDevice()
if self.callback_default_speaker_device is not None and self.update_flag_default_speaker_device is True:
self.setSpeakerDefaultDevice()
if self.callback_host_list is not None and self.update_flag_host_list is True:
self.setMicHostList()
if self.callback_mic_device_list is not None and self.update_flag_mic_device_list is True:
self.setMicDeviceList()
if self.callback_speaker_device_list is not None and self.update_flag_speaker_device_list is True:
self.setSpeakerDeviceList()
if self.callback_speaker_device_list is not None:
if [device['name'] for device in self.prev_speaker_devices] != [device['name'] for device in self.speaker_devices]:
self.callback_speaker_device_list()
self.prev_speaker_devices = self.speaker_devices
self.update_flag_default_mic_device = False
self.update_flag_default_speaker_device = False
self.update_flag_host_list = False
self.update_flag_mic_device_list = False
self.update_flag_speaker_device_list = False
def forceSetMicDefaultDevice(self):
def setMicDefaultDevice(self):
self.callback_default_mic_device(self.default_mic_device["host"]["name"], self.default_mic_device["device"]["name"])
def forceSetSpeakerDefaultDevice(self):
def setSpeakerDefaultDevice(self):
self.callback_default_speaker_device(self.default_speaker_device["device"]["name"])
def setMicHostList(self):
self.callback_host_list()
def setMicDeviceList(self):
self.callback_mic_device_list()
def setSpeakerDeviceList(self):
self.callback_speaker_device_list()
def getMicDevices(self):
return self.mic_devices
@@ -248,6 +296,17 @@ class DeviceManager:
def getDefaultSpeakerDevice(self):
return self.default_speaker_device
def forceUpdateAndSetMicDevices(self):
self.update()
self.setMicHostList()
self.setMicDeviceList()
self.setMicDefaultDevice()
def forceUpdateAndSetSpeakerDevices(self):
self.update()
self.setSpeakerDeviceList()
self.setSpeakerDefaultDevice()
device_manager = DeviceManager()
if __name__ == "__main__":

47
src-python/model.py
View File

@@ -12,12 +12,15 @@ from queue import Queue
from threading import Thread
from requests import get as requests_get
import webbrowser
from typing import Callable
from flashtext import KeywordProcessor
from pykakasi import kakasi
from device_manager import device_manager
from config import config
from models.translation.translation_translator import Translator
from models.transcription.transcription_utils import device_manager
from models.osc.osc_tools import sendTyping, sendMessage, receiveOscParameters, getOSCParameterValue
from models.transcription.transcription_recorder import SelectedMicEnergyAndAudioRecorder, SelectedSpeakerEnergyAndAudioRecorder
from models.transcription.transcription_recorder import SelectedMicEnergyRecorder, SelectedSpeakerEnergyRecorder
@@ -29,8 +32,6 @@ from models.transcription.transcription_whisper import checkWhisperWeight, downl
from models.overlay.overlay import Overlay
from models.overlay.overlay_image import OverlayImage
from config import config
class threadFnc(Thread):
def __init__(self, fnc, end_fnc=None, daemon=True, *args, **kwargs):
super(threadFnc, self).__init__(daemon=daemon, target=fnc, *args, **kwargs)
@@ -424,13 +425,8 @@ class Model:
return result
def startMicTranscript(self, fnc):
if config.AUTO_MIC_SELECT is True:
default_device = device_manager.getDefaultMicDevice()
mic_host_name = default_device["host"]["name"]
mic_device_name = default_device["device"]["name"]
else:
mic_host_name = config.SELECTED_MIC_HOST
mic_device_name = config.SELECTED_MIC_DEVICE
mic_host_name = config.SELECTED_MIC_HOST
mic_device_name = config.SELECTED_MIC_DEVICE
mic_device_list = device_manager.getMicDevices().get(mic_host_name, [{"name": "NoDevice"}])
selected_mic_device = [device for device in mic_device_list if device["name"] == mic_device_name]
@@ -451,7 +447,7 @@ class Model:
device=mic_device,
energy_threshold=config.MIC_THRESHOLD,
dynamic_energy_threshold=config.MIC_AUTOMATIC_THRESHOLD,
record_timeout=record_timeout,
phrase_time_limit=record_timeout,
)
# self.mic_audio_recorder.recordIntoQueue(self.mic_audio_queue, mic_energy_queue)
self.mic_audio_recorder.recordIntoQueue(self.mic_audio_queue, None)
@@ -558,13 +554,8 @@ class Model:
if isinstance(fnc, Callable):
self.check_mic_energy_fnc = fnc
if config.AUTO_MIC_SELECT is True:
default_device = device_manager.getDefaultMicDevice()
mic_host_name = default_device["host"]["name"]
mic_device_name = default_device["device"]["name"]
else:
mic_host_name = config.SELECTED_MIC_HOST
mic_device_name = config.SELECTED_MIC_DEVICE
mic_host_name = config.SELECTED_MIC_HOST
mic_device_name = config.SELECTED_MIC_DEVICE
mic_device_list = device_manager.getMicDevices().get(mic_host_name, [{"name": "NoDevice"}])
selected_mic_device = [device for device in mic_device_list if device["name"] == mic_device_name]
@@ -600,14 +591,8 @@ class Model:
self.mic_energy_recorder = None
def startSpeakerTranscript(self, fnc):
if config.AUTO_SPEAKER_SELECT is True:
default_device = device_manager.getDefaultSpeakerDevice()
speaker_device_name = default_device["device"]["name"]
else:
speaker_device_name = config.SELECTED_SPEAKER_DEVICE
speaker_device_list = device_manager.getSpeakerDevices()
selected_speaker_device = [device for device in speaker_device_list if device["name"] == speaker_device_name]
selected_speaker_device = [device for device in speaker_device_list if device["name"] == config.SELECTED_SPEAKER_DEVICE]
if len(selected_speaker_device) == 0:
return False
@@ -624,7 +609,7 @@ class Model:
device=speaker_device,
energy_threshold=config.SPEAKER_THRESHOLD,
dynamic_energy_threshold=config.SPEAKER_AUTOMATIC_THRESHOLD,
record_timeout=record_timeout,
phrase_time_limit=record_timeout,
)
# self.speaker_audio_recorder.recordIntoQueue(speaker_audio_queue, speaker_energy_queue)
self.speaker_audio_recorder.recordIntoQueue(speaker_audio_queue, None)
@@ -692,14 +677,8 @@ class Model:
if isinstance(fnc, Callable):
self.check_speaker_energy_fnc = fnc
if config.AUTO_SPEAKER_SELECT is True:
default_device = device_manager.getDefaultSpeakerDevice()
speaker_device_name = default_device["device"]["name"]
else:
speaker_device_name = config.SELECTED_SPEAKER_DEVICE
speaker_device_list = device_manager.getSpeakerDevices()
selected_speaker_device = [device for device in speaker_device_list if device["name"] == speaker_device_name]
selected_speaker_device = [device for device in speaker_device_list if device["name"] == config.SELECTED_SPEAKER_DEVICE]
if len(selected_speaker_device) == 0:
return False

32
src-python/models/transcription/transcription_recorder.py
View File

@@ -91,10 +91,12 @@ class SelectedSpeakerEnergyRecorder(BaseEnergyRecorder):
# self.adjustForNoise()
class BaseEnergyAndAudioRecorder:
def __init__(self, source, energy_threshold, dynamic_energy_threshold, record_timeout):
def __init__(self, source, energy_threshold, dynamic_energy_threshold, phrase_time_limit, phrase_timeout, record_timeout):
self.recorder = Recognizer()
self.recorder.energy_threshold = energy_threshold
self.recorder.dynamic_energy_threshold = dynamic_energy_threshold
self.phrase_time_limit = phrase_time_limit
self.phrase_timeout = phrase_timeout
self.record_timeout = record_timeout
self.stop = None
@@ -117,20 +119,29 @@ class BaseEnergyAndAudioRecorder:
self.stop, self.pause, self.resume = self.recorder.listen_energy_and_audio_in_background(
source=self.source,
callback=audioRecordCallback,
phrase_time_limit=self.record_timeout,
callback_energy=energyRecordCallback if energy_queue is not None else None)
phrase_time_limit=self.phrase_time_limit,
callback_energy=energyRecordCallback if energy_queue is not None else None,
phrase_timeout=self.phrase_timeout,
record_timeout=self.record_timeout)
class SelectedMicEnergyAndAudioRecorder(BaseEnergyAndAudioRecorder):
def __init__(self, device, energy_threshold, dynamic_energy_threshold, record_timeout):
def __init__(self, device, energy_threshold, dynamic_energy_threshold, phrase_time_limit, phrase_timeout:int=1, record_timeout:int=5):
source=Microphone(
device_index=device['index'],
sample_rate=int(device["defaultSampleRate"]),
)
super().__init__(source=source, energy_threshold=energy_threshold, dynamic_energy_threshold=dynamic_energy_threshold, record_timeout=record_timeout)
super().__init__(
source=source,
energy_threshold=energy_threshold,
dynamic_energy_threshold=dynamic_energy_threshold,
phrase_time_limit=phrase_time_limit,
phrase_timeout=phrase_timeout,
record_timeout=record_timeout,
)
# self.adjustForNoise()
class SelectedSpeakerEnergyAndAudioRecorder(BaseEnergyAndAudioRecorder):
def __init__(self, device, energy_threshold, dynamic_energy_threshold, record_timeout):
def __init__(self, device, energy_threshold, dynamic_energy_threshold, phrase_time_limit, phrase_timeout:int=1, record_timeout:int=5):
source = Microphone(speaker=True,
device_index= device["index"],
@@ -138,5 +149,12 @@ class SelectedSpeakerEnergyAndAudioRecorder(BaseEnergyAndAudioRecorder):
chunk_size=get_sample_size(paInt16),
channels=device["maxInputChannels"]
)
super().__init__(source=source, energy_threshold=energy_threshold, dynamic_energy_threshold=dynamic_energy_threshold, record_timeout=record_timeout)
super().__init__(
source=source,
energy_threshold=energy_threshold,
dynamic_energy_threshold=dynamic_energy_threshold,
phrase_time_limit=phrase_time_limit,
phrase_timeout=phrase_timeout,
record_timeout=record_timeout,
)
# self.adjustForNoise()

152
src-python/webui_controller.py
View File

@@ -3,16 +3,16 @@ from time import sleep
from subprocess import Popen
from threading import Thread
import re
from device_manager import device_manager
from config import config
from model import model
from utils import isUniqueStrings, printLog
from models.transcription.transcription_utils import device_manager
class Controller:
def __init__(self) -> None:
self.run_mapping = {}
self.run = None
self.transcription_access_status = True
self.device_access_status = True
def setRunMapping(self, run_mapping:dict) -> None:
self.run_mapping = run_mapping
@@ -56,11 +56,25 @@ class Controller:
model.getListSpeakerDevice(),
)
def prevUpdateSelectedDevices(self) -> None:
def restartAccessDevices(self) -> None:
if config.ENABLE_TRANSCRIPTION_SEND is True:
model.stopMicTranscript()
self.startThreadingTranscriptionSendMessage()
if config.ENABLE_TRANSCRIPTION_RECEIVE is True:
model.stopSpeakerTranscript()
self.startThreadingTranscriptionReceiveMessage()
if config.ENABLE_CHECK_ENERGY_SEND is True:
model.startCheckMicEnergy(
self.progressBarMicEnergy,
)
if config.ENABLE_CHECK_ENERGY_RECEIVE is True:
model.startCheckSpeakerEnergy(
self.progressBarSpeakerEnergy,
)
def stopAccessDevices(self) -> None:
if config.ENABLE_TRANSCRIPTION_SEND is True:
self.stopThreadingTranscriptionSendMessage()
if config.ENABLE_TRANSCRIPTION_RECEIVE is True:
self.stopThreadingTranscriptionReceiveMessage()
if config.ENABLE_CHECK_ENERGY_SEND is True:
model.stopCheckMicEnergy()
if config.ENABLE_CHECK_ENERGY_RECEIVE is True:
@@ -69,10 +83,6 @@ class Controller:
def updateSelectedMicDevice(self, host, device) -> None:
config.SELECTED_MIC_HOST = host
config.SELECTED_MIC_DEVICE = device
if config.ENABLE_TRANSCRIPTION_SEND is True:
model.startMicTranscript()
if config.ENABLE_CHECK_ENERGY_SEND is True:
model.startCheckMicEnergy()
self.run(
200,
self.run_mapping["selected_mic_device"],
@@ -81,10 +91,6 @@ class Controller:
def updateSelectedSpeakerDevice(self, device) -> None:
config.SELECTED_SPEAKER_DEVICE = device
if config.ENABLE_TRANSCRIPTION_RECEIVE is True:
model.startSpeakerTranscript()
if config.ENABLE_CHECK_ENERGY_RECEIVE is True:
model.startCheckSpeakerEnergy()
self.run(
200,
self.run_mapping["selected_speaker_device"],
@@ -599,16 +605,17 @@ class Controller:
def setEnableAutoMicSelect(self, *args, **kwargs) -> dict:
config.AUTO_MIC_SELECT = True
device_manager.setCallbackPrevUpdateDevices(self.prevUpdateSelectedDevices)
device_manager.setCallbackProcessBeforeUpdateDevices(self.stopAccessDevices)
device_manager.setCallbackDefaultMicDevice(self.updateSelectedMicDevice)
device_manager.noticeDefaultDevice()
device_manager.forceSetMicDefaultDevice()
device_manager.setCallbackProcessAfterUpdateDevices(self.restartAccessDevices)
device_manager.forceUpdateAndSetMicDevices()
return {"status":200, "result":config.AUTO_MIC_SELECT}
@staticmethod
def setDisableAutoMicSelect(*args, **kwargs) -> dict:
device_manager.clearCallbackPrevUpdateDevices()
device_manager.clearCallbackProcessBeforeUpdateDevices()
device_manager.clearCallbackDefaultMicDevice()
device_manager.clearCallbackProcessAfterUpdateDevices()
config.AUTO_MIC_SELECT = False
return {"status":200, "result":config.AUTO_MIC_SELECT}
@@ -616,13 +623,12 @@ class Controller:
def getSelectedMicHost(*args, **kwargs) -> dict:
return {"status":200, "result":config.SELECTED_MIC_HOST}
@staticmethod
def setSelectedMicHost(data, *args, **kwargs) -> dict:
def setSelectedMicHost(self, data, *args, **kwargs) -> dict:
config.SELECTED_MIC_HOST = data
config.SELECTED_MIC_DEVICE = model.getMicDefaultDevice()
if config.ENABLE_CHECK_ENERGY_SEND is True:
model.stopCheckMicEnergy()
model.startCheckMicEnergy()
self.stopThreadingCheckMicEnergy()
self.startThreadingTranscriptionSendMessage()
return {"status":200,
"result":{
"host":config.SELECTED_MIC_HOST,
@@ -634,12 +640,11 @@ class Controller:
def getSelectedMicDevice(*args, **kwargs) -> dict:
return {"status":200, "result":config.SELECTED_MIC_DEVICE}
@staticmethod
def setSelectedMicDevice(data, *args, **kwargs) -> dict:
def setSelectedMicDevice(self, data, *args, **kwargs) -> dict:
config.SELECTED_MIC_DEVICE = data
if config.ENABLE_CHECK_ENERGY_SEND is True:
model.stopCheckMicEnergy()
model.startCheckMicEnergy()
self.stopThreadingCheckMicEnergy()
self.startThreadingTranscriptionSendMessage()
return {"status":200, "result": config.SELECTED_MIC_DEVICE}
@staticmethod
@@ -784,16 +789,18 @@ class Controller:
def setEnableAutoSpeakerSelect(self, *args, **kwargs) -> dict:
config.AUTO_SPEAKER_SELECT = True
device_manager.setCallbackPrevUpdateDevices(self.prevUpdateSelectedDevices)
device_manager.setCallbackProcessBeforeUpdateDevices(self.stopAccessDevices)
device_manager.setCallbackDefaultSpeakerDevice(self.updateSelectedSpeakerDevice)
device_manager.noticeDefaultDevice()
device_manager.forceSetSpeakerDefaultDevice()
device_manager.setCallbackProcessAfterUpdateDevices(self.restartAccessDevices)
device_manager.forceUpdateAndSetSpeakerDevices()
return {"status":200, "result":config.AUTO_SPEAKER_SELECT}
@staticmethod
def setDisableAutoSpeakerSelect(*args, **kwargs) -> dict:
device_manager.clearCallbackPrevUpdateDevices()
device_manager.clearCallbackProcessBeforeUpdateDevices()
device_manager.clearCallbackDefaultSpeakerDevice()
device_manager.clearCallbackProcessAfterUpdateDevices()
config.AUTO_SPEAKER_SELECT = False
return {"status":200, "result":config.AUTO_SPEAKER_SELECT}
@@ -801,12 +808,11 @@ class Controller:
def getSelectedSpeakerDevice(*args, **kwargs) -> dict:
return {"status":200, "result":config.SELECTED_SPEAKER_DEVICE}
@staticmethod
def setSelectedSpeakerDevice(data, *args, **kwargs) -> dict:
def setSelectedSpeakerDevice(self, data, *args, **kwargs) -> dict:
config.SELECTED_SPEAKER_DEVICE = data
if config.ENABLE_CHECK_ENERGY_RECEIVE is True:
model.stopCheckSpeakerEnergy()
model.startCheckSpeakerEnergy()
self.stopThreadingCheckSpeakerEnergy()
self.startThreadingTranscriptionReceiveMessage()
return {"status":200, "result":config.SELECTED_SPEAKER_DEVICE}
@staticmethod
@@ -1264,28 +1270,22 @@ class Controller:
return {"status":200, "result":config.VRC_MIC_MUTE_SYNC}
def setEnableCheckSpeakerThreshold(self, *args, **kwargs) -> dict:
model.startCheckSpeakerEnergy(
self.progressBarSpeakerEnergy,
)
self.startThreadingCheckSpeakerEnergy()
config.ENABLE_CHECK_ENERGY_RECEIVE = True
return {"status":200, "result":config.ENABLE_CHECK_ENERGY_RECEIVE}
@staticmethod
def setDisableCheckSpeakerThreshold(*args, **kwargs) -> dict:
model.stopCheckSpeakerEnergy()
def setDisableCheckSpeakerThreshold(self, *args, **kwargs) -> dict:
self.stopThreadingCheckSpeakerEnergy()
config.ENABLE_CHECK_ENERGY_RECEIVE = False
return {"status":200, "result":config.ENABLE_CHECK_ENERGY_RECEIVE}
def setEnableCheckMicThreshold(self, *args, **kwargs) -> dict:
model.startCheckMicEnergy(
self.progressBarMicEnergy,
)
self.startThreadingCheckMicEnergy()
config.ENABLE_CHECK_ENERGY_SEND = True
return {"status":200, "result":config.ENABLE_CHECK_ENERGY_SEND}
@staticmethod
def setDisableCheckMicThreshold(*args, **kwargs) -> dict:
model.stopCheckMicEnergy()
def setDisableCheckMicThreshold(self, *args, **kwargs) -> dict:
self.stopThreadingCheckMicEnergy()
config.ENABLE_CHECK_ENERGY_SEND = False
return {"status":200, "result":config.ENABLE_CHECK_ENERGY_SEND}
@@ -1399,11 +1399,11 @@ class Controller:
self.run(200, self.run_mapping["translation_engines"], "CTranslate2")
def startTranscriptionSendMessage(self) -> None:
while self.transcription_access_status is False:
while self.device_access_status is False:
sleep(1)
self.transcription_access_status = False
self.device_access_status = False
model.startMicTranscript(self.micMessage)
self.transcription_access_status = True
self.device_access_status = True
@staticmethod
def stopTranscriptionSendMessage() -> None:
@@ -1421,11 +1421,11 @@ class Controller:
th_stopTranscriptionSendMessage.join()
def startTranscriptionReceiveMessage(self) -> None:
while self.transcription_access_status is False:
while self.device_access_status is False:
sleep(1)
self.transcription_access_status = False
self.device_access_status = False
model.startSpeakerTranscript(self.speakerMessage)
self.transcription_access_status = True
self.device_access_status = True
@staticmethod
def stopTranscriptionReceiveMessage() -> None:
@@ -1491,6 +1491,48 @@ class Controller:
self.run(200, self.run_mapping["selected_translation_engines"], config.SELECTED_TRANSLATION_ENGINES)
self.run(200, self.run_mapping["translation_engines"], engines)
def startCheckMicEnergy(self) -> None:
while self.device_access_status is False:
sleep(1)
self.device_access_status = False
model.startCheckMicEnergy(self.progressBarMicEnergy)
self.device_access_status = True
def startThreadingCheckMicEnergy(self) -> None:
th_startCheckMicEnergy = Thread(target=self.startCheckMicEnergy)
th_startCheckMicEnergy.daemon = True
th_startCheckMicEnergy.start()
def stopCheckMicEnergy(self) -> None:
model.stopCheckMicEnergy()
def stopThreadingCheckMicEnergy(self) -> None:
th_stopCheckMicEnergy = Thread(target=self.stopCheckMicEnergy)
th_stopCheckMicEnergy.daemon = True
th_stopCheckMicEnergy.start()
th_stopCheckMicEnergy.join()
def startCheckSpeakerEnergy(self) -> None:
while self.device_access_status is False:
sleep(1)
self.device_access_status = False
model.startCheckSpeakerEnergy(self.progressBarSpeakerEnergy)
self.device_access_status = True
def startThreadingCheckSpeakerEnergy(self) -> None:
th_startCheckSpeakerEnergy = Thread(target=self.startCheckSpeakerEnergy)
th_startCheckSpeakerEnergy.daemon = True
th_startCheckSpeakerEnergy.start()
def stopCheckSpeakerEnergy(self) -> None:
model.stopCheckSpeakerEnergy()
def stopThreadingCheckSpeakerEnergy(self) -> None:
th_stopCheckSpeakerEnergy = Thread(target=self.stopCheckSpeakerEnergy)
th_stopCheckSpeakerEnergy.daemon = True
th_stopCheckSpeakerEnergy.start()
th_stopCheckSpeakerEnergy.join()
@staticmethod
def startThreadingDownloadCtranslate2Weight(callback:Callable[[float], None]) -> None:
th_download = Thread(target=model.downloadCTranslate2ModelWeight, args=(callback,))
@@ -1556,6 +1598,10 @@ class Controller:
model.startCheckMuteSelfStatus()
# init Auto device selection
device_manager.setCallbackHostList(self.updateMicHostList)
device_manager.setCallbackMicDeviceList(self.updateMicDeviceList)
device_manager.setCallbackSpeakerDeviceList(self.updateSpeakerDeviceList)
printLog("Init Auto Device Selection")
if config.AUTO_MIC_SELECT is True:
self.setEnableAutoMicSelect()
@@ -1563,8 +1609,4 @@ class Controller:
if config.AUTO_SPEAKER_SELECT is True:
self.setEnableAutoSpeakerSelect()
device_manager.setCallbackHostList(self.updateMicHostList)
device_manager.setCallbackMicDeviceList(self.updateMicDeviceList)
device_manager.setCallbackSpeakerDeviceList(self.updateSpeakerDeviceList)
printLog("End Initialization")