src/Thread_FileAnalyzer.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // LameXP - Audio Encoder Front-End
   3 // Copyright (C) 2004-2012 LoRd_MuldeR <MuldeR2@GMX.de>
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 2 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License along
  16 // with this program; if not, write to the Free Software Foundation, Inc.,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 // http://www.gnu.org/licenses/gpl-2.0.txt
  20 ///////////////////////////////////////////////////////////////////////////////
  21
  22 #include "Thread_FileAnalyzer.h"
  23
  24 #include "Global.h"
  25 #include "LockedFile.h"
  26 #include "Model_AudioFile.h"
  27 #include "Thread_FileAnalyzer_Task.h"
  28
  29 #include <QDir>
  30 #include <QFileInfo>
  31 #include <QProcess>
  32 #include <QDate>
  33 #include <QTime>
  34 #include <QDebug>
  35 #include <QImage>
  36 #include <QThreadPool>
  37 #include <QTime>
  38
  39 ////////////////////////////////////////////////////////////
  40 // Constructor
  41 ////////////////////////////////////////////////////////////
  42
  43 FileAnalyzer::FileAnalyzer(const QStringList &inputFiles)
  44 :
  45         m_abortFlag(false),
  46         m_inputFiles(inputFiles),
  47         m_templateFile(NULL)
  48 {
  49         m_bSuccess = false;
  50         m_bAborted = false;
  51 }
  52
  53 FileAnalyzer::~FileAnalyzer(void)
  54 {
  55         if(m_templateFile)
  56         {
  57                 QString templatePath = m_templateFile->filePath();
  58                 LAMEXP_DELETE(m_templateFile);
  59                 if(QFile::exists(templatePath)) QFile::remove(templatePath);
  60         }
  61
  62         AnalyzeTask::reset();
  63 }
  64
  65 ////////////////////////////////////////////////////////////
  66 // Static data
  67 ////////////////////////////////////////////////////////////
  68
  69 const char *FileAnalyzer::g_tags_gen[] =
  70 {
  71         "ID",
  72         "Format",
  73         "Format_Profile",
  74         "Format_Version",
  75         "Duration",
  76         "Title", "Track",
  77         "Track/Position",
  78         "Artist", "Performer",
  79         "Album",
  80         "Genre",
  81         "Released_Date", "Recorded_Date",
  82         "Comment",
  83         "Cover",
  84         "Cover_Type",
  85         "Cover_Mime",
  86         "Cover_Data",
  87         NULL
  88 };
  89
  90 const char *FileAnalyzer::g_tags_aud[] =
  91 {
  92         "ID",
  93         "Source",
  94         "Format",
  95         "Format_Profile",
  96         "Format_Version",
  97         "Channel(s)",
  98         "SamplingRate",
  99         "BitDepth",
 100         "BitRate",
 101         "BitRate_Mode",
 102         NULL
 103 };
 104
 105 ////////////////////////////////////////////////////////////
 106 // Thread Main
 107 ////////////////////////////////////////////////////////////
 108
 109 void FileAnalyzer::run()
 110 {
 111         qWarning("--- FileAnalyzer::run() ---");
 112
 113         m_abortFlag = false;
 114
 115         m_bAborted = false;
 116         m_bSuccess = false;
 117
 118         int nFiles = m_inputFiles.count();
 119
 120         emit progressMaxChanged(nFiles);
 121         emit progressValChanged(0);
 122
 123         m_inputFiles.sort();
 124
 125         if(!m_templateFile)
 126         {
 127                 if(!createTemplate())
 128                 {
 129                         qWarning("Failed to create template file!");
 130                         return;
 131                 }
 132         }
 133
 134         AnalyzeTask::reset();
 135         QThreadPool *pool = new QThreadPool();
 136         QThread::msleep(333);
 137
 138         pool->setMaxThreadCount(qBound(2, ((QThread::idealThreadCount() * 3) / 2), 12));
 139
 140         while(!(m_inputFiles.isEmpty() || m_bAborted))
 141         {
 142                 while(!(m_inputFiles.isEmpty() || m_bAborted))
 143                 {
 144                         if(!AnalyzeTask::waitForFreeSlot(&m_abortFlag))
 145                         {
 146                                 qWarning("Timeout in AnalyzeTask::waitForFreeSlot() !!!");
 147                         }
 148
 149                         if(m_abortFlag)
 150                         {
 151                                 MessageBeep(MB_ICONERROR);
 152                                 m_bAborted = true;
 153                                 break;
 154                         }
 155
 156                         if(!m_bAborted)
 157                         {
 158                                 const QString currentFile = QDir::fromNativeSeparators(m_inputFiles.takeFirst());
 159
 160                                 AnalyzeTask *task = new AnalyzeTask(currentFile, m_templateFile->filePath(), &m_abortFlag);
 161                                 connect(task, SIGNAL(fileSelected(QString)), this, SIGNAL(fileSelected(QString)), Qt::DirectConnection);
 162                                 connect(task, SIGNAL(progressValChanged(unsigned int)), this, SIGNAL(progressValChanged(unsigned int)), Qt::DirectConnection);
 163                                 connect(task, SIGNAL(progressMaxChanged(unsigned int)), this, SIGNAL(progressMaxChanged(unsigned int)), Qt::DirectConnection);
 164                                 connect(task, SIGNAL(fileAnalyzed(AudioFileModel)), this, SIGNAL(fileAnalyzed(AudioFileModel)), Qt::DirectConnection);
 165
 166                                 pool->start(task);
 167
 168                                 if(int count = AnalyzeTask::getAdditionalFiles(m_inputFiles))
 169                                 {
 170                                         emit progressMaxChanged(nFiles += count);
 171                                 }
 172                         }
 173                 }
 174
 175                 //One of the Analyze tasks may have gathered additional files from a playlist!
 176                 if(!m_bAborted)
 177                 {
 178                         pool->waitForDone();
 179                         if(int count = AnalyzeTask::getAdditionalFiles(m_inputFiles))
 180                         {
 181                                 emit progressMaxChanged(nFiles += count);
 182                         }
 183                 }
 184         }
 185
 186         pool->waitForDone();
 187         LAMEXP_DELETE(pool);
 188
 189         if(m_bAborted)
 190         {
 191                 qWarning("Operation cancelled by user!");
 192                 return;
 193         }
 194
 195         qDebug("All files added.\n");
 196         m_bSuccess = true;
 197 }
 198
 199 ////////////////////////////////////////////////////////////
 200 // Privtae Functions
 201 ////////////////////////////////////////////////////////////
 202
 203 bool FileAnalyzer::createTemplate(void)
 204 {
 205         if(m_templateFile)
 206         {
 207                 qWarning("Template file already exists!");
 208                 return true;
 209         }
 210
 211         QString templatePath = QString("%1/%2.txt").arg(lamexp_temp_folder2(), lamexp_rand_str());
 212
 213         QFile templateFile(templatePath);
 214         if(!templateFile.open(QIODevice::WriteOnly))
 215         {
 216                 return false;
 217         }
 218
 219         templateFile.write("General;");
 220         for(size_t i = 0; g_tags_gen[i]; i++)
 221         {
 222                 templateFile.write(QString("Gen_%1=%%1%\\n").arg(g_tags_gen[i]).toLatin1().constData());
 223         }
 224         templateFile.write("\\n\r\n");
 225
 226         templateFile.write("Audio;");
 227         for(size_t i = 0; g_tags_aud[i]; i++)
 228         {
 229                 templateFile.write(QString("Aud_%1=%%1%\\n").arg(g_tags_aud[i]).toLatin1().constData());
 230         }
 231         templateFile.write("\\n\r\n");
 232
 233         bool success = (templateFile.error() == QFile::NoError);
 234         templateFile.close();
 235
 236         if(!success)
 237         {
 238                 QFile::remove(templatePath);
 239                 return false;
 240         }
 241
 242         try
 243         {
 244                 m_templateFile = new LockedFile(templatePath);
 245         }
 246         catch(...)
 247         {
 248                 qWarning("Failed to lock template file!");
 249                 return false;
 250         }
 251
 252         return true;
 253 }
 254
 255 ////////////////////////////////////////////////////////////
 256 // Public Functions
 257 ////////////////////////////////////////////////////////////
 258
 259 unsigned int FileAnalyzer::filesAccepted(void)
 260 {
 261         return AnalyzeTask::filesAccepted();
 262 }
 263
 264 unsigned int FileAnalyzer::filesRejected(void)
 265 {
 266         return AnalyzeTask::filesRejected();
 267 }
 268
 269 unsigned int FileAnalyzer::filesDenied(void)
 270 {
 271         return AnalyzeTask::filesDenied();
 272 }
 273
 274 unsigned int FileAnalyzer::filesDummyCDDA(void)
 275 {
 276         return AnalyzeTask::filesDummyCDDA();
 277 }
 278
 279 unsigned int FileAnalyzer::filesCueSheet(void)
 280 {
 281         return AnalyzeTask::filesCueSheet();
 282 }
 283
 284 ////////////////////////////////////////////////////////////
 285 // EVENTS
 286 ////////////////////////////////////////////////////////////
 287
 288 /*NONE*/