rbutil/rbutilqt/talkfile.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 "talkfile.h"
  21
  22 TalkFileCreator::TalkFileCreator(QObject* parent): QObject(parent)
  23 {
  24
  25 }
  26
  27 //! \brief Creates Talkfiles.
  28 //!
  29 //! \param logger A pointer to a Loggerobject
  30 bool TalkFileCreator::createTalkFiles(ProgressloggerInterface* logger)
  31 {
  32     m_abort = false;
  33     m_logger = logger;
  34
  35     QMultiMap<QString,QString> fileList;
  36     QMultiMap<QString,QString> dirList;
  37     QStringList toSpeakList;
  38     QString errStr;
  39
  40     m_logger->addItem(tr("Starting Talk file generation"),LOGINFO);
  41
  42     //tts
  43     m_tts = TTSBase::getTTS(settings->curTTS());
  44     m_tts->setCfg(settings);
  45
  46     if(!m_tts->start(&errStr))
  47     {
  48         m_logger->addItem(errStr.trimmed(),LOGERROR);
  49         m_logger->addItem(tr("Init of TTS engine failed"),LOGERROR);
  50         m_logger->abort();
  51         return false;
  52     }
  53
  54     // Encoder
  55     m_enc = EncBase::getEncoder(settings->curEncoder());
  56     m_enc->setCfg(settings);
  57
  58     if(!m_enc->start())
  59     {
  60         m_logger->addItem(tr("Init of Encoder engine failed"),LOGERROR);
  61         m_logger->abort();
  62         m_tts->stop();
  63         return false;
  64     }
  65
  66     QCoreApplication::processEvents();
  67
  68     connect(logger,SIGNAL(aborted()),this,SLOT(abort()));
  69     m_logger->setProgressMax(0);
  70
  71     // read in Maps of paths - file/dirnames
  72     m_logger->addItem(tr("Reading Filelist..."),LOGINFO);
  73     if(createDirAndFileMaps(m_dir,&dirList,&fileList) == false)
  74     {
  75         m_logger->addItem(tr("Talk file creation aborted"),LOGERROR);
  76         doAbort(toSpeakList);
  77         return false;
  78     }
  79
  80     // create List of all Files/Dirs to speak
  81     QMapIterator<QString, QString> dirIt(dirList);
  82     while (dirIt.hasNext())
  83     {
  84         dirIt.next();
  85         // insert only non dublicate dir entries into list
  86         if(!toSpeakList.contains(dirIt.value()))
  87         {
  88             qDebug() << "toSpeaklist dir:" << dirIt.value();
  89             toSpeakList.append(dirIt.value());
  90         }
  91     }
  92     QMapIterator<QString, QString> fileIt(fileList);
  93     while (fileIt.hasNext())
  94     {
  95         fileIt.next();
  96         // insert only non- dublictae file entries into list
  97         if(!toSpeakList.contains(fileIt.value()))
  98         {
  99             if(m_stripExtensions)
 100                 toSpeakList.append(stripExtension(fileIt.value()));
 101             else
 102                 toSpeakList.append(fileIt.value());
 103         }
 104     }
 105
 106     // Voice entryies
 107     m_logger->addItem(tr("Voicing entries..."),LOGINFO);
 108     if(voiceList(toSpeakList,&errStr) == false)
 109     {
 110         m_logger->addItem(errStr,LOGERROR);
 111         doAbort(toSpeakList);
 112         return false;
 113     }
 114
 115     // Encoding Entries
 116     m_logger->addItem(tr("Encoding files..."),LOGINFO);
 117     if(encodeList(toSpeakList,&errStr) == false)
 118     {
 119         m_logger->addItem(errStr,LOGERROR);
 120         doAbort(toSpeakList);
 121         return false;
 122     }
 123
 124     // Copying talk files
 125     m_logger->addItem(tr("Copying Talkfile for Dirs..."),LOGINFO);
 126     if(copyTalkDirFiles(dirList,&errStr) == false)
 127     {
 128         m_logger->addItem(errStr,LOGERROR);
 129         doAbort(toSpeakList);
 130         return false;
 131     }
 132
 133     //Copying file talk files
 134     m_logger->addItem(tr("Copying Talkfile for Files..."),LOGINFO);
 135     if(copyTalkFileFiles(fileList,&errStr) == false)
 136     {
 137         m_logger->addItem(errStr,LOGERROR);
 138         doAbort(toSpeakList);
 139         return false;
 140     }
 141
 142     // Deleting left overs
 143     if( !cleanup(toSpeakList))
 144         return false;
 145
 146     m_tts->stop();
 147     m_enc->stop();
 148     m_logger->addItem(tr("Finished creating Talk files"),LOGOK);
 149     m_logger->setProgressMax(1);
 150     m_logger->setProgressValue(1);
 151     m_logger->abort();
 152
 153     return true;
 154 }
 155
 156 //! \brief resets the internal progress counter, and sets the Progressbar in the Logger
 157 //!
 158 //! \param max  The maximum to shich the Progressbar is set.
 159 void TalkFileCreator::resetProgress(int max)
 160 {
 161     m_progress = 0;
 162     m_logger->setProgressMax(max);
 163     m_logger->setProgressValue(m_progress);
 164 }
 165
 166 //! \brief Strips everything after and including the last dot in a string. If there is no dot, nothing is changed
 167 //!
 168 //! \param filename The filename from which to strip the Extension
 169 //! \returns the modified string
 170 QString TalkFileCreator::stripExtension(QString filename)
 171 {
 172     if(filename.lastIndexOf(".") != -1)
 173         return filename.left(filename.lastIndexOf("."));
 174     else
 175         return filename;
 176 }
 177
 178 //! \brief Does needed Tasks when we need to abort. Cleans up Files. Stops the Logger, Stops TTS and Encoder
 179 //!
 180 //! \param cleanupList  List of filenames to give to cleanup()
 181 void TalkFileCreator::doAbort(QStringList cleanupList)
 182 {
 183     cleanup(cleanupList);
 184     m_logger->setProgressMax(1);
 185     m_logger->setProgressValue(0);
 186     m_logger->abort();
 187     m_tts->stop();
 188     m_enc->stop();
 189 }
 190
 191 //! \brief Creates MultiMaps (paths -> File/dir names)  of all Dirs and Files in a Folder.
 192 //!  Depending on settings, either Dirs  or Files can be ignored.
 193 //! Also recursion is controlled by settings
 194 //!
 195 //! \param startDir     The dir where it beginns scanning
 196 //! \param dirMap       The MulitMap where the dirs are stored
 197 //! \param filMap       The MultiMap where Files are stored
 198 //! \returns true on Success, false if User aborted.
 199 bool TalkFileCreator::createDirAndFileMaps(QDir startDir,QMultiMap<QString,QString> *dirMap,QMultiMap<QString,QString> *fileMap)
 200 {
 201     // create Iterator
 202     QDirIterator::IteratorFlags flags = QDirIterator::NoIteratorFlags;
 203     if(m_recursive)
 204         flags = QDirIterator::Subdirectories;
 205
 206     QDirIterator it(startDir,flags);
 207
 208     // read in Maps of paths - file/dirnames
 209     while (it.hasNext())
 210     {
 211         it.next();
 212         if(m_abort)
 213         {
 214             return false;
 215         }
 216
 217         QFileInfo fileInf = it.fileInfo();
 218
 219         // its a dir
 220         if(fileInf.isDir())
 221         {
 222             QDir dir = fileInf.dir();
 223
 224             // insert into List
 225             if(!dir.dirName().isEmpty() && m_talkFolders)
 226             {
 227                 qDebug() << "Dir: " << dir.dirName() << " - " << dir.path();
 228                 dirMap->insert(dir.path(),dir.dirName());
 229             }
 230         }
 231         else  // its a File
 232         {
 233             // insert into List
 234             if( !fileInf.fileName().isEmpty() && !fileInf.fileName().endsWith(".talk") && m_talkFiles)
 235             {
 236                 qDebug() << "File: " << fileInf.fileName() << " - " << fileInf.path();
 237                 fileMap->insert(fileInf.path(),fileInf.fileName());
 238             }
 239         }
 240         QCoreApplication::processEvents();
 241     }
 242     return true;
 243 }
 244
 245 //! \brief Voices a List of string to the temp dir. Progress is handled inside.
 246 //!
 247 //!  \param toSpeak QStringList with the Entries to voice.
 248 //! \param errString pointer to where the Error cause is written
 249 //! \returns true on success, false on error or user abort
 250 bool TalkFileCreator::voiceList(QStringList toSpeak,QString* errString)
 251 {
 252     resetProgress(toSpeak.size());
 253
 254     for(int i=0; i < toSpeak.size(); i++)
 255     {
 256         if(m_abort)
 257         {
 258             *errString = tr("Talk file creation aborted");
 259             return false;
 260         }
 261
 262         QString filename = QDir::tempPath()+ "/"+  toSpeak[i] + ".wav";
 263
 264         if(!m_tts->voice(toSpeak[i],filename))
 265         {
 266             *errString =tr("Voicing of %s failed").arg(toSpeak[i]);
 267             return false;
 268         }
 269         m_logger->setProgressValue(++m_progress);
 270         QCoreApplication::processEvents();
 271     }
 272     return true;
 273 }
 274
 275
 276 //! \brief Encodes a List of strings from/to the temp dir. Progress is handled inside.
 277 //! It expects the inputfile in the temp dir with the name in the List appended with ".wav"
 278 //!
 279 //!  \param toSpeak QStringList with the Entries to encode.
 280 //! \param errString pointer to where the Error cause is written
 281 //! \returns true on success, false on error or user abort
 282 bool TalkFileCreator::encodeList(QStringList toEncode,QString* errString)
 283 {
 284     resetProgress(toEncode.size());
 285     for(int i=0; i < toEncode.size(); i++)
 286     {
 287         if(m_abort)
 288         {
 289             *errString = tr("Talk file creation aborted");
 290             return false;
 291         }
 292
 293         QString wavfilename = QDir::tempPath()+ "/"+   toEncode[i] + ".wav";
 294         QString filename = QDir::tempPath()+ "/"+  toEncode[i] + ".talk";
 295
 296         if(!m_enc->encode(wavfilename,filename))
 297         {
 298             *errString =tr("Encoding of %1 failed").arg(filename);
 299             return false;
 300         }
 301         m_logger->setProgressValue(++m_progress);
 302         QCoreApplication::processEvents();
 303     }
 304     return true;
 305 }
 306
 307 //! \brief copys Talkfile for Dirs from the temp dir to the target. Progress and installlog is handled inside
 308 //!
 309 //! \param dirMap   a MultiMap of Paths -> Dirnames
 310 //! \param errString Pointer to a QString where the error cause is written.
 311 //! \returns true on success, false on error or user abort
 312 bool TalkFileCreator::copyTalkDirFiles(QMultiMap<QString,QString> dirMap,QString* errString)
 313 {
 314     resetProgress(dirMap.size());
 315
 316     QSettings installlog(m_mountpoint + "/.rockbox/rbutil.log", QSettings::IniFormat, 0);
 317     installlog.beginGroup("talkfiles");
 318
 319     QMapIterator<QString, QString> it(dirMap);
 320     while (it.hasNext())
 321     {
 322         it.next();
 323         if(m_abort)
 324         {
 325             *errString = tr("Talk file creation aborted");
 326             return false;
 327         }
 328
 329         QString source = QDir::tempPath()+ "/"+  it.value() + ".talk";
 330         QString target = it.key() + "/" + "_dirname.talk";
 331
 332          // remove target if it exists, and if we should overwrite it
 333         if(m_overwriteTalk && QFile::exists(target))
 334             QFile::remove(target);
 335
 336         // copying
 337         if(!QFile::copy(source,target))
 338         {
 339             *errString = tr("Copying of %1 to %2 failed").arg(source).arg(target);
 340             return false;
 341         }
 342
 343         // add to installlog
 344         QString now = QDate::currentDate().toString("yyyyMMdd");
 345         installlog.setValue(target.remove(0,m_mountpoint.length()),now);
 346
 347         m_logger->setProgressValue(++m_progress);
 348         QCoreApplication::processEvents();
 349     }
 350     installlog.endGroup();
 351     installlog.sync();
 352     return true;
 353 }
 354
 355 //! \brief copys Talkfile for Files from the temp dir to the target. Progress and installlog is handled inside
 356 //!
 357 //! \param fileMap   a MultiMap of Paths -> Filenames
 358 //! \param errString Pointer to a QString where the error cause is written.
 359 //! \returns true on success, false on error or user abort
 360 bool TalkFileCreator::copyTalkFileFiles(QMultiMap<QString,QString> fileMap,QString* errString)
 361 {
 362     resetProgress(fileMap.size());
 363
 364     QSettings installlog(m_mountpoint + "/.rockbox/rbutil.log", QSettings::IniFormat, 0);
 365     installlog.beginGroup("talkfiles");
 366
 367     QMapIterator<QString, QString> it(fileMap);
 368     while (it.hasNext())
 369     {
 370         it.next();
 371         if(m_abort)
 372         {
 373             *errString = tr("Talk file creation aborted");
 374             return false;
 375         }
 376
 377         QString source;
 378         QString target = it.key() + "/" + it.value() + ".talk";
 379
 380         // correct source if we hav stripExtension enabled
 381         if(m_stripExtensions)
 382             source = QDir::tempPath()+ "/"+ stripExtension(it.value()) + ".talk";
 383         else
 384             source = QDir::tempPath()+ "/"+  it.value() + ".talk";
 385
 386         // remove target if it exists, and if we should overwrite it
 387         if(m_overwriteTalk && QFile::exists(target))
 388             QFile::remove(target);
 389
 390         // copy file
 391         qDebug() << "copying: " << source << " to " << target;
 392         if(!QFile::copy(source,target))
 393         {
 394             *errString = tr("Copying of %1 to %2 failed").arg(source).arg(target);
 395             return false;
 396         }
 397
 398         //  add to Install log
 399         QString now = QDate::currentDate().toString("yyyyMMdd");
 400         installlog.setValue(target.remove(0,m_mountpoint.length()),now);
 401
 402         m_logger->setProgressValue(++m_progress);
 403         QCoreApplication::processEvents();
 404     }
 405     installlog.endGroup();
 406     installlog.sync();
 407     return true;
 408 }
 409
 410
 411 //! \brief Cleans up Files potentially left in the temp dir
 412 //!
 413 //! \param list List of file to try to delete in the temp dir. Function appends ".wav" and ".talk" to the filenames
 414 bool TalkFileCreator::cleanup(QStringList list)
 415 {
 416     m_logger->addItem(tr("Cleaning up.."),LOGINFO);
 417
 418     for(int i=0; i < list.size(); i++)
 419     {
 420         if(QFile::exists(QDir::tempPath()+ "/"+  list[i] + ".wav"))
 421                 QFile::remove(QDir::tempPath()+ "/"+  list[i] + ".wav");
 422         if(QFile::exists(QDir::tempPath()+ "/"+  list[i] + ".talk"))
 423                 QFile::remove(QDir::tempPath()+ "/"+  list[i] + ".talk");
 424
 425         QCoreApplication::processEvents();
 426     }
 427     return true;
 428 }
 429
 430 //! \brief slot, which is connected to the abort of the Logger. Sets a flag, so Creating Talkfiles ends at the next possible position
 431 //!
 432 void TalkFileCreator::abort()
 433 {
 434     m_abort = true;
 435 }
 436