1 files changed, 281 insertions, 0 deletions
diff --git a/kttsd/plugins/flite/fliteproc.cpp b/kttsd/plugins/flite/fliteproc.cpp
new file mode 100644
index 0000000..54b15e3
--- /dev/null
+++ b/kttsd/plugins/flite/fliteproc.cpp
@@ -0,0 +1,281 @@
+/***************************************************** vim:set ts=4 sw=4 sts=4:
+  Main speaking functions for the Festival Lite (Flite) Plug in
+  -------------------
+  Copyright:
+  (C) 2004 by Gary Cramblitt <garycramblitt@comcast.net>
+  -------------------
+  Original author: Gary Cramblitt <garycramblitt@comcast.net>
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ ******************************************************************************/
+
+// Qt includes.
+#include <qstring.h>
+#include <qstringlist.h>
+
+// KDE includes.
+#include <kdebug.h>
+#include <kconfig.h>
+#include <kstandarddirs.h>
+#include <kprocess.h>
+
+// Flite Plugin includes.
+#include "fliteproc.h"
+#include "fliteproc.moc"
+ 
+/** Constructor */
+FliteProc::FliteProc( QObject* parent, const char* name, const QStringList& ) : 
+    PlugInProc( parent, name ){
+    kdDebug() << "FliteProc::FliteProc: Running" << endl;
+    m_state = psIdle;
+    m_waitingStop = false;
+    m_fliteProc = 0;
+}
+
+/** Destructor */
+FliteProc::~FliteProc(){
+    kdDebug() << "FliteProc::~FliteProc:: Running" << endl;
+    if (m_fliteProc)
+    {
+        stopText();
+        delete m_fliteProc;
+    }
+}
+
+/** Initialize the speech */
+bool FliteProc::init(KConfig* config, const QString& configGroup){
+    // kdDebug() << "Running: FliteProc::init(const QString &lang)" << endl;
+    // kdDebug() << "Initializing plug in: Flite" << endl;
+    // Retrieve path to flite executable.
+    config->setGroup(configGroup);
+    m_fliteExePath = config->readEntry("FliteExePath", "flite");
+    kdDebug() << "FliteProc::init: path to flite: " << m_fliteExePath << endl;
+    return true;
+}
+
+/** 
+* Say a text.  Synthesize and audibilize it.
+* @param text                    The text to be spoken.
+*
+* If the plugin supports asynchronous operation, it should return immediately.
+*/
+void FliteProc::sayText(const QString &text)
+{
+    synth(text, QString::null, m_fliteExePath);
+}
+
+/**
+* Synthesize text into an audio file, but do not send to the audio device.
+* @param text                    The text to be synthesized.
+* @param suggestedFilename       Full pathname of file to create.  The plugin
+*                                may ignore this parameter and choose its own
+*                                filename.  KTTSD will query the generated
+*                                filename using getFilename().
+*
+* If the plugin supports asynchronous operation, it should return immediately.
+*/
+void FliteProc::synthText(const QString& text, const QString& suggestedFilename)
+{
+    synth(text, suggestedFilename, m_fliteExePath);
+}
+
+/**
+* Say or Synthesize text.
+* @param text                    The text to be synthesized.
+* @param suggestedFilename       If not Null, synthesize only to this filename, otherwise
+*                                synthesize and audibilize the text.
+*/
+void FliteProc::synth(
+    const QString &text,
+    const QString &synthFilename,
+    const QString& fliteExePath)
+{
+    // kdDebug() << "Running: FliteProc::synth(const QString &text)" << endl;
+
+    if (m_fliteProc)
+    {
+        if (m_fliteProc->isRunning()) m_fliteProc->kill();
+        delete m_fliteProc;
+        m_fliteProc = 0;
+    }
+    // kdDebug()<< "FliteProc::synth: Creating Flite object" << endl;
+    m_fliteProc = new KProcess;
+    connect(m_fliteProc, SIGNAL(processExited(KProcess*)),
+        this, SLOT(slotProcessExited(KProcess*)));
+    connect(m_fliteProc, SIGNAL(receivedStdout(KProcess*, char*, int)),
+        this, SLOT(slotReceivedStdout(KProcess*, char*, int)));
+    connect(m_fliteProc, SIGNAL(receivedStderr(KProcess*, char*, int)),
+        this, SLOT(slotReceivedStderr(KProcess*, char*, int)));
+    connect(m_fliteProc, SIGNAL(wroteStdin(KProcess*)),
+        this, SLOT(slotWroteStdin(KProcess* )));
+    if (synthFilename.isNull())
+        m_state = psSaying;
+    else
+        m_state = psSynthing;
+
+    
+    // Encode quotation characters.
+    QString saidText = text;
+/*
+    saidText.replace("\\\"", "#!#!");
+    saidText.replace("\"", "\\\"");
+    saidText.replace("#!#!", "\\\"");
+    // Remove certain comment characters.
+    saidText.replace("--", "");
+    saidText = "\"" + saidText + "\"";
+*/
+    saidText += "\n";
+
+    *m_fliteProc << fliteExePath;
+//    *m_fliteProc << "-t" << saidText;
+    if (!synthFilename.isNull()) *m_fliteProc << "-o" << synthFilename;
+    
+    // Ok, let's rock.
+    m_synthFilename = synthFilename;
+    kdDebug() << "FliteProc::synth: Synthing text: '" << saidText << "' using Flite plug in" << endl;
+    if (!m_fliteProc->start(KProcess::NotifyOnExit, KProcess::All))
+    {
+        kdDebug() << "FliteProc::synth: Error starting Flite process.  Is flite in the PATH?" << endl;
+        m_state = psIdle;
+        return;
+    }
+    kdDebug()<< "FliteProc:synth: Flite initialized" << endl;
+    m_fliteProc->writeStdin(saidText.latin1(), saidText.length());
+}
+        
+/**
+* Get the generated audio filename from synthText.
+* @return                        Name of the audio file the plugin generated.
+*                                Null if no such file.
+*
+* The plugin must not re-use the filename.
+*/
+QString FliteProc::getFilename()
+{
+    kdDebug() << "FliteProc::getFilename: returning " << m_synthFilename << endl;
+    return m_synthFilename;
+}
+
+/**
+* Stop current operation (saying or synthesizing text).
+* Important: This function may be called from a thread different from the
+* one that called sayText or synthText.
+* If the plugin cannot stop an in-progress @ref sayText or
+* @ref synthText operation, it must not block waiting for it to complete.
+* Instead, return immediately.
+*
+* If a plugin returns before the operation has actually been stopped,
+* the plugin must emit the @ref stopped signal when the operation has
+* actually stopped.
+*
+* The plugin should change to the psIdle state after stopping the
+* operation.
+*/
+void FliteProc::stopText(){
+    kdDebug() << "FliteProc::stopText:: Running" << endl;
+    if (m_fliteProc)
+    {
+        if (m_fliteProc->isRunning())
+        {
+            kdDebug() << "FliteProc::stopText: killing Flite." << endl;
+            m_waitingStop = true;
+            m_fliteProc->kill();
+        } else m_state = psIdle;
+    }else m_state = psIdle;
+    kdDebug() << "FliteProc::stopText: Flite stopped." << endl;
+}
+
+void FliteProc::slotProcessExited(KProcess*)
+{
+    kdDebug() << "FliteProc:slotProcessExited: Flite process has exited." << endl;
+    pluginState prevState = m_state;
+    if (m_waitingStop)
+    {
+        m_waitingStop = false;
+        m_state = psIdle;
+        emit stopped();
+    } else {
+        m_state = psFinished;
+        if (prevState == psSaying)
+            emit sayFinished();
+        else
+            if (prevState == psSynthing)
+                emit synthFinished();
+    }
+}
+
+void FliteProc::slotReceivedStdout(KProcess*, char* buffer, int buflen)
+{
+    QString buf = QString::fromLatin1(buffer, buflen);
+    kdDebug() << "FliteProc::slotReceivedStdout: Received output from Flite: " << buf << endl;
+}
+
+void FliteProc::slotReceivedStderr(KProcess*, char* buffer, int buflen)
+{
+    QString buf = QString::fromLatin1(buffer, buflen);
+    kdDebug() << "FliteProc::slotReceivedStderr: Received error from Flite: " << buf << endl;
+}
+
+void FliteProc::slotWroteStdin(KProcess*)
+{
+    kdDebug() << "FliteProc::slotWroteStdin: closing Stdin" << endl;
+    m_fliteProc->closeStdin();
+}
+
+/**
+* Return the current state of the plugin.
+* This function only makes sense in asynchronous mode.
+* @return                        The pluginState of the plugin.
+*
+* @see pluginState
+*/
+pluginState FliteProc::getState() { return m_state; }
+
+/**
+* Acknowledges a finished state and resets the plugin state to psIdle.
+*
+* If the plugin is not in state psFinished, nothing happens.
+* The plugin may use this call to do any post-processing cleanup,
+* for example, blanking the stored filename (but do not delete the file).
+* Calling program should call getFilename prior to ackFinished.
+*/
+void FliteProc::ackFinished()
+{
+    if (m_state == psFinished)
+    {
+        m_state = psIdle;
+        m_synthFilename = QString::null;
+    }
+}
+
+/**
+* Returns True if the plugin supports asynchronous processing,
+* i.e., returns immediately from sayText or synthText.
+* @return                        True if this plugin supports asynchronous processing.
+*
+* If the plugin returns True, it must also implement @ref getState .
+* It must also emit @ref sayFinished or @ref synthFinished signals when
+* saying or synthesis is completed.
+*/
+bool FliteProc::supportsAsync() { return true; }
+
+/**
+* Returns True if the plugin supports synthText method,
+* i.e., is able to synthesize text to a sound file without
+* audibilizing the text.
+* @return                        True if this plugin supports synthText method.
+*/
+bool FliteProc::supportsSynth() { return true; }
+