412 lines
13 KiB
C++
412 lines
13 KiB
C++
/***************************************************************************
|
|
* __________ __ ___.
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
* \/ \/ \/ \/ \/
|
|
*
|
|
* Copyright (C) 2007 by Dominik Wenger
|
|
*
|
|
* All files in this archive are subject to the GNU General Public License.
|
|
* See the file COPYING in the source tree root for full license agreement.
|
|
*
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
* KIND, either express or implied.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#include <QtCore>
|
|
#include <QTcpSocket>
|
|
|
|
#include "ttsfestival.h"
|
|
#include "utils.h"
|
|
#include "rbsettings.h"
|
|
#include "Logger.h"
|
|
|
|
TTSFestival::~TTSFestival()
|
|
{
|
|
LOG_INFO() << "Destroying instance";
|
|
stop();
|
|
}
|
|
|
|
TTSBase::Capabilities TTSFestival::capabilities()
|
|
{
|
|
return RunInParallel;
|
|
}
|
|
|
|
void TTSFestival::generateSettings()
|
|
{
|
|
// server path
|
|
QString exepath = RbSettings::subValue("festival-server",
|
|
RbSettings::TtsPath).toString();
|
|
if(exepath == "" ) exepath = Utils::findExecutable("festival");
|
|
insertSetting(eSERVERPATH,new EncTtsSetting(this,
|
|
EncTtsSetting::eSTRING, "Path to Festival server:",
|
|
exepath,EncTtsSetting::eBROWSEBTN));
|
|
|
|
// client path
|
|
QString clientpath = RbSettings::subValue("festival-client",
|
|
RbSettings::TtsPath).toString();
|
|
if(clientpath == "" ) clientpath = Utils::findExecutable("festival_client");
|
|
insertSetting(eCLIENTPATH,new EncTtsSetting(this,EncTtsSetting::eSTRING,
|
|
tr("Path to Festival client:"),
|
|
clientpath,EncTtsSetting::eBROWSEBTN));
|
|
|
|
// voice
|
|
EncTtsSetting* setting = new EncTtsSetting(this,
|
|
EncTtsSetting::eSTRINGLIST, tr("Voice:"),
|
|
RbSettings::subValue("festival", RbSettings::TtsVoice),
|
|
getVoiceList(), EncTtsSetting::eREFRESHBTN);
|
|
connect(setting, &EncTtsSetting::refresh,
|
|
this, &TTSFestival::updateVoiceList);
|
|
connect(setting, &EncTtsSetting::dataChanged,
|
|
this, &TTSFestival::clearVoiceDescription);
|
|
insertSetting(eVOICE,setting);
|
|
|
|
//voice description
|
|
setting = new EncTtsSetting(this,EncTtsSetting::eREADONLYSTRING,
|
|
tr("Voice description:"),"",EncTtsSetting::eREFRESHBTN);
|
|
connect(setting, &EncTtsSetting::refresh,
|
|
this, &TTSFestival::updateVoiceDescription);
|
|
insertSetting(eVOICEDESC,setting);
|
|
}
|
|
|
|
void TTSFestival::saveSettings()
|
|
{
|
|
//save settings in user config
|
|
RbSettings::setSubValue("festival-server",
|
|
RbSettings::TtsPath,getSetting(eSERVERPATH)->current().toString());
|
|
RbSettings::setSubValue("festival-client",
|
|
RbSettings::TtsPath,getSetting(eCLIENTPATH)->current().toString());
|
|
RbSettings::setSubValue("festival",
|
|
RbSettings::TtsVoice,getSetting(eVOICE)->current().toString());
|
|
|
|
RbSettings::sync();
|
|
}
|
|
|
|
void TTSFestival::updateVoiceDescription()
|
|
{
|
|
// get voice Info with current voice and path
|
|
currentPath = getSetting(eSERVERPATH)->current().toString();
|
|
QString info = getVoiceInfo(getSetting(eVOICE)->current().toString());
|
|
currentPath = "";
|
|
|
|
getSetting(eVOICEDESC)->setCurrent(info);
|
|
}
|
|
|
|
void TTSFestival::clearVoiceDescription()
|
|
{
|
|
getSetting(eVOICEDESC)->setCurrent("");
|
|
}
|
|
|
|
void TTSFestival::updateVoiceList()
|
|
{
|
|
currentPath = getSetting(eSERVERPATH)->current().toString();
|
|
QStringList voiceList = getVoiceList();
|
|
currentPath = "";
|
|
|
|
getSetting(eVOICE)->setList(voiceList);
|
|
if(voiceList.size() > 0) getSetting(eVOICE)->setCurrent(voiceList.at(0));
|
|
else getSetting(eVOICE)->setCurrent("");
|
|
}
|
|
|
|
void TTSFestival::startServer()
|
|
{
|
|
if(!configOk())
|
|
return;
|
|
|
|
if(serverProcess.state() != QProcess::Running)
|
|
{
|
|
QString path;
|
|
/* currentPath is set by the GUI - if it's set, it is the currently set
|
|
path in the configuration GUI; if it's not set, use the saved path */
|
|
if (currentPath == "")
|
|
path = RbSettings::subValue("festival-server",RbSettings::TtsPath).toString();
|
|
else
|
|
path = currentPath;
|
|
|
|
serverProcess.start(QString("%1 --server").arg(path));
|
|
serverProcess.waitForStarted();
|
|
|
|
/* A friendlier version of a spinlock */
|
|
while (serverProcess.processId() == 0 && serverProcess.state() != QProcess::Running)
|
|
QCoreApplication::processEvents(QEventLoop::AllEvents, 50);
|
|
|
|
if(serverProcess.state() == QProcess::Running)
|
|
LOG_INFO() << "Server is up and running";
|
|
else
|
|
LOG_ERROR() << "Server failed to start, state:"
|
|
<< serverProcess.state();
|
|
}
|
|
}
|
|
|
|
bool TTSFestival::ensureServerRunning()
|
|
{
|
|
if(serverProcess.state() != QProcess::Running)
|
|
{
|
|
startServer();
|
|
}
|
|
return serverProcess.state() == QProcess::Running;
|
|
}
|
|
|
|
bool TTSFestival::start(QString* errStr)
|
|
{
|
|
LOG_INFO() << "Starting server with voice"
|
|
<< RbSettings::subValue("festival", RbSettings::TtsVoice).toString();
|
|
|
|
bool running = ensureServerRunning();
|
|
if (!RbSettings::subValue("festival",RbSettings::TtsVoice).toString().isEmpty())
|
|
{
|
|
/* There's no harm in using both methods to set the voice .. */
|
|
QString voiceSelect = QString("(voice.select '%1)\n")
|
|
.arg(RbSettings::subValue("festival", RbSettings::TtsVoice).toString());
|
|
queryServer(voiceSelect, 3000);
|
|
|
|
if(prologFile.open())
|
|
{
|
|
prologFile.write(voiceSelect.toLatin1());
|
|
prologFile.close();
|
|
prologPath = QFileInfo(prologFile).absoluteFilePath();
|
|
LOG_INFO() << "Prolog created at" << prologPath;
|
|
}
|
|
|
|
}
|
|
|
|
if (!running)
|
|
(*errStr) = "Festival could not be started";
|
|
return running;
|
|
}
|
|
|
|
bool TTSFestival::stop()
|
|
{
|
|
serverProcess.terminate();
|
|
serverProcess.kill();
|
|
|
|
return true;
|
|
}
|
|
|
|
TTSStatus TTSFestival::voice(QString text, QString wavfile, QString* errStr)
|
|
{
|
|
LOG_INFO() << "Voicing" << text << "->" << wavfile;
|
|
|
|
QString path = RbSettings::subValue("festival-client",
|
|
RbSettings::TtsPath).toString();
|
|
QString cmd = QString("%1 --server localhost --otype riff --ttw --withlisp"
|
|
" --output \"%2\" --prolog \"%3\" - ").arg(path, wavfile, prologPath);
|
|
LOG_INFO() << "Client cmd:" << cmd;
|
|
|
|
QProcess clientProcess;
|
|
clientProcess.start(cmd);
|
|
clientProcess.write(QString("%1.\n").arg(text).toLatin1());
|
|
clientProcess.waitForBytesWritten();
|
|
clientProcess.closeWriteChannel();
|
|
clientProcess.waitForReadyRead();
|
|
QString response = clientProcess.readAll();
|
|
response = response.trimmed();
|
|
if(!response.contains("Utterance"))
|
|
{
|
|
LOG_WARNING() << "Could not voice string: " << response;
|
|
*errStr = tr("engine could not voice string");
|
|
return Warning;
|
|
/* do not stop the voicing process because of a single string
|
|
TODO: needs proper settings */
|
|
}
|
|
clientProcess.closeReadChannel(QProcess::StandardError);
|
|
clientProcess.closeReadChannel(QProcess::StandardOutput);
|
|
clientProcess.terminate();
|
|
clientProcess.kill();
|
|
|
|
return NoError;
|
|
}
|
|
|
|
bool TTSFestival::configOk()
|
|
{
|
|
bool ret;
|
|
if (currentPath == "")
|
|
{
|
|
QString serverPath = RbSettings::subValue("festival-server",
|
|
RbSettings::TtsPath).toString();
|
|
QString clientPath = RbSettings::subValue("festival-client",
|
|
RbSettings::TtsPath).toString();
|
|
|
|
ret = QFileInfo(serverPath).isExecutable() &&
|
|
QFileInfo(clientPath).isExecutable();
|
|
if(RbSettings::subValue("festival",RbSettings::TtsVoice).toString().size() > 0
|
|
&& voices.size() > 0)
|
|
ret = ret && (voices.indexOf(RbSettings::subValue("festival",
|
|
RbSettings::TtsVoice).toString()) != -1);
|
|
}
|
|
else /* If we're currently configuring the server, we need to know that
|
|
the entered path is valid */
|
|
ret = QFileInfo(currentPath).isExecutable();
|
|
|
|
return ret;
|
|
}
|
|
|
|
QStringList TTSFestival::getVoiceList()
|
|
{
|
|
if(!configOk())
|
|
return QStringList();
|
|
|
|
if(voices.size() > 0)
|
|
{
|
|
LOG_INFO() << "Using voice cache";
|
|
return voices;
|
|
}
|
|
|
|
QString response = queryServer("(voice.list)", 10000);
|
|
|
|
// get the 2nd line. It should be (<voice_name>, <voice_name>)
|
|
response = response.mid(response.indexOf('\n') + 1, -1);
|
|
response = response.left(response.indexOf('\n')).trimmed();
|
|
|
|
voices = response.mid(1, response.size()-2).split(' ');
|
|
|
|
voices.sort();
|
|
if (voices.size() == 1 && voices[0].size() == 0)
|
|
voices.removeAt(0);
|
|
if (voices.size() > 0)
|
|
LOG_INFO() << "Voices:" << voices;
|
|
else
|
|
LOG_WARNING() << "No voices. Response was:" << response;
|
|
|
|
return voices;
|
|
}
|
|
|
|
QString TTSFestival::getVoiceInfo(QString voice)
|
|
{
|
|
if(!configOk())
|
|
return "";
|
|
|
|
if(!getVoiceList().contains(voice))
|
|
return "";
|
|
|
|
if(voiceDescriptions.contains(voice))
|
|
return voiceDescriptions[voice];
|
|
|
|
QString response = queryServer(QString("(voice.description '%1)").arg(voice),
|
|
10000);
|
|
|
|
if (response == "")
|
|
{
|
|
voiceDescriptions[voice]=tr("No description available");
|
|
}
|
|
else
|
|
{
|
|
response = response.remove(QRegularExpression("(description \".*\")",
|
|
QRegularExpression::CaseInsensitiveOption));
|
|
LOG_INFO() << "voiceInfo w/o descr:" << response;
|
|
response = response.remove(')');
|
|
#if QT_VERSION >= 0x050e00
|
|
QStringList responseLines = response.split('(', Qt::SkipEmptyParts);
|
|
#else
|
|
QStringList responseLines = response.split('(', QString::SkipEmptyParts);
|
|
#endif
|
|
responseLines.removeAt(0); // the voice name itself
|
|
|
|
QString description;
|
|
foreach(QString line, responseLines)
|
|
{
|
|
line = line.remove('(');
|
|
line = line.simplified();
|
|
|
|
line[0] = line[0].toUpper(); // capitalize the key
|
|
|
|
int firstSpace = line.indexOf(' ');
|
|
if (firstSpace > 0)
|
|
{
|
|
// add a colon between the key and the value
|
|
line = line.insert(firstSpace, ':');
|
|
// capitalize the value
|
|
line[firstSpace+2] = line[firstSpace+2].toUpper();
|
|
}
|
|
|
|
description += line + "\n";
|
|
}
|
|
voiceDescriptions[voice] = description.trimmed();
|
|
}
|
|
|
|
return voiceDescriptions[voice];
|
|
}
|
|
|
|
QString TTSFestival::queryServer(QString query, int timeout)
|
|
{
|
|
if(!configOk())
|
|
return "";
|
|
|
|
// this operation could take some time
|
|
emit busy();
|
|
|
|
LOG_INFO() << "queryServer with" << query;
|
|
|
|
if (!ensureServerRunning())
|
|
{
|
|
LOG_ERROR() << "queryServer: ensureServerRunning failed";
|
|
emit busyEnd();
|
|
return "";
|
|
}
|
|
|
|
QString response;
|
|
|
|
QDateTime endTime;
|
|
if(timeout > 0)
|
|
endTime = QDateTime::currentDateTime().addMSecs(timeout);
|
|
|
|
/* Festival is *extremely* unreliable. Although at this
|
|
* point we are sure that SIOD is accepting commands,
|
|
* we might end up with an empty response. Hence, the loop.
|
|
*/
|
|
while(true)
|
|
{
|
|
QCoreApplication::processEvents(QEventLoop::AllEvents, 50);
|
|
QTcpSocket socket;
|
|
|
|
socket.connectToHost("localhost", 1314);
|
|
socket.waitForConnected();
|
|
|
|
if(socket.state() == QAbstractSocket::ConnectedState)
|
|
{
|
|
socket.write(QString("%1\n").arg(query).toLatin1());
|
|
socket.waitForBytesWritten();
|
|
socket.waitForReadyRead();
|
|
|
|
response = socket.readAll().trimmed();
|
|
|
|
if (response != "LP" && response != "")
|
|
break;
|
|
}
|
|
socket.abort();
|
|
socket.disconnectFromHost();
|
|
|
|
if(timeout > 0 && QDateTime::currentDateTime() >= endTime)
|
|
{
|
|
emit busyEnd();
|
|
return "";
|
|
}
|
|
/* make sure we wait a little as we don't want to flood the server
|
|
* with requests */
|
|
QDateTime tmpEndTime = QDateTime::currentDateTime().addMSecs(500);
|
|
while(QDateTime::currentDateTime() < tmpEndTime)
|
|
QCoreApplication::processEvents(QEventLoop::AllEvents);
|
|
}
|
|
if(response == "nil")
|
|
{
|
|
emit busyEnd();
|
|
return "";
|
|
}
|
|
|
|
QStringList lines = response.split('\n');
|
|
if(lines.size() > 2)
|
|
{
|
|
lines.removeFirst(); /* should be LP */
|
|
lines.removeLast(); /* should be ft_StUfF_keyOK */
|
|
}
|
|
else
|
|
LOG_ERROR() << "Response too short:" << response;
|
|
|
|
emit busyEnd();
|
|
return lines.join("\n");
|
|
|
|
}
|
|
|