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)
  26 {
  27
  28 }
  29
  30 //! \brief Creates Talkfiles.
  31 //!
  32 TalkGenerator::Status TalkGenerator::process(QList<TalkEntry>* list,int wavtrimth)
  33 {
  34     m_abort = false;
  35     QString errStr;
  36     bool warnings = false;
  37
  38     //tts
  39     emit logItem(tr("Starting TTS Engine"),LOGINFO);
  40     m_tts = TTSBase::getTTS(this,RbSettings::value(RbSettings::Tts).toString());
  41     if(!m_tts->start(&errStr))
  42     {
  43         emit logItem(errStr.trimmed(),LOGERROR);
  44         emit logItem(tr("Init of TTS engine failed"),LOGERROR);
  45         emit done(true);
  46         return eERROR;
  47     }
  48     QCoreApplication::processEvents();
  49
  50     // Encoder
  51     emit logItem(tr("Starting Encoder Engine"),LOGINFO);
  52     m_enc = EncBase::getEncoder(this,SystemInfo::value(SystemInfo::CurEncoder).toString());
  53     if(!m_enc->start())
  54     {
  55         emit logItem(tr("Init of Encoder engine failed"),LOGERROR);
  56         emit done(true);
  57         m_tts->stop();
  58         return eERROR;
  59     }
  60     QCoreApplication::processEvents();
  61
  62     emit logProgress(0,0);
  63
  64     // Voice entries
  65     emit logItem(tr("Voicing entries..."),LOGINFO);
  66     Status voiceStatus= voiceList(list,wavtrimth);
  67     if(voiceStatus == eERROR)
  68     {
  69         m_tts->stop();
  70         m_enc->stop();
  71         emit done(true);
  72         return eERROR;
  73     }
  74     else if( voiceStatus == eWARNING)
  75         warnings = true;
  76
  77     QCoreApplication::processEvents();
  78
  79     // Encoding Entries
  80     emit logItem(tr("Encoding files..."),LOGINFO);
  81     Status encoderStatus = encodeList(list);
  82     if( encoderStatus == eERROR)
  83     {
  84         m_tts->stop();
  85         m_enc->stop();
  86         emit done(true);
  87         return eERROR;
  88     }
  89     else if( voiceStatus == eWARNING)
  90         warnings = true;
  91
  92     QCoreApplication::processEvents();
  93
  94     m_tts->stop();
  95     m_enc->stop();
  96     emit logProgress(1,1);
  97
  98     if(warnings)
  99         return eWARNING;
 100     return eOK;
 101 }
 102
 103 //! \brief Voices a List of string
 104 //!
 105 TalkGenerator::Status TalkGenerator::voiceList(QList<TalkEntry>* list,int wavtrimth)
 106 {
 107     int progressMax = list->size();
 108     int m_progress = 0;
 109     emit logProgress(m_progress,progressMax);
 110
 111     QStringList errors;
 112     QStringList dublicates;
 113
 114     bool warnings = false;
 115     for(int i=0; i < list->size(); i++)
 116     {
 117         if(m_abort)
 118         {
 119             emit logItem(tr("Voicing aborted"), LOGERROR);
 120             return eERROR;
 121         }
 122
 123         // skip dublicated wav entrys
 124         if(!dublicates.contains(list->at(i).wavfilename))
 125             dublicates.append(list->at(i).wavfilename);
 126         else
 127         {
 128             qDebug() << "dublicate skipped";
 129             (*list)[i].voiced = true;
 130             emit logProgress(++m_progress,progressMax);
 131             continue;
 132         }
 133
 134         // skip already voiced entrys
 135         if(list->at(i).voiced == true)
 136         {
 137             emit logProgress(++m_progress,progressMax);
 138             continue;
 139         }
 140         // skip entry whith empty text
 141         if(list->at(i).toSpeak == "")
 142         {
 143             emit logProgress(++m_progress,progressMax);
 144             continue;
 145         }
 146
 147         // voice entry
 148         QString error;
 149         qDebug() << "voicing: " << list->at(i).toSpeak << "to" << list->at(i).wavfilename;
 150         TTSStatus status = m_tts->voice(list->at(i).toSpeak,list->at(i).wavfilename, &error);
 151         if(status == Warning)
 152         {
 153             warnings = true;
 154             emit logItem(tr("Voicing of %1 failed: %2").arg(list->at(i).toSpeak).arg(error),
 155                     LOGWARNING);
 156         }
 157         else if (status == FatalError)
 158         {
 159             emit logItem(tr("Voicing of %1 failed: %2").arg(list->at(i).toSpeak).arg(error),
 160                     LOGERROR);
 161             return eERROR;
 162         }
 163         else
 164            (*list)[i].voiced = true;
 165
 166         //wavetrim if needed
 167         if(wavtrimth != -1)
 168         {
 169             char buffer[255];
 170             wavtrim(list->at(i).wavfilename.toLocal8Bit().data(),wavtrimth,buffer,255);
 171         }
 172
 173         emit logProgress(++m_progress,progressMax);
 174         QCoreApplication::processEvents();
 175     }
 176     if(warnings)
 177         return eWARNING;
 178     else
 179         return eOK;
 180 }
 181
 182
 183 //! \brief Encodes a List of strings
 184 //!
 185 TalkGenerator::Status TalkGenerator::encodeList(QList<TalkEntry>* list)
 186 {
 187     QStringList dublicates;
 188
 189     int progressMax = list->size();
 190     int m_progress = 0;
 191     emit logProgress(m_progress,progressMax);
 192
 193     for(int i=0; i < list->size(); i++)
 194     {
 195         if(m_abort)
 196         {
 197             emit logItem(tr("Encoding aborted"), LOGERROR);
 198             return eERROR;
 199         }
 200
 201          //skip non-voiced entrys
 202         if(list->at(i).voiced == false)
 203         {
 204             qDebug() << "non voiced entry" << list->at(i).toSpeak <<"detected";
 205             emit logProgress(++m_progress,progressMax);
 206             continue;
 207         }
 208         //skip dublicates
 209          if(!dublicates.contains(list->at(i).talkfilename))
 210             dublicates.append(list->at(i).talkfilename);
 211         else
 212         {
 213             qDebug() << "dublicate skipped";
 214             (*list)[i].encoded = true;
 215             emit logProgress(++m_progress,progressMax);
 216             continue;
 217         }
 218
 219         //encode entry
 220         qDebug() << "encoding " << list->at(i).wavfilename << "to" << list->at(i).talkfilename;
 221         if(!m_enc->encode(list->at(i).wavfilename,list->at(i).talkfilename))
 222         {
 223             emit logItem(tr("Encoding of %1 failed").arg(list->at(i).wavfilename), LOGERROR);
 224             return eERROR;
 225         }
 226         (*list)[i].encoded = true;
 227         emit logProgress(++m_progress,progressMax);
 228         QCoreApplication::processEvents();
 229     }
 230     return eOK;
 231 }
 232
 233 //! \brief slot, which is connected to the abort of the Logger. Sets a flag, so Creating Talkfiles ends at the next possible position
 234 //!
 235 void TalkGenerator::abort()
 236 {
 237     m_abort = true;
 238 }
 239