rbutil/rbutilqt/base/talkgenerator.cpp

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  *
   9  *   Copyright (C) 2007 by Dominik Wenger
  10  *   $Id$
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 #include "talkgenerator.h"
  21 #include "rbsettings.h"
  22 #include "systeminfo.h"
  23 #include "wavtrim.h"
  24
  25 TalkGenerator::TalkGenerator(QObject* parent): QObject(parent), encFutureWatcher(this), ttsFutureWatcher(this)
  26 {
  27
  28 }
  29
  30 //! \brief Creates Talkfiles.
  31 //!
  32 TalkGenerator::Status TalkGenerator::process(QList<TalkEntry>* list,int wavtrimth)
  33 {
  34     QString errStr;
  35     bool warnings = false;
  36
  37     //tts
  38     emit logItem(tr("Starting TTS Engine"),LOGINFO);
  39     m_tts = TTSBase::getTTS(this,RbSettings::value(RbSettings::Tts).toString());
  40     if(!m_tts->start(&errStr))
  41     {
  42         emit logItem(errStr.trimmed(),LOGERROR);
  43         emit logItem(tr("Init of TTS engine failed"),LOGERROR);
  44         emit done(true);
  45         return eERROR;
  46     }
  47     QCoreApplication::processEvents();
  48
  49     // Encoder
  50     emit logItem(tr("Starting Encoder Engine"),LOGINFO);
  51     m_enc = EncBase::getEncoder(this,SystemInfo::value(SystemInfo::CurEncoder).toString());
  52     if(!m_enc->start())
  53     {
  54         emit logItem(tr("Init of Encoder engine failed"),LOGERROR);
  55         emit done(true);
  56         m_tts->stop();
  57         return eERROR;
  58     }
  59     QCoreApplication::processEvents();
  60
  61     emit logProgress(0,0);
  62
  63     // Voice entries
  64     emit logItem(tr("Voicing entries..."),LOGINFO);
  65     Status voiceStatus= voiceList(list,wavtrimth);
  66     if(voiceStatus == eERROR)
  67     {
  68         m_tts->stop();
  69         m_enc->stop();
  70         emit done(true);
  71         return eERROR;
  72     }
  73     else if( voiceStatus == eWARNING)
  74         warnings = true;
  75
  76     QCoreApplication::processEvents();
  77
  78     // Encoding Entries
  79     emit logItem(tr("Encoding files..."),LOGINFO);
  80     Status encoderStatus = encodeList(list);
  81     if( encoderStatus == eERROR)
  82     {
  83         m_tts->stop();
  84         m_enc->stop();
  85         emit done(true);
  86         return eERROR;
  87     }
  88     else if( voiceStatus == eWARNING)
  89         warnings = true;
  90
  91     QCoreApplication::processEvents();
  92
  93     m_tts->stop();
  94     m_enc->stop();
  95     emit logProgress(1,1);
  96
  97     if(warnings)
  98         return eWARNING;
  99     return eOK;
 100 }
 101
 102 //! \brief Voices a List of string
 103 //!
 104 TalkGenerator::Status TalkGenerator::voiceList(QList<TalkEntry>* list,int wavtrimth)
 105 {
 106     emit logProgress(0, list->size());
 107
 108     QStringList duplicates;
 109
 110     m_ttsWarnings = false;
 111     for(int i=0; i < list->size(); i++)
 112     {
 113         (*list)[i].refs.tts = m_tts;
 114         (*list)[i].refs.wavtrim = wavtrimth;
 115         (*list)[i].refs.generator = this;
 116
 117         // skip duplicated wav entries
 118         if(!duplicates.contains(list->at(i).wavfilename))
 119             duplicates.append(list->at(i).wavfilename);
 120         else
 121         {
 122             qDebug() << "[TalkGen] duplicate skipped";
 123             (*list)[i].voiced = true;
 124             continue;
 125         }
 126     }
 127
 128     /* If the engine can't be parallelized, we use only 1 thread */
 129     int maxThreadCount = QThreadPool::globalInstance()->maxThreadCount();
 130     if ((m_tts->capabilities() & TTSBase::RunInParallel) == 0)
 131         QThreadPool::globalInstance()->setMaxThreadCount(1);
 132
 133     connect(&ttsFutureWatcher, SIGNAL(progressValueChanged(int)),
 134             this, SLOT(ttsProgress(int)));
 135     ttsFutureWatcher.setFuture(QtConcurrent::map(*list, &TalkGenerator::ttsEntryPoint));
 136
 137     /* We use this loop as an equivalent to ttsFutureWatcher.waitForFinished()
 138      * since the latter blocks all events */
 139     while(ttsFutureWatcher.isRunning())
 140         QCoreApplication::processEvents();
 141
 142     /* Restore global settings, if we changed them */
 143     if ((m_tts->capabilities() & TTSBase::RunInParallel) == 0)
 144         QThreadPool::globalInstance()->setMaxThreadCount(maxThreadCount);
 145
 146     if(ttsFutureWatcher.isCanceled())
 147         return eERROR;
 148     else if(m_ttsWarnings)
 149         return eWARNING;
 150     else
 151         return eOK;
 152 }
 153
 154 void TalkGenerator::ttsEntryPoint(TalkEntry& entry)
 155 {
 156     if (!entry.voiced && !entry.toSpeak.isEmpty())
 157     {
 158         QString error;
 159         qDebug() << "[TalkGen] voicing: " << entry.toSpeak << "to" << entry.wavfilename;
 160         TTSStatus status = entry.refs.tts->voice(entry.toSpeak,entry.wavfilename, &error);
 161         if (status == Warning || status == FatalError)
 162         {
 163             entry.refs.generator->ttsFailEntry(entry, status, error);
 164             return;
 165         }
 166         if (entry.refs.wavtrim != -1)
 167         {
 168             char buffer[255];
 169             wavtrim(entry.wavfilename.toLocal8Bit().data(), entry.refs.wavtrim, buffer, 255);
 170         }
 171         entry.voiced = true;
 172     }
 173 }
 174
 175 void TalkGenerator::ttsFailEntry(const TalkEntry& entry, TTSStatus status, QString error)
 176 {
 177     if(status == Warning)
 178     {
 179         m_ttsWarnings = true;
 180         emit logItem(tr("Voicing of %1 failed: %2").arg(entry.toSpeak).arg(error),
 181                     LOGWARNING);
 182     }
 183     else if (status == FatalError)
 184     {
 185         emit logItem(tr("Voicing of %1 failed: %2").arg(entry.toSpeak).arg(error),
 186                     LOGERROR);
 187         abort();
 188     }
 189 }
 190
 191 void TalkGenerator::ttsProgress(int value)
 192 {
 193     emit logProgress(value,ttsFutureWatcher.progressMaximum());
 194 }
 195
 196 //! \brief Encodes a List of strings
 197 //!
 198 TalkGenerator::Status TalkGenerator::encodeList(QList<TalkEntry>* list)
 199 {
 200     QStringList duplicates;
 201
 202     int itemsCount = list->size();
 203     emit logProgress(0, itemsCount);
 204
 205     /* Do some preprocessing and remove entries that have not been voiced. */
 206     for (int idx=0; idx < itemsCount; idx++)
 207     {
 208         if(list->at(idx).voiced == false)
 209         {
 210             qDebug() << "[TalkGen] unvoiced entry" << list->at(idx).toSpeak <<"detected";
 211             list->removeAt(idx);
 212             itemsCount--;
 213             idx--;
 214             continue;
 215         }
 216         if(duplicates.contains(list->at(idx).talkfilename))
 217         {
 218             (*list)[idx].encoded = true; /* make sure we skip this entry */
 219             continue;
 220         }
 221         duplicates.append(list->at(idx).talkfilename);
 222         (*list)[idx].refs.encoder = m_enc;
 223         (*list)[idx].refs.generator = this; /* not really needed, unless we end up
 224                                                voicing and encoding with two different
 225                                                TalkGenerators.*/
 226     }
 227
 228     connect(&encFutureWatcher, SIGNAL(progressValueChanged(int)),
 229             this, SLOT(encProgress(int)));
 230     encFutureWatcher.setFuture(QtConcurrent::map(*list, &TalkGenerator::encEntryPoint));
 231
 232     /* We use this loop as an equivalent to encFutureWatcher.waitForFinished()
 233      * since the latter blocks all events */
 234     while (encFutureWatcher.isRunning())
 235         QCoreApplication::processEvents(QEventLoop::AllEvents);
 236
 237     if (encFutureWatcher.isCanceled())
 238         return eERROR;
 239     else
 240         return eOK;
 241 }
 242
 243 void TalkGenerator::encEntryPoint(TalkEntry& entry)
 244 {
 245     if(!entry.encoded)
 246     {
 247         bool res = entry.refs.encoder->encode(entry.wavfilename, entry.talkfilename);
 248         entry.encoded = res;
 249         if (!entry.encoded)
 250             entry.refs.generator->encFailEntry(entry);
 251         }
 252     return;
 253 }
 254
 255 void TalkGenerator::encProgress(int value)
 256 {
 257     emit logProgress(value, encFutureWatcher.progressMaximum());
 258 }
 259
 260 void TalkGenerator::encFailEntry(const TalkEntry& entry)
 261 {
 262     emit logItem(tr("Encoding of %1 failed").arg(entry.wavfilename), LOGERROR);
 263     abort();
 264 }
 265
 266 //! \brief slot, which is connected to the abort of the Logger. Sets a flag, so Creating Talkfiles ends at the next possible position
 267 //!
 268 void TalkGenerator::abort()
 269 {
 270     if (ttsFutureWatcher.isRunning())
 271     {
 272         ttsFutureWatcher.cancel();
 273         emit logItem(tr("Voicing aborted"), LOGERROR);
 274     }
 275     if (encFutureWatcher.isRunning())
 276     {
 277         encFutureWatcher.cancel();
 278         emit logItem(tr("Encoding aborted"), LOGERROR);
 279     }
 280 }
 281