seedlingattempt/godot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #110481 from Cheeseness/73671_backport

Browse Source 
[3.x] Process TTS callback on the main thread to avoid speech-dispatcher deadlock
This commit is contained in:
Rémi Verschelde
2025-10-28 09:42:57 +01:00
parent cfff242da2 13ea0d64a5
commit e2621e5517
2 changed files with 78 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
platform/x11/tts_linux.cpp
View File

@ -34,6 +34,11 @@
TTS_Linux *TTS_Linux::singleton = nullptr; TTS_Linux *TTS_Linux::singleton = nullptr;
void TTS_Linux::_bind_methods() {
ClassDB::bind_method(D_METHOD("_speech_event", "msg_id", "client_id", "type"), &TTS_Linux::_speech_event);
ClassDB::bind_method(D_METHOD("_speech_index_mark", "msg_id", "client_id", "type", "index_mark"), &TTS_Linux::_speech_index_mark);
}
static bool _is_whitespace(CharType c) { static bool _is_whitespace(CharType c) {
return c == '\t' || c == ' '; return c == '\t' || c == ' ';
} }
@ -75,43 +80,56 @@ void TTS_Linux::speech_init_thread_func(void *p_userdata) {
void TTS_Linux::speech_event_index_mark(size_t p_msg_id, size_t p_client_id, SPDNotificationType p_type, char *p_index_mark) { void TTS_Linux::speech_event_index_mark(size_t p_msg_id, size_t p_client_id, SPDNotificationType p_type, char *p_index_mark) {
TTS_Linux *tts = TTS_Linux::get_singleton(); TTS_Linux *tts = TTS_Linux::get_singleton();
if (tts && tts->ids.has(p_msg_id)) { if (tts) {
MutexLock thread_safe_method(tts->_thread_safe_); tts->call_deferred("_speech_index_mark", p_msg_id, p_client_id, (int)p_type, String::utf8(p_index_mark));
// Get word offset from the index mark injected to the text stream. }
String mark = String::utf8(p_index_mark); }
OS::get_singleton()->tts_post_utterance_event(OS::TTS_UTTERANCE_BOUNDARY, tts->ids[p_msg_id], mark.to_int());
void TTS_Linux::_speech_index_mark(size_t p_msg_id, size_t p_client_id, int p_type, const String &p_index_mark) {
_THREAD_SAFE_METHOD_
if (ids.has(p_msg_id)) {
OS::get_singleton()->tts_post_utterance_event(OS::TTS_UTTERANCE_BOUNDARY, ids[p_msg_id], p_index_mark.to_int());
} }
} }
void TTS_Linux::speech_event_callback(size_t p_msg_id, size_t p_client_id, SPDNotificationType p_type) { void TTS_Linux::speech_event_callback(size_t p_msg_id, size_t p_client_id, SPDNotificationType p_type) {
TTS_Linux *tts = TTS_Linux::get_singleton(); TTS_Linux *tts = TTS_Linux::get_singleton();
if (tts) { if (tts) {
MutexLock thread_safe_method(tts->_thread_safe_); tts->call_deferred("_speech_event", p_msg_id, p_client_id, (int)p_type);
List<OS::TTSUtterance> &queue = tts->queue; }
if (!tts->paused && tts->ids.has(p_msg_id)) { }
if (p_type == SPD_EVENT_END) {
OS::get_singleton()->tts_post_utterance_event(OS::TTS_UTTERANCE_ENDED, tts->ids[p_msg_id]); void TTS_Linux::_speech_event(size_t p_msg_id, size_t p_client_id, int p_type) {
tts->ids.erase(p_msg_id); _THREAD_SAFE_METHOD_
tts->last_msg_id = -1;
tts->speaking = false; if (!paused && ids.has(p_msg_id)) {
} else if (p_type == SPD_EVENT_CANCEL) { if ((SPDNotificationType)p_type == SPD_EVENT_END) {
OS::get_singleton()->tts_post_utterance_event(OS::TTS_UTTERANCE_CANCELED, tts->ids[p_msg_id]); OS::get_singleton()->tts_post_utterance_event(OS::TTS_UTTERANCE_ENDED, ids[p_msg_id]);
tts->ids.erase(p_msg_id); ids.erase(p_msg_id);
tts->last_msg_id = -1; last_msg_id = -1;
tts->speaking = false; speaking = false;
} else if ((SPDNotificationType)p_type == SPD_EVENT_CANCEL) {
OS::get_singleton()->tts_post_utterance_event(OS::TTS_UTTERANCE_CANCELED, ids[p_msg_id]);
ids.erase(p_msg_id);
last_msg_id = -1;
speaking = false;
} }
} }
if (!tts->speaking && queue.size() > 0) { if (!speaking && queue.size() > 0) {
OS::TTSUtterance &message = queue.front()->get(); OS::TTSUtterance &message = queue.front()->get();
// Inject index mark after each word. // Inject index mark after each word.
String text; String text;
// Inject index mark after each word.
PoolIntArray breaks; PoolIntArray breaks;
for (int i = 0; i < message.text.size(); i++) { for (int i = 0; i < message.text.size(); i++) {
if (_is_whitespace(message.text[i])) { if (_is_whitespace(message.text[i])) {
breaks.push_back(i); breaks.push_back(i);
} }
} }
int prev = 0; int prev = 0;
for (int i = 0; i < breaks.size(); i++) { for (int i = 0; i < breaks.size(); i++) {
text += message.text.substr(prev, breaks[i] - prev); text += message.text.substr(prev, breaks[i] - prev);
@ -120,24 +138,23 @@ void TTS_Linux::speech_event_callback(size_t p_msg_id, size_t p_client_id, SPDNo
} }
text += message.text.substr(prev, -1); text += message.text.substr(prev, -1);
spd_set_synthesis_voice(tts->synth, message.voice.utf8().get_data()); spd_set_synthesis_voice(synth, message.voice.utf8().get_data());
spd_set_volume(tts->synth, message.volume * 2 - 100); spd_set_volume(synth, message.volume * 2 - 100);
spd_set_voice_pitch(tts->synth, (message.pitch - 1) * 100); spd_set_voice_pitch(synth, (message.pitch - 1) * 100);
float rate = 0; float rate = 0;
if (message.rate > 1.f) { if (message.rate > 1.f) {
rate = log10(MIN(message.rate, 2.5f)) / log10(2.5f) * 100; rate = log10(MIN(message.rate, 2.5f)) / log10(2.5f) * 100;
} else if (message.rate < 1.f) { } else if (message.rate < 1.f) {
rate = log10(MAX(message.rate, 0.5f)) / log10(0.5f) * -100; rate = log10(MAX(message.rate, 0.5f)) / log10(0.5f) * -100;
} }
spd_set_voice_rate(tts->synth, rate); spd_set_voice_rate(synth, rate);
spd_set_data_mode(tts->synth, SPD_DATA_SSML); spd_set_data_mode(synth, SPD_DATA_SSML);
tts->last_msg_id = spd_say(tts->synth, SPD_TEXT, text.utf8().get_data()); last_msg_id = spd_say(synth, SPD_TEXT, text.utf8().get_data());
tts->ids[tts->last_msg_id] = message.id; ids[last_msg_id] = message.id;
OS::get_singleton()->tts_post_utterance_event(OS::TTS_UTTERANCE_STARTED, message.id); OS::get_singleton()->tts_post_utterance_event(OS::TTS_UTTERANCE_STARTED, message.id);
queue.pop_front(); queue.pop_front();
tts->speaking = true; speaking = true;
}
} }
} }
@ -196,7 +213,7 @@ void TTS_Linux::speak(const String &p_text, const String &p_voice, int p_volume,
if (is_paused()) { if (is_paused()) {
resume(); resume();
} else { } else {
speech_event_callback(0, 0, SPD_EVENT_BEGIN); _speech_event(0, 0, (int)SPD_EVENT_BEGIN);
} }
} }

8
platform/x11/tts_linux.h
View File

@ -41,7 +41,8 @@
#include "speechd-so_wrap.h" #include "speechd-so_wrap.h"
class TTS_Linux { class TTS_Linux : public Object {
GDCLASS(TTS_Linux, Object);
_THREAD_SAFE_CLASS_ _THREAD_SAFE_CLASS_
List<OS::TTSUtterance> queue; List<OS::TTSUtterance> queue;
@ -59,6 +60,11 @@ class TTS_Linux {
static TTS_Linux *singleton; static TTS_Linux *singleton;
protected:
static void _bind_methods();
void _speech_event(size_t p_msg_id, size_t p_client_id, int p_type);
void _speech_index_mark(size_t p_msg_id, size_t p_client_id, int p_type, const String &p_index_mark);
public: public:
static TTS_Linux *get_singleton(); static TTS_Linux *get_singleton();