src/Thread_FileAnalyzer.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // LameXP - Audio Encoder Front-End
   3 // Copyright (C) 2004-2011 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
  28 #include <QDir>
  29 #include <QFileInfo>
  30 #include <QProcess>
  31 #include <QDate>
  32 #include <QTime>
  33 #include <QDebug>
  34 #include <QMessageBox>
  35
  36 #include <math.h>
  37
  38 //Un-escape XML characters
  39 #define XML_DECODE replace("&amp;", "&").replace("&apos;", "'").replace("&nbsp;", " ").replace("&quot;", "\"").replace("&lt;", "<").replace("&gt;", ">")
  40
  41 ////////////////////////////////////////////////////////////
  42 // Constructor
  43 ////////////////////////////////////////////////////////////
  44
  45 FileAnalyzer::FileAnalyzer(const QStringList &inputFiles)
  46 :
  47         m_inputFiles(inputFiles),
  48         m_mediaInfoBin_x86(lamexp_lookup_tool("mediainfo_i386.exe")),
  49         m_mediaInfoBin_x64(lamexp_lookup_tool("mediainfo_x64.exe"))
  50 {
  51         m_bSuccess = false;
  52
  53         if(m_mediaInfoBin_x86.isEmpty() || m_mediaInfoBin_x64.isEmpty())
  54         {
  55                 qFatal("Invalid path to MediaInfo binary. Tool not initialized properly.");
  56         }
  57
  58         m_filesAccepted = 0;
  59         m_filesRejected = 0;
  60         m_filesDenied = 0;
  61 }
  62
  63 ////////////////////////////////////////////////////////////
  64 // Thread Main
  65 ////////////////////////////////////////////////////////////
  66
  67 void FileAnalyzer::run()
  68 {
  69         m_bSuccess = false;
  70
  71         m_filesAccepted = 0;
  72         m_filesRejected = 0;
  73         m_filesDenied = 0;
  74
  75         m_inputFiles.sort();
  76
  77         while(!m_inputFiles.isEmpty())
  78         {
  79                 QString currentFile = QDir::fromNativeSeparators(m_inputFiles.takeFirst());
  80                 qDebug("Analyzing: %s", currentFile.toUtf8().constData());
  81                 emit fileSelected(QFileInfo(currentFile).fileName());
  82                 AudioFileModel file = analyzeFile(currentFile);
  83                 if(file.fileName().isEmpty() || file.formatContainerType().isEmpty() || file.formatAudioType().isEmpty())
  84                 {
  85                         if(!importPlaylist(m_inputFiles, currentFile))
  86                         {
  87                                 m_filesRejected++;
  88                                 qDebug("Skipped: %s", file.filePath().toUtf8().constData());
  89                         }
  90                         continue;
  91                 }
  92                 m_filesAccepted++;
  93                 emit fileAnalyzed(file);
  94         }
  95
  96         qDebug("All files added.\n");
  97         m_bSuccess = true;
  98 }
  99
 100 ////////////////////////////////////////////////////////////
 101 // Privtae Functions
 102 ////////////////////////////////////////////////////////////
 103
 104 const AudioFileModel FileAnalyzer::analyzeFile(const QString &filePath)
 105 {
 106         lamexp_cpu_t cpuInfo = lamexp_detect_cpu_features();
 107         const QString mediaInfoBin = cpuInfo.x64 ? m_mediaInfoBin_x64 : m_mediaInfoBin_x86;
 108
 109         AudioFileModel audioFile(filePath);
 110         m_currentSection = sectionOther;
 111
 112         QFile readTest(filePath);
 113         if(!readTest.open(QIODevice::ReadOnly))
 114         {
 115                 qWarning("Cannot access file for reading, skipping!");
 116                 m_filesDenied++;
 117                 return audioFile;
 118         }
 119         else
 120         {
 121                 readTest.close();
 122         }
 123
 124         QProcess process;
 125         process.setProcessChannelMode(QProcess::MergedChannels);
 126         process.setReadChannel(QProcess::StandardOutput);
 127         process.start(mediaInfoBin, QStringList() << QDir::toNativeSeparators(filePath));
 128
 129         if(!process.waitForStarted())
 130         {
 131                 qWarning("MediaInfo process failed to create!");
 132                 qWarning("Error message: \"%s\"\n", process.errorString().toLatin1().constData());
 133                 process.kill();
 134                 process.waitForFinished(-1);
 135                 return audioFile;
 136         }
 137
 138         while(process.state() != QProcess::NotRunning)
 139         {
 140                 if(!process.waitForReadyRead())
 141                 {
 142                         if(process.state() == QProcess::Running)
 143                         {
 144                                 qWarning("MediaInfo time out. Killing process and skipping file!");
 145                                 process.kill();
 146                                 process.waitForFinished(-1);
 147                                 return audioFile;
 148                         }
 149                 }
 150
 151                 QByteArray data;
 152
 153                 while(process.canReadLine())
 154                 {
 155                         QString line = QString::fromUtf8(process.readLine().constData()).simplified();
 156                         if(!line.isEmpty())
 157                         {
 158                                 int index = line.indexOf(':');
 159                                 if(index > 0)
 160                                 {
 161                                         QString key = line.left(index-1).trimmed();
 162                                         QString val = line.mid(index+1).trimmed();
 163                                         if(!key.isEmpty() && !val.isEmpty())
 164                                         {
 165                                                 updateInfo(audioFile, key, val);
 166                                         }
 167                                 }
 168                                 else
 169                                 {
 170                                         updateSection(line);
 171                                 }
 172                         }
 173                 }
 174         }
 175
 176         if(audioFile.fileName().isEmpty())
 177         {
 178                 QString baseName = QFileInfo(filePath).fileName();
 179                 int index = baseName.lastIndexOf(".");
 180
 181                 if(index >= 0)
 182                 {
 183                         baseName = baseName.left(index);
 184                 }
 185
 186                 baseName = baseName.replace("_", " ").simplified();
 187                 index = baseName.lastIndexOf(" - ");
 188
 189                 if(index >= 0)
 190                 {
 191                         baseName = baseName.mid(index + 3).trimmed();
 192                 }
 193
 194                 audioFile.setFileName(baseName);
 195         }
 196
 197         return audioFile;
 198 }
 199
 200 void FileAnalyzer::updateSection(const QString &section)
 201 {
 202         if(section.startsWith("General", Qt::CaseInsensitive))
 203         {
 204                 m_currentSection = sectionGeneral;
 205         }
 206         else if(!section.compare("Audio", Qt::CaseInsensitive) || section.startsWith("Audio #1", Qt::CaseInsensitive))
 207         {
 208                 m_currentSection = sectionAudio;
 209         }
 210         else if(section.startsWith("Audio", Qt::CaseInsensitive) || section.startsWith("Video", Qt::CaseInsensitive) || section.startsWith("Text", Qt::CaseInsensitive) ||
 211                 section.startsWith("Menu", Qt::CaseInsensitive) || section.startsWith("Image", Qt::CaseInsensitive) || section.startsWith("Chapters", Qt::CaseInsensitive))
 212         {
 213                 m_currentSection = sectionOther;
 214         }
 215         else
 216         {
 217                 qWarning("Unknown section: %s", section.toUtf8().constData());
 218         }
 219 }
 220
 221 void FileAnalyzer::updateInfo(AudioFileModel &audioFile, const QString &key, const QString &value)
 222 {
 223         switch(m_currentSection)
 224         {
 225         case sectionGeneral:
 226                 if(!key.compare("Title", Qt::CaseInsensitive) || !key.compare("Track", Qt::CaseInsensitive) || !key.compare("Track Name", Qt::CaseInsensitive))
 227                 {
 228                         if(audioFile.fileName().isEmpty()) audioFile.setFileName(value);
 229                 }
 230                 else if(!key.compare("Duration", Qt::CaseInsensitive))
 231                 {
 232                         if(!audioFile.fileDuration()) audioFile.setFileDuration(parseDuration(value));
 233                 }
 234                 else if(!key.compare("Artist", Qt::CaseInsensitive) || !key.compare("Performer", Qt::CaseInsensitive))
 235                 {
 236                         if(audioFile.fileArtist().isEmpty()) audioFile.setFileArtist(value);
 237                 }
 238                 else if(!key.compare("Album", Qt::CaseInsensitive))
 239                 {
 240                         if(audioFile.fileAlbum().isEmpty()) audioFile.setFileAlbum(value);
 241                 }
 242                 else if(!key.compare("Genre", Qt::CaseInsensitive))
 243                 {
 244                         if(audioFile.fileGenre().isEmpty()) audioFile.setFileGenre(value);
 245                 }
 246                 else if(!key.compare("Year", Qt::CaseInsensitive) || !key.compare("Recorded Date", Qt::CaseInsensitive) || !key.compare("Encoded Date", Qt::CaseInsensitive))
 247                 {
 248                         if(!audioFile.fileYear()) audioFile.setFileYear(parseYear(value));
 249                 }
 250                 else if(!key.compare("Comment", Qt::CaseInsensitive))
 251                 {
 252                         if(audioFile.fileComment().isEmpty()) audioFile.setFileComment(value);
 253                 }
 254                 else if(!key.compare("Track Name/Position", Qt::CaseInsensitive))
 255                 {
 256                         if(!audioFile.filePosition()) audioFile.setFilePosition(value.toInt());
 257                 }
 258                 else if(!key.compare("Format", Qt::CaseInsensitive))
 259                 {
 260                         if(audioFile.formatContainerType().isEmpty()) audioFile.setFormatContainerType(value);
 261                 }
 262                 else if(!key.compare("Format Profile", Qt::CaseInsensitive))
 263                 {
 264                         if(audioFile.formatContainerProfile().isEmpty()) audioFile.setFormatContainerProfile(value);
 265                 }
 266                 break;
 267
 268         case sectionAudio:
 269                 if(!key.compare("Year", Qt::CaseInsensitive) || !key.compare("Recorded Date", Qt::CaseInsensitive) || !key.compare("Encoded Date", Qt::CaseInsensitive))
 270                 {
 271                         if(!audioFile.fileYear()) audioFile.setFileYear(parseYear(value));
 272                 }
 273                 else if(!key.compare("Format", Qt::CaseInsensitive))
 274                 {
 275                         if(audioFile.formatAudioType().isEmpty()) audioFile.setFormatAudioType(value);
 276                 }
 277                 else if(!key.compare("Format Profile", Qt::CaseInsensitive))
 278                 {
 279                         if(audioFile.formatAudioProfile().isEmpty()) audioFile.setFormatAudioProfile(value);
 280                 }
 281                 else if(!key.compare("Format Version", Qt::CaseInsensitive))
 282                 {
 283                         if(audioFile.formatAudioVersion().isEmpty()) audioFile.setFormatAudioVersion(value);
 284                 }
 285                 else if(!key.compare("Channel(s)", Qt::CaseInsensitive))
 286                 {
 287                         if(!audioFile.formatAudioChannels()) audioFile.setFormatAudioChannels(value.split(" ", QString::SkipEmptyParts).first().toInt());
 288                 }
 289                 else if(!key.compare("Sampling rate", Qt::CaseInsensitive))
 290                 {
 291                         if(!audioFile.formatAudioSamplerate()) audioFile.setFormatAudioSamplerate(ceil(value.split(" ", QString::SkipEmptyParts).first().toFloat() * 1000.0f));
 292                 }
 293                 else if(!key.compare("Bit depth", Qt::CaseInsensitive))
 294                 {
 295                         if(!audioFile.formatAudioBitdepth()) audioFile.setFormatAudioBitdepth(value.split(" ", QString::SkipEmptyParts).first().toInt());
 296                 }
 297                 else if(!key.compare("Duration", Qt::CaseInsensitive))
 298                 {
 299                         if(!audioFile.fileDuration()) audioFile.setFileDuration(parseDuration(value));
 300                 }
 301                 break;
 302         }
 303 }
 304
 305 unsigned int FileAnalyzer::parseYear(const QString &str)
 306 {
 307         if(str.startsWith("UTC", Qt::CaseInsensitive))
 308         {
 309                 QDate date = QDate::fromString(str.mid(3).trimmed().left(10), "yyyy-MM-dd");
 310                 if(date.isValid())
 311                 {
 312                         return date.year();
 313                 }
 314                 else
 315                 {
 316                         return 0;
 317                 }
 318         }
 319         else
 320         {
 321                 bool ok = false;
 322                 int year = str.toInt(&ok);
 323                 if(ok && year > 0)
 324                 {
 325                         return year;
 326                 }
 327                 else
 328                 {
 329                         return 0;
 330                 }
 331         }
 332 }
 333
 334 unsigned int FileAnalyzer::parseDuration(const QString &str)
 335 {
 336         QTime time;
 337
 338         time = QTime::fromString(str, "z'ms'");
 339         if(time.isValid())
 340         {
 341                 return max(1, (time.hour() * 60 * 60) + (time.minute() * 60) + time.second());
 342         }
 343
 344         time = QTime::fromString(str, "s's 'z'ms'");
 345         if(time.isValid())
 346         {
 347                 return max(1, (time.hour() * 60 * 60) + (time.minute() * 60) + time.second());
 348         }
 349
 350         time = QTime::fromString(str, "m'mn 's's'");
 351         if(time.isValid())
 352         {
 353                 return max(1, (time.hour() * 60 * 60) + (time.minute() * 60) + time.second());
 354         }
 355
 356         time = QTime::fromString(str, "h'h 'm'mn'");
 357         if(time.isValid())
 358         {
 359                 return max(1, (time.hour() * 60 * 60) + (time.minute() * 60) + time.second());
 360         }
 361
 362         return 0;
 363 }
 364
 365
 366 bool FileAnalyzer::importPlaylist(QStringList &fileList, const QString &playlistFile)
 367 {
 368         QFileInfo file(playlistFile);
 369         QDir baseDir(file.canonicalPath());
 370
 371         QDir rootDir(baseDir);
 372         while(rootDir.cdUp());
 373
 374         //Sanity check
 375         if(file.size() < 3 || file.size() > 512000)
 376         {
 377                 return false;
 378         }
 379
 380         //Detect playlist type
 381         playlist_t playlistType = isPlaylist(file.canonicalFilePath());
 382
 383         //Exit if not a playlist
 384         if(playlistType == noPlaylist)
 385         {
 386                 return false;
 387         }
 388
 389         QFile data(playlistFile);
 390
 391         //Open file for reading
 392         if(!data.open(QIODevice::ReadOnly))
 393         {
 394                 return false;
 395         }
 396
 397         //Parse playlist depending on type
 398         switch(playlistType)
 399         {
 400         case m3uPlaylist:
 401                 return parsePlaylist_m3u(data, fileList, baseDir, rootDir);
 402                 break;
 403         case plsPlaylist:
 404                 return parsePlaylist_pls(data, fileList, baseDir, rootDir);
 405                 break;
 406         case wplPlaylist:
 407                 return parsePlaylist_wpl(data, fileList, baseDir, rootDir);
 408                 break;
 409         default:
 410                 return false;
 411                 break;
 412         }
 413 }
 414
 415 bool FileAnalyzer::parsePlaylist_m3u(QFile &data, QStringList &fileList, const QDir &baseDir, const QDir &rootDir)
 416 {
 417         QByteArray line = data.readLine();
 418
 419         while(line.size() > 0)
 420         {
 421                 QFileInfo filename1(QDir::fromNativeSeparators(QString::fromUtf8(line.constData(), line.size()).trimmed()));
 422                 QFileInfo filename2(QDir::fromNativeSeparators(QString::fromLatin1(line.constData(), line.size()).trimmed()));
 423
 424                 filename1.setCaching(false);
 425                 filename2.setCaching(false);
 426
 427                 if(!(filename1.filePath().startsWith("#") || filename2.filePath().startsWith("#")))
 428                 {
 429                         fixFilePath(filename1, baseDir, rootDir);
 430                         fixFilePath(filename2, baseDir, rootDir);
 431
 432                         if(filename1.exists())
 433                         {
 434                                 if(isPlaylist(filename1.canonicalFilePath()) == noPlaylist)
 435                                 {
 436                                         fileList << filename1.canonicalFilePath();
 437                                 }
 438                         }
 439                         else if(filename2.exists())
 440                         {
 441                                 if(isPlaylist(filename2.canonicalFilePath()) == noPlaylist)
 442                                 {
 443                                         fileList << filename2.canonicalFilePath();
 444                                 }
 445                         }
 446                 }
 447
 448                 line = data.readLine();
 449         }
 450
 451         return true;
 452 }
 453
 454 bool FileAnalyzer::parsePlaylist_pls(QFile &data, QStringList &fileList, const QDir &baseDir, const QDir &rootDir)
 455 {
 456         QRegExp plsEntry("File(\\d+)=(.+)", Qt::CaseInsensitive);
 457         QByteArray line = data.readLine();
 458
 459         while(line.size() > 0)
 460         {
 461                 bool flag = false;
 462
 463                 QString temp1(QDir::fromNativeSeparators(QString::fromUtf8(line.constData(), line.size()).trimmed()));
 464                 QString temp2(QDir::fromNativeSeparators(QString::fromLatin1(line.constData(), line.size()).trimmed()));
 465
 466                 if(!flag && plsEntry.indexIn(temp1) >= 0)
 467                 {
 468                         QFileInfo filename(QDir::fromNativeSeparators(plsEntry.cap(2)).trimmed());
 469                         filename.setCaching(false);
 470                         fixFilePath(filename, baseDir, rootDir);
 471
 472                         if(filename.exists())
 473                         {
 474                                 if(isPlaylist(filename.canonicalFilePath()) == noPlaylist)
 475                                 {
 476                                         fileList << filename.canonicalFilePath();
 477                                         flag = true;
 478                                 }
 479                         }
 480                 }
 481
 482                 if(!flag && plsEntry.indexIn(temp2) >= 0)
 483                 {
 484                         QFileInfo filename(QDir::fromNativeSeparators(plsEntry.cap(2)).trimmed());
 485                         filename.setCaching(false);
 486                         fixFilePath(filename, baseDir, rootDir);
 487
 488                         if(filename.exists())
 489                         {
 490                                 if(isPlaylist(filename.canonicalFilePath()) == noPlaylist)
 491                                 {
 492                                         fileList << filename.canonicalFilePath();
 493                                         flag = true;
 494                                 }
 495                         }
 496                 }
 497
 498                 line = data.readLine();
 499         }
 500
 501         return true;
 502 }
 503
 504 bool FileAnalyzer::parsePlaylist_wpl(QFile &data, QStringList &fileList, const QDir &baseDir, const QDir &rootDir)
 505 {
 506         QRegExp skipData("<!--(.+)-->", Qt::CaseInsensitive);
 507         QRegExp wplEntry("<(media|ref)[^<>]*(src|href)=\"([^\"]+)\"[^<>]*>", Qt::CaseInsensitive);
 508
 509         skipData.setMinimal(true);
 510
 511         QByteArray buffer = data.readAll();
 512         QString line = QString::fromUtf8(buffer.constData(), buffer.size()).simplified();
 513         buffer.clear();
 514
 515         int index = 0;
 516
 517         while((index = skipData.indexIn(line)) >= 0)
 518         {
 519                 line.remove(index, skipData.matchedLength());
 520         }
 521
 522         int offset = 0;
 523
 524         while((offset = wplEntry.indexIn(line, offset) + 1) > 0)
 525         {
 526                 QFileInfo filename(QDir::fromNativeSeparators(wplEntry.cap(3).XML_DECODE.trimmed()));
 527                 filename.setCaching(false);
 528                 fixFilePath(filename, baseDir, rootDir);
 529
 530                 if(filename.exists())
 531                 {
 532                         if(isPlaylist(filename.canonicalFilePath()) == noPlaylist)
 533                         {
 534                                 fileList << filename.canonicalFilePath();
 535                         }
 536                 }
 537         }
 538
 539         return true;
 540 }
 541
 542 FileAnalyzer::playlist_t FileAnalyzer::isPlaylist(const QString &fileName)
 543 {
 544         QFileInfo file (fileName);
 545
 546         if(file.suffix().compare("m3u", Qt::CaseInsensitive) == 0)
 547         {
 548                 return m3uPlaylist;
 549         }
 550         else if(file.suffix().compare("m3u8", Qt::CaseInsensitive) == 0)
 551         {
 552                 return m3uPlaylist;
 553         }
 554         else if(file.suffix().compare("pls", Qt::CaseInsensitive) == 0)
 555         {
 556                 return  plsPlaylist;
 557         }
 558         else if(file.suffix().compare("asx", Qt::CaseInsensitive) == 0)
 559         {
 560                 return  wplPlaylist;
 561         }
 562         else if(file.suffix().compare("wpl", Qt::CaseInsensitive) == 0)
 563         {
 564                 return  wplPlaylist;
 565         }
 566         else
 567         {
 568                 return noPlaylist;
 569         }
 570 }
 571
 572 void FileAnalyzer::fixFilePath(QFileInfo &filename, const QDir &baseDir, const QDir &rootDir)
 573 {
 574         if(filename.filePath().startsWith("/"))
 575         {
 576                 while(filename.filePath().startsWith("/"))
 577                 {
 578                         filename.setFile(filename.filePath().mid(1));
 579                 }
 580                 filename.setFile(rootDir.filePath(filename.filePath()));
 581         }
 582
 583         if(!filename.isAbsolute())
 584         {
 585                 filename.setFile(baseDir.filePath(filename.filePath()));
 586         }
 587 }
 588
 589 ////////////////////////////////////////////////////////////
 590 // Public Functions
 591 ////////////////////////////////////////////////////////////
 592
 593 unsigned int FileAnalyzer::filesAccepted(void)
 594 {
 595         return m_filesAccepted;
 596 }
 597
 598 unsigned int FileAnalyzer::filesRejected(void)
 599 {
 600         return m_filesRejected - m_filesDenied;
 601 }
 602
 603 unsigned int FileAnalyzer::filesDenied(void)
 604 {
 605         return m_filesDenied;
 606 }
 607
 608 ////////////////////////////////////////////////////////////
 609 // EVENTS
 610 ////////////////////////////////////////////////////////////
 611
 612 /*NONE*/