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

[fix] Model: Handle cases where selected microphone or speaker devices are not available

Browse Source
This commit is contained in:
misyaguziya
2025-03-22 17:20:26 +09:00
parent 863baddad0
commit 7a3a2cfe07
1 changed files with 180 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

357
src-python/model.py
View File

@@ -396,83 +396,83 @@ class Model:
mic_device_list = device_manager.getMicDevices().get(mic_host_name, [{"name": "NoDevice"}]) 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] selected_mic_device = [device for device in mic_device_list if device["name"] == mic_device_name]
if len(selected_mic_device) == 0: if len(selected_mic_device) == 0 or mic_device_name == "NoDevice":
return False fnc({"text": False, "language": None})
else:
self.mic_audio_queue = Queue()
# self.mic_energy_queue = Queue()
self.mic_audio_queue = Queue() mic_device = selected_mic_device[0]
# self.mic_energy_queue = Queue() record_timeout = config.MIC_RECORD_TIMEOUT
phrase_timeout = config.MIC_PHRASE_TIMEOUT
if record_timeout > phrase_timeout:
record_timeout = phrase_timeout
mic_device = selected_mic_device[0] self.mic_audio_recorder = SelectedMicEnergyAndAudioRecorder(
record_timeout = config.MIC_RECORD_TIMEOUT device=mic_device,
phrase_timeout = config.MIC_PHRASE_TIMEOUT energy_threshold=config.MIC_THRESHOLD,
if record_timeout > phrase_timeout: dynamic_energy_threshold=config.MIC_AUTOMATIC_THRESHOLD,
record_timeout = phrase_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)
self.mic_transcriber = AudioTranscriber(
speaker=False,
source=self.mic_audio_recorder.source,
phrase_timeout=phrase_timeout,
max_phrases=config.MIC_MAX_PHRASES,
transcription_engine=config.SELECTED_TRANSCRIPTION_ENGINE,
root=config.PATH_LOCAL,
whisper_weight_type=config.WHISPER_WEIGHT_TYPE,
device=config.SELECTED_TRANSCRIPTION_COMPUTE_DEVICE["device"],
device_index=config.SELECTED_TRANSCRIPTION_COMPUTE_DEVICE["device_index"],
)
def sendMicTranscript():
try:
selected_your_languages = config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO]
languages = [data["language"] for data in selected_your_languages.values() if data["enable"] is True]
countries = [data["country"] for data in selected_your_languages.values() if data["enable"] is True]
if isinstance(self.mic_transcriber, AudioTranscriber) is True:
res = self.mic_transcriber.transcribeAudioQueue(
self.mic_audio_queue,
languages,
countries,
config.MIC_AVG_LOGPROB,
config.MIC_NO_SPEECH_PROB
)
if res:
result = self.mic_transcriber.getTranscript()
fnc(result)
except Exception:
errorLogging()
self.mic_audio_recorder = SelectedMicEnergyAndAudioRecorder( def endMicTranscript():
device=mic_device, while not self.mic_audio_queue.empty():
energy_threshold=config.MIC_THRESHOLD, self.mic_audio_queue.get()
dynamic_energy_threshold=config.MIC_AUTOMATIC_THRESHOLD, # while not self.mic_energy_queue.empty():
phrase_time_limit=record_timeout, # self.mic_energy_queue.get()
) self.mic_transcriber = None
# self.mic_audio_recorder.recordIntoQueue(self.mic_audio_queue, mic_energy_queue) gc.collect()
self.mic_audio_recorder.recordIntoQueue(self.mic_audio_queue, None)
self.mic_transcriber = AudioTranscriber(
speaker=False,
source=self.mic_audio_recorder.source,
phrase_timeout=phrase_timeout,
max_phrases=config.MIC_MAX_PHRASES,
transcription_engine=config.SELECTED_TRANSCRIPTION_ENGINE,
root=config.PATH_LOCAL,
whisper_weight_type=config.WHISPER_WEIGHT_TYPE,
device=config.SELECTED_TRANSCRIPTION_COMPUTE_DEVICE["device"],
device_index=config.SELECTED_TRANSCRIPTION_COMPUTE_DEVICE["device_index"],
)
def sendMicTranscript():
try:
selected_your_languages = config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO]
languages = [data["language"] for data in selected_your_languages.values() if data["enable"] is True]
countries = [data["country"] for data in selected_your_languages.values() if data["enable"] is True]
if isinstance(self.mic_transcriber, AudioTranscriber) is True:
res = self.mic_transcriber.transcribeAudioQueue(
self.mic_audio_queue,
languages,
countries,
config.MIC_AVG_LOGPROB,
config.MIC_NO_SPEECH_PROB
)
if res:
result = self.mic_transcriber.getTranscript()
fnc(result)
except Exception:
errorLogging()
def endMicTranscript(): # def sendMicEnergy():
while not self.mic_audio_queue.empty(): # if mic_energy_queue.empty() is False:
self.mic_audio_queue.get() # energy = mic_energy_queue.get()
# while not self.mic_energy_queue.empty(): # # print("mic energy:", energy)
# self.mic_energy_queue.get() # try:
self.mic_transcriber = None # fnc(energy)
gc.collect() # except Exception:
# pass
# sleep(0.01)
# def sendMicEnergy(): self.mic_print_transcript = threadFnc(sendMicTranscript, end_fnc=endMicTranscript)
# if mic_energy_queue.empty() is False: self.mic_print_transcript.daemon = True
# energy = mic_energy_queue.get() self.mic_print_transcript.start()
# # print("mic energy:", energy)
# try:
# fnc(energy)
# except Exception:
# pass
# sleep(0.01)
self.mic_print_transcript = threadFnc(sendMicTranscript, end_fnc=endMicTranscript) # self.mic_get_energy = threadFnc(sendMicEnergy)
self.mic_print_transcript.daemon = True # self.mic_get_energy.daemon = True
self.mic_print_transcript.start() # self.mic_get_energy.start()
# self.mic_get_energy = threadFnc(sendMicEnergy) self.changeMicTranscriptStatus()
# self.mic_get_energy.daemon = True
# self.mic_get_energy.start()
self.changeMicTranscriptStatus()
def resumeMicTranscript(self): def resumeMicTranscript(self):
# キューをクリア # キューをクリア
@@ -531,25 +531,25 @@ class Model:
mic_device_list = device_manager.getMicDevices().get(mic_host_name, [{"name": "NoDevice"}]) 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] selected_mic_device = [device for device in mic_device_list if device["name"] == mic_device_name]
if len(selected_mic_device) == 0: if len(selected_mic_device) == 0 or mic_device_name == "NoDevice":
return False self.check_mic_energy_fnc(False)
else:
def sendMicEnergy():
if mic_energy_queue.empty() is False:
energy = mic_energy_queue.get()
try:
self.check_mic_energy_fnc(energy)
except Exception:
errorLogging()
sleep(0.01)
def sendMicEnergy(): mic_energy_queue = Queue()
if mic_energy_queue.empty() is False: mic_device = selected_mic_device[0]
energy = mic_energy_queue.get() self.mic_energy_recorder = SelectedMicEnergyRecorder(mic_device)
try: self.mic_energy_recorder.recordIntoQueue(mic_energy_queue)
self.check_mic_energy_fnc(energy) self.mic_energy_plot_progressbar = threadFnc(sendMicEnergy)
except Exception: self.mic_energy_plot_progressbar.daemon = True
errorLogging() self.mic_energy_plot_progressbar.start()
sleep(0.01)
mic_energy_queue = Queue()
mic_device = selected_mic_device[0]
self.mic_energy_recorder = SelectedMicEnergyRecorder(mic_device)
self.mic_energy_recorder.recordIntoQueue(mic_energy_queue)
self.mic_energy_plot_progressbar = threadFnc(sendMicEnergy)
self.mic_energy_plot_progressbar.daemon = True
self.mic_energy_plot_progressbar.start()
def stopCheckMicEnergy(self): def stopCheckMicEnergy(self):
if isinstance(self.mic_energy_plot_progressbar, threadFnc): if isinstance(self.mic_energy_plot_progressbar, threadFnc):
@@ -562,83 +562,85 @@ class Model:
self.mic_energy_recorder = None self.mic_energy_recorder = None
def startSpeakerTranscript(self, fnc): def startSpeakerTranscript(self, fnc):
speaker_device_name = config.SELECTED_SPEAKER_DEVICE
speaker_device_list = device_manager.getSpeakerDevices() speaker_device_list = device_manager.getSpeakerDevices()
selected_speaker_device = [device for device in speaker_device_list if device["name"] == config.SELECTED_SPEAKER_DEVICE] selected_speaker_device = [device for device in speaker_device_list if device["name"] == speaker_device_name]
if len(selected_speaker_device) == 0: if len(selected_speaker_device) == 0 or speaker_device_name == "NoDevice":
return False fnc({"text": False, "language": None})
else:
speaker_audio_queue = Queue()
# speaker_energy_queue = Queue()
speaker_device = selected_speaker_device[0]
record_timeout = config.SPEAKER_RECORD_TIMEOUT
phrase_timeout = config.SPEAKER_PHRASE_TIMEOUT
if record_timeout > phrase_timeout:
record_timeout = phrase_timeout
speaker_audio_queue = Queue() self.speaker_audio_recorder = SelectedSpeakerEnergyAndAudioRecorder(
# speaker_energy_queue = Queue() device=speaker_device,
speaker_device = selected_speaker_device[0] energy_threshold=config.SPEAKER_THRESHOLD,
record_timeout = config.SPEAKER_RECORD_TIMEOUT dynamic_energy_threshold=config.SPEAKER_AUTOMATIC_THRESHOLD,
phrase_timeout = config.SPEAKER_PHRASE_TIMEOUT phrase_time_limit=record_timeout,
if record_timeout > phrase_timeout: )
record_timeout = phrase_timeout # self.speaker_audio_recorder.recordIntoQueue(speaker_audio_queue, speaker_energy_queue)
self.speaker_audio_recorder.recordIntoQueue(speaker_audio_queue, None)
self.speaker_transcriber = AudioTranscriber(
speaker=True,
source=self.speaker_audio_recorder.source,
phrase_timeout=phrase_timeout,
max_phrases=config.SPEAKER_MAX_PHRASES,
transcription_engine=config.SELECTED_TRANSCRIPTION_ENGINE,
root=config.PATH_LOCAL,
whisper_weight_type=config.WHISPER_WEIGHT_TYPE,
device=config.SELECTED_TRANSCRIPTION_COMPUTE_DEVICE["device"],
device_index=config.SELECTED_TRANSCRIPTION_COMPUTE_DEVICE["device_index"],
)
def sendSpeakerTranscript():
try:
selected_target_languages = config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]
languages = [data["language"] for data in selected_target_languages.values() if data["enable"] is True]
countries = [data["country"] for data in selected_target_languages.values() if data["enable"] is True]
if isinstance(self.speaker_transcriber, AudioTranscriber) is True:
res = self.speaker_transcriber.transcribeAudioQueue(
speaker_audio_queue,
languages,
countries,
config.SPEAKER_AVG_LOGPROB,
config.SPEAKER_NO_SPEECH_PROB
)
if res:
result = self.speaker_transcriber.getTranscript()
fnc(result)
except Exception:
errorLogging()
self.speaker_audio_recorder = SelectedSpeakerEnergyAndAudioRecorder( def endSpeakerTranscript():
device=speaker_device, while not speaker_audio_queue.empty():
energy_threshold=config.SPEAKER_THRESHOLD, speaker_audio_queue.get()
dynamic_energy_threshold=config.SPEAKER_AUTOMATIC_THRESHOLD, # while not speaker_energy_queue.empty():
phrase_time_limit=record_timeout, # speaker_energy_queue.get()
) self.speaker_transcriber = None
# self.speaker_audio_recorder.recordIntoQueue(speaker_audio_queue, speaker_energy_queue) gc.collect()
self.speaker_audio_recorder.recordIntoQueue(speaker_audio_queue, None)
self.speaker_transcriber = AudioTranscriber(
speaker=True,
source=self.speaker_audio_recorder.source,
phrase_timeout=phrase_timeout,
max_phrases=config.SPEAKER_MAX_PHRASES,
transcription_engine=config.SELECTED_TRANSCRIPTION_ENGINE,
root=config.PATH_LOCAL,
whisper_weight_type=config.WHISPER_WEIGHT_TYPE,
device=config.SELECTED_TRANSCRIPTION_COMPUTE_DEVICE["device"],
device_index=config.SELECTED_TRANSCRIPTION_COMPUTE_DEVICE["device_index"],
)
def sendSpeakerTranscript():
try:
selected_target_languages = config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]
languages = [data["language"] for data in selected_target_languages.values() if data["enable"] is True]
countries = [data["country"] for data in selected_target_languages.values() if data["enable"] is True]
if isinstance(self.speaker_transcriber, AudioTranscriber) is True:
res = self.speaker_transcriber.transcribeAudioQueue(
speaker_audio_queue,
languages,
countries,
config.SPEAKER_AVG_LOGPROB,
config.SPEAKER_NO_SPEECH_PROB
)
if res:
result = self.speaker_transcriber.getTranscript()
fnc(result)
except Exception:
errorLogging()
def endSpeakerTranscript(): # def sendSpeakerEnergy():
while not speaker_audio_queue.empty(): # if speaker_energy_queue.empty() is False:
speaker_audio_queue.get() # energy = speaker_energy_queue.get()
# while not speaker_energy_queue.empty(): # # print("speaker energy:", energy)
# speaker_energy_queue.get() # try:
self.speaker_transcriber = None # fnc(energy)
gc.collect() # except Exception:
# pass
# sleep(0.01)
# def sendSpeakerEnergy(): self.speaker_print_transcript = threadFnc(sendSpeakerTranscript, end_fnc=endSpeakerTranscript)
# if speaker_energy_queue.empty() is False: self.speaker_print_transcript.daemon = True
# energy = speaker_energy_queue.get() self.speaker_print_transcript.start()
# # print("speaker energy:", energy)
# try:
# fnc(energy)
# except Exception:
# pass
# sleep(0.01)
self.speaker_print_transcript = threadFnc(sendSpeakerTranscript, end_fnc=endSpeakerTranscript) # self.speaker_get_energy = threadFnc(sendSpeakerEnergy)
self.speaker_print_transcript.daemon = True # self.speaker_get_energy.daemon = True
self.speaker_print_transcript.start() # self.speaker_get_energy.start()
# self.speaker_get_energy = threadFnc(sendSpeakerEnergy)
# self.speaker_get_energy.daemon = True
# self.speaker_get_energy.start()
def stopSpeakerTranscript(self): def stopSpeakerTranscript(self):
if isinstance(self.speaker_print_transcript, threadFnc): if isinstance(self.speaker_print_transcript, threadFnc):
@@ -656,28 +658,29 @@ class Model:
if isinstance(fnc, Callable): if isinstance(fnc, Callable):
self.check_speaker_energy_fnc = fnc self.check_speaker_energy_fnc = fnc
speaker_device_name = config.SELECTED_SPEAKER_DEVICE
speaker_device_list = device_manager.getSpeakerDevices() speaker_device_list = device_manager.getSpeakerDevices()
selected_speaker_device = [device for device in speaker_device_list if device["name"] == config.SELECTED_SPEAKER_DEVICE] selected_speaker_device = [device for device in speaker_device_list if device["name"] == speaker_device_name]
if len(selected_speaker_device) == 0: if len(selected_speaker_device) == 0 or speaker_device_name == "NoDevice":
return False self.check_speaker_energy_fnc(False)
else:
def sendSpeakerEnergy():
if speaker_energy_queue.empty() is False:
energy = speaker_energy_queue.get()
try:
self.check_speaker_energy_fnc(energy)
except Exception:
errorLogging()
sleep(0.01)
def sendSpeakerEnergy(): speaker_energy_queue = Queue()
if speaker_energy_queue.empty() is False: speaker_device = selected_speaker_device[0]
energy = speaker_energy_queue.get() self.speaker_energy_recorder = SelectedSpeakerEnergyRecorder(speaker_device)
try: self.speaker_energy_recorder.recordIntoQueue(speaker_energy_queue)
self.check_speaker_energy_fnc(energy) self.speaker_energy_plot_progressbar = threadFnc(sendSpeakerEnergy)
except Exception: self.speaker_energy_plot_progressbar.daemon = True
errorLogging() self.speaker_energy_plot_progressbar.start()
sleep(0.01)
speaker_energy_queue = Queue()
speaker_device = selected_speaker_device[0]
self.speaker_energy_recorder = SelectedSpeakerEnergyRecorder(speaker_device)
self.speaker_energy_recorder.recordIntoQueue(speaker_energy_queue)
self.speaker_energy_plot_progressbar = threadFnc(sendSpeakerEnergy)
self.speaker_energy_plot_progressbar.daemon = True
self.speaker_energy_plot_progressbar.start()
def stopCheckSpeakerEnergy(self): def stopCheckSpeakerEnergy(self):
if isinstance(self.speaker_energy_plot_progressbar, threadFnc): if isinstance(self.speaker_energy_plot_progressbar, threadFnc):