src/Thread_FileAnalyzer_ST.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // LameXP - Audio Encoder Front-End
   3 // Copyright (C) 2004-2013 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 // --------------------------------------------------------------------
  23 // !!! THIS IS THE OLD SINGLE-THREADED VERSION OF THE FILE ANALYZER !!!
  24 // --------------------------------------------------------------------
  25
  26 #include "Thread_FileAnalyzer_ST.h"
  27
  28 #include "Global.h"
  29 #include "LockedFile.h"
  30 #include "Model_AudioFile.h"
  31 #include "PlaylistImporter.h"
  32
  33 #include <QDir>
  34 #include <QFileInfo>
  35 #include <QProcess>
  36 #include <QDate>
  37 #include <QTime>
  38 #include <QDebug>
  39 #include <QImage>
  40
  41 #include <math.h>
  42
  43 #define IS_KEY(KEY) (key.compare(KEY, Qt::CaseInsensitive) == 0)
  44 #define IS_SEC(SEC) (key.startsWith((SEC "_"), Qt::CaseInsensitive))
  45 #define FIRST_TOK(STR) (STR.split(" ", QString::SkipEmptyParts).first())
  46
  47 ////////////////////////////////////////////////////////////
  48 // Constructor
  49 ////////////////////////////////////////////////////////////
  50
  51 FileAnalyzer_ST::FileAnalyzer_ST(const QStringList &inputFiles)
  52 :
  53         m_inputFiles(inputFiles),
  54         m_mediaInfoBin(lamexp_lookup_tool("mediainfo.exe")),
  55         m_avs2wavBin(lamexp_lookup_tool("avs2wav.exe")),
  56         m_templateFile(NULL),
  57         m_abortFlag(false)
  58 {
  59         m_bSuccess = false;
  60         m_bAborted = false;
  61
  62         if(m_mediaInfoBin.isEmpty())
  63         {
  64                 qFatal("Invalid path to MediaInfo binary. Tool not initialized properly.");
  65         }
  66
  67         m_filesAccepted = 0;
  68         m_filesRejected = 0;
  69         m_filesDenied = 0;
  70         m_filesDummyCDDA = 0;
  71         m_filesCueSheet = 0;
  72 }
  73
  74 FileAnalyzer_ST::~FileAnalyzer_ST(void)
  75 {
  76         if(m_templateFile)
  77         {
  78                 QString templatePath = m_templateFile->filePath();
  79                 LAMEXP_DELETE(m_templateFile);
  80                 if(QFile::exists(templatePath)) QFile::remove(templatePath);
  81         }
  82 }
  83
  84 ////////////////////////////////////////////////////////////
  85 // Static data
  86 ////////////////////////////////////////////////////////////
  87
  88 const char *FileAnalyzer_ST::g_tags_gen[] =
  89 {
  90         "ID",
  91         "Format",
  92         "Format_Profile",
  93         "Format_Version",
  94         "Duration",
  95         "Title", "Track",
  96         "Track/Position",
  97         "Artist", "Performer",
  98         "Album",
  99         "Genre",
 100         "Released_Date", "Recorded_Date",
 101         "Comment",
 102         "Cover",
 103         "Cover_Type",
 104         "Cover_Mime",
 105         "Cover_Data",
 106         NULL
 107 };
 108
 109 const char *FileAnalyzer_ST::g_tags_aud[] =
 110 {
 111         "ID",
 112         "Source",
 113         "Format",
 114         "Format_Profile",
 115         "Format_Version",
 116         "Channel(s)",
 117         "SamplingRate",
 118         "BitDepth",
 119         "BitRate",
 120         "BitRate_Mode",
 121         NULL
 122 };
 123
 124 ////////////////////////////////////////////////////////////
 125 // Thread Main
 126 ////////////////////////////////////////////////////////////
 127
 128 void FileAnalyzer_ST::run()
 129 {
 130         m_bSuccess = false;
 131         m_bAborted = false;
 132
 133         m_filesAccepted = 0;
 134         m_filesRejected = 0;
 135         m_filesDenied = 0;
 136         m_filesDummyCDDA = 0;
 137         m_filesCueSheet = 0;
 138
 139         lamexp_natural_string_sort(m_inputFiles); // .sort()
 140
 141         m_recentlyAdded.clear();
 142         m_abortFlag = false;
 143
 144         if(!m_templateFile)
 145         {
 146                 if(!createTemplate())
 147                 {
 148                         qWarning("Failed to create template file!");
 149                         return;
 150                 }
 151         }
 152
 153         while(!m_inputFiles.isEmpty())
 154         {
 155                 int fileType = fileTypeNormal;
 156                 QString currentFile = QDir::fromNativeSeparators(m_inputFiles.takeFirst());
 157                 qDebug("Analyzing: %s", currentFile.toUtf8().constData());
 158                 emit fileSelected(QFileInfo(currentFile).fileName());
 159                 AudioFileModel file = analyzeFile(currentFile, &fileType);
 160
 161                 if(m_abortFlag)
 162                 {
 163                         MessageBeep(MB_ICONERROR);
 164                         m_bAborted = true;
 165                         qWarning("Operation cancelled by user!");
 166                         return;
 167                 }
 168                 if(fileType == fileTypeSkip)
 169                 {
 170                         qWarning("File was recently added, skipping!");
 171                         continue;
 172                 }
 173                 if(fileType == fileTypeDenied)
 174                 {
 175                         m_filesDenied++;
 176                         qWarning("Cannot access file for reading, skipping!");
 177                         continue;
 178                 }
 179                 if(fileType == fileTypeCDDA)
 180                 {
 181                         m_filesDummyCDDA++;
 182                         qWarning("Dummy CDDA file detected, skipping!");
 183                         continue;
 184                 }
 185
 186                 if(file.fileName().isEmpty() || file.formatContainerType().isEmpty() || file.formatAudioType().isEmpty())
 187                 {
 188                         if(PlaylistImporter::importPlaylist(m_inputFiles, currentFile))
 189                         {
 190                                 qDebug("Imported playlist file.");
 191                         }
 192                         else if(!QFileInfo(currentFile).suffix().compare("cue", Qt::CaseInsensitive))
 193                         {
 194                                 qWarning("Cue Sheet file detected, skipping!");
 195                                 m_filesCueSheet++;
 196                         }
 197                         else if(!QFileInfo(currentFile).suffix().compare("avs", Qt::CaseInsensitive))
 198                         {
 199                                 qDebug("Found a potential Avisynth script, investigating...");
 200                                 if(analyzeAvisynthFile(currentFile, file))
 201                                 {
 202                                         m_filesAccepted++;
 203                                         emit fileAnalyzed(file);
 204                                 }
 205                                 else
 206                                 {
 207                                         qDebug("Rejected Avisynth file: %s", file.filePath().toUtf8().constData());
 208                                         m_filesRejected++;
 209                                 }
 210                         }
 211                         else
 212                         {
 213                                 qDebug("Rejected file of unknown type: %s", file.filePath().toUtf8().constData());
 214                                 m_filesRejected++;
 215                         }
 216                         continue;
 217                 }
 218
 219                 m_filesAccepted++;
 220                 m_recentlyAdded.append(file.filePath());
 221                 emit fileAnalyzed(file);
 222         }
 223
 224         qDebug("All files added.\n");
 225         m_bSuccess = true;
 226 }
 227
 228 ////////////////////////////////////////////////////////////
 229 // Privtae Functions
 230 ////////////////////////////////////////////////////////////
 231
 232 const AudioFileModel FileAnalyzer_ST::analyzeFile(const QString &filePath, int *type)
 233 {
 234         *type = fileTypeNormal;
 235
 236         AudioFileModel audioFile(filePath);
 237
 238         if(m_recentlyAdded.contains(filePath, Qt::CaseInsensitive))
 239         {
 240                 *type = fileTypeSkip;
 241                 return audioFile;
 242         }
 243
 244         QFile readTest(filePath);
 245         if(!readTest.open(QIODevice::ReadOnly))
 246         {
 247                 *type = fileTypeDenied;
 248                 return audioFile;
 249         }
 250         if(checkFile_CDDA(readTest))
 251         {
 252                 *type = fileTypeCDDA;
 253                 return audioFile;
 254         }
 255         readTest.close();
 256
 257         bool skipNext = false;
 258         unsigned int id_val[2] = {UINT_MAX, UINT_MAX};
 259         cover_t coverType = coverNone;
 260         QByteArray coverData;
 261
 262         QStringList params;
 263         params << QString("--Inform=file://%1").arg(QDir::toNativeSeparators(m_templateFile->filePath()));
 264         params << QDir::toNativeSeparators(filePath);
 265
 266         QProcess process;
 267         process.setProcessChannelMode(QProcess::MergedChannels);
 268         process.setReadChannel(QProcess::StandardOutput);
 269         process.start(m_mediaInfoBin, params);
 270
 271         if(!process.waitForStarted())
 272         {
 273                 qWarning("MediaInfo process failed to create!");
 274                 qWarning("Error message: \"%s\"\n", process.errorString().toLatin1().constData());
 275                 process.kill();
 276                 process.waitForFinished(-1);
 277                 return audioFile;
 278         }
 279
 280         while(process.state() != QProcess::NotRunning)
 281         {
 282                 if(m_abortFlag)
 283                 {
 284                         process.kill();
 285                         qWarning("Process was aborted on user request!");
 286                         break;
 287                 }
 288
 289                 if(!process.waitForReadyRead())
 290                 {
 291                         if(process.state() == QProcess::Running)
 292                         {
 293                                 qWarning("MediaInfo time out. Killing process and skipping file!");
 294                                 process.kill();
 295                                 process.waitForFinished(-1);
 296                                 return audioFile;
 297                         }
 298                 }
 299
 300                 QByteArray data;
 301
 302                 while(process.canReadLine())
 303                 {
 304                         QString line = QString::fromUtf8(process.readLine().constData()).simplified();
 305                         if(!line.isEmpty())
 306                         {
 307                                 //qDebug("Line:%s", line.toUtf8().constData());
 308
 309                                 int index = line.indexOf('=');
 310                                 if(index > 0)
 311                                 {
 312                                         QString key = line.left(index).trimmed();
 313                                         QString val = line.mid(index+1).trimmed();
 314                                         if(!key.isEmpty())
 315                                         {
 316                                                 updateInfo(audioFile, &skipNext, id_val, &coverType, &coverData, key, val);
 317                                         }
 318                                 }
 319                         }
 320                 }
 321         }
 322
 323         if(audioFile.fileName().isEmpty())
 324         {
 325                 QString baseName = QFileInfo(filePath).fileName();
 326                 int index = baseName.lastIndexOf(".");
 327
 328                 if(index >= 0)
 329                 {
 330                         baseName = baseName.left(index);
 331                 }
 332
 333                 baseName = baseName.replace("_", " ").simplified();
 334                 index = baseName.lastIndexOf(" - ");
 335
 336                 if(index >= 0)
 337                 {
 338                         baseName = baseName.mid(index + 3).trimmed();
 339                 }
 340
 341                 audioFile.setFileName(baseName);
 342         }
 343
 344         process.waitForFinished();
 345         if(process.state() != QProcess::NotRunning)
 346         {
 347                 process.kill();
 348                 process.waitForFinished(-1);
 349         }
 350
 351         if((coverType != coverNone) && (!coverData.isEmpty()))
 352         {
 353                 retrieveCover(audioFile, coverType, coverData);
 354         }
 355
 356         return audioFile;
 357 }
 358
 359 void FileAnalyzer_ST::updateInfo(AudioFileModel &audioFile, bool *skipNext, unsigned int *id_val, cover_t *coverType, QByteArray *coverData, const QString &key, const QString &value)
 360 {
 361         //qWarning("'%s' -> '%s'", key.toUtf8().constData(), value.toUtf8().constData());
 362
 363         /*New Stream*/
 364         if(IS_KEY("Gen_ID") || IS_KEY("Aud_ID"))
 365         {
 366                 if(value.isEmpty())
 367                 {
 368                         *skipNext = false;
 369                 }
 370                 else
 371                 {
 372                         //We ignore all ID's, except for the lowest one!
 373                         bool ok = false;
 374                         unsigned int id = value.toUInt(&ok);
 375                         if(ok)
 376                         {
 377                                 if(IS_KEY("Gen_ID")) { id_val[0] = qMin(id_val[0], id); *skipNext = (id > id_val[0]); }
 378                                 if(IS_KEY("Aud_ID")) { id_val[1] = qMin(id_val[1], id); *skipNext = (id > id_val[1]); }
 379                         }
 380                         else
 381                         {
 382                                 *skipNext = true;
 383                         }
 384                 }
 385                 if(*skipNext)
 386                 {
 387                         qWarning("Skipping info for non-primary stream!");
 388                 }
 389                 return;
 390         }
 391
 392         /*Skip or empty?*/
 393         if((*skipNext) || value.isEmpty())
 394         {
 395                 return;
 396         }
 397
 398         /*Playlist file?*/
 399         if(IS_KEY("Aud_Source"))
 400         {
 401                 *skipNext = true;
 402                 audioFile.setFormatContainerType(QString());
 403                 audioFile.setFormatAudioType(QString());
 404                 qWarning("Skipping info for playlist file!");
 405                 return;
 406         }
 407
 408         /*General Section*/
 409         if(IS_SEC("Gen"))
 410         {
 411                 if(IS_KEY("Gen_Format"))
 412                 {
 413                         audioFile.setFormatContainerType(value);
 414                 }
 415                 else if(IS_KEY("Gen_Format_Profile"))
 416                 {
 417                         audioFile.setFormatContainerProfile(value);
 418                 }
 419                 else if(IS_KEY("Gen_Title") || IS_KEY("Gen_Track"))
 420                 {
 421                         audioFile.setFileName(value);
 422                 }
 423                 else if(IS_KEY("Gen_Duration"))
 424                 {
 425                         unsigned int tmp = parseDuration(value);
 426                         if(tmp > 0) audioFile.setFileDuration(tmp);
 427                 }
 428                 else if(IS_KEY("Gen_Artist") || IS_KEY("Gen_Performer"))
 429                 {
 430                         audioFile.setFileArtist(value);
 431                 }
 432                 else if(IS_KEY("Gen_Album"))
 433                 {
 434                         audioFile.setFileAlbum(value);
 435                 }
 436                 else if(IS_KEY("Gen_Genre"))
 437                 {
 438                         audioFile.setFileGenre(value);
 439                 }
 440                 else if(IS_KEY("Gen_Released_Date") || IS_KEY("Gen_Recorded_Date"))
 441                 {
 442                         unsigned int tmp = parseYear(value);
 443                         if(tmp > 0) audioFile.setFileYear(tmp);
 444                 }
 445                 else if(IS_KEY("Gen_Comment"))
 446                 {
 447                         audioFile.setFileComment(value);
 448                 }
 449                 else if(IS_KEY("Gen_Track/Position"))
 450                 {
 451                         bool ok = false;
 452                         unsigned int tmp = value.toUInt(&ok);
 453                         if(ok) audioFile.setFilePosition(tmp);
 454                 }
 455                 else if(IS_KEY("Gen_Cover") || IS_KEY("Gen_Cover_Type"))
 456                 {
 457                         if(*coverType == coverNone)
 458                         {
 459                                 *coverType = coverJpeg;
 460                         }
 461                 }
 462                 else if(IS_KEY("Gen_Cover_Mime"))
 463                 {
 464                         QString temp = FIRST_TOK(value);
 465                         if(!temp.compare("image/jpeg", Qt::CaseInsensitive)) *coverType = coverJpeg;
 466                         else if(!temp.compare("image/png", Qt::CaseInsensitive)) *coverType = coverPng;
 467                         else if(!temp.compare("image/gif", Qt::CaseInsensitive)) *coverType = coverGif;
 468                 }
 469                 else if(IS_KEY("Gen_Cover_Data"))
 470                 {
 471                         if(!coverData->isEmpty()) coverData->clear();
 472                         coverData->append(QByteArray::fromBase64(FIRST_TOK(value).toLatin1()));
 473                 }
 474                 else
 475                 {
 476                         qWarning("Unknown key '%s' with value '%s' found!", key.toUtf8().constData(), value.toUtf8().constData());
 477                 }
 478                 return;
 479         }
 480
 481         /*Audio Section*/
 482         if(IS_SEC("Aud"))
 483         {
 484
 485                 if(IS_KEY("Aud_Format"))
 486                 {
 487                         audioFile.setFormatAudioType(value);
 488                 }
 489                 else if(IS_KEY("Aud_Format_Profile"))
 490                 {
 491                         audioFile.setFormatAudioProfile(value);
 492                 }
 493                 else if(IS_KEY("Aud_Format_Version"))
 494                 {
 495                         audioFile.setFormatAudioVersion(value);
 496                 }
 497                 else if(IS_KEY("Aud_Channel(s)"))
 498                 {
 499                         bool ok = false;
 500                         unsigned int tmp = value.toUInt(&ok);
 501                         if(ok) audioFile.setFormatAudioChannels(tmp);
 502                 }
 503                 else if(IS_KEY("Aud_SamplingRate"))
 504                 {
 505                         bool ok = false;
 506                         unsigned int tmp = value.toUInt(&ok);
 507                         if(ok) audioFile.setFormatAudioSamplerate(tmp);
 508                 }
 509                 else if(IS_KEY("Aud_BitDepth"))
 510                 {
 511                         bool ok = false;
 512                         unsigned int tmp = value.toUInt(&ok);
 513                         if(ok) audioFile.setFormatAudioBitdepth(tmp);
 514                 }
 515                 else if(IS_KEY("Aud_Duration"))
 516                 {
 517                         unsigned int tmp = parseDuration(value);
 518                         if(tmp > 0) audioFile.setFileDuration(tmp);
 519                 }
 520                 else if(IS_KEY("Aud_BitRate"))
 521                 {
 522                         bool ok = false;
 523                         unsigned int tmp = value.toUInt(&ok);
 524                         if(ok) audioFile.setFormatAudioBitrate(tmp/1000);
 525                 }
 526                 else if(IS_KEY("Aud_BitRate_Mode"))
 527                 {
 528                         if(!value.compare("CBR", Qt::CaseInsensitive)) audioFile.setFormatAudioBitrateMode(AudioFileModel::BitrateModeConstant);
 529                         if(!value.compare("VBR", Qt::CaseInsensitive)) audioFile.setFormatAudioBitrateMode(AudioFileModel::BitrateModeVariable);
 530                 }
 531                 else
 532                 {
 533                         qWarning("Unknown key '%s' with value '%s' found!", key.toUtf8().constData(), value.toUtf8().constData());
 534                 }
 535                 return;
 536         }
 537
 538         /*Section not recognized*/
 539         qWarning("Unknown section: %s", key.toUtf8().constData());
 540 }
 541
 542 bool FileAnalyzer_ST::checkFile_CDDA(QFile &file)
 543 {
 544         file.reset();
 545         QByteArray data = file.read(128);
 546
 547         int i = data.indexOf("RIFF");
 548         int j = data.indexOf("CDDA");
 549         int k = data.indexOf("fmt ");
 550
 551         return ((i >= 0) && (j >= 0) && (k >= 0) && (k > j) && (j > i));
 552 }
 553
 554 void FileAnalyzer_ST::retrieveCover(AudioFileModel &audioFile, cover_t coverType, const QByteArray &coverData)
 555 {
 556         qDebug("Retrieving cover!");
 557         QString extension;
 558
 559         switch(coverType)
 560         {
 561         case coverPng:
 562                 extension = QString::fromLatin1("png");
 563                 break;
 564         case coverGif:
 565                 extension = QString::fromLatin1("gif");
 566                 break;
 567         default:
 568                 extension = QString::fromLatin1("jpg");
 569                 break;
 570         }
 571
 572         if(!(QImage::fromData(coverData, extension.toUpper().toLatin1().constData()).isNull()))
 573         {
 574                 QFile coverFile(QString("%1/%2.%3").arg(lamexp_temp_folder2(), lamexp_rand_str(), extension));
 575                 if(coverFile.open(QIODevice::WriteOnly))
 576                 {
 577                         coverFile.write(coverData);
 578                         coverFile.close();
 579                         audioFile.setFileCover(coverFile.fileName(), true);
 580                 }
 581         }
 582         else
 583         {
 584                 qWarning("Image data seems to be invalid :-(");
 585         }
 586 }
 587
 588 bool FileAnalyzer_ST::analyzeAvisynthFile(const QString &filePath, AudioFileModel &info)
 589 {
 590         QProcess process;
 591         process.setProcessChannelMode(QProcess::MergedChannels);
 592         process.setReadChannel(QProcess::StandardOutput);
 593         process.start(m_avs2wavBin, QStringList() << QDir::toNativeSeparators(filePath) << "?");
 594
 595         if(!process.waitForStarted())
 596         {
 597                 qWarning("AVS2WAV process failed to create!");
 598                 qWarning("Error message: \"%s\"\n", process.errorString().toLatin1().constData());
 599                 process.kill();
 600                 process.waitForFinished(-1);
 601                 return false;
 602         }
 603
 604         bool bInfoHeaderFound = false;
 605
 606         while(process.state() != QProcess::NotRunning)
 607         {
 608                 if(m_abortFlag)
 609                 {
 610                         process.kill();
 611                         qWarning("Process was aborted on user request!");
 612                         break;
 613                 }
 614
 615                 if(!process.waitForReadyRead())
 616                 {
 617                         if(process.state() == QProcess::Running)
 618                         {
 619                                 qWarning("AVS2WAV time out. Killing process and skipping file!");
 620                                 process.kill();
 621                                 process.waitForFinished(-1);
 622                                 return false;
 623                         }
 624                 }
 625
 626                 QByteArray data;
 627
 628                 while(process.canReadLine())
 629                 {
 630                         QString line = QString::fromUtf8(process.readLine().constData()).simplified();
 631                         if(!line.isEmpty())
 632                         {
 633                                 int index = line.indexOf(':');
 634                                 if(index > 0)
 635                                 {
 636                                         QString key = line.left(index).trimmed();
 637                                         QString val = line.mid(index+1).trimmed();
 638
 639                                         if(bInfoHeaderFound && !key.isEmpty() && !val.isEmpty())
 640                                         {
 641                                                 if(key.compare("TotalSeconds", Qt::CaseInsensitive) == 0)
 642                                                 {
 643                                                         bool ok = false;
 644                                                         unsigned int duration = val.toUInt(&ok);
 645                                                         if(ok) info.setFileDuration(duration);
 646                                                 }
 647                                                 if(key.compare("SamplesPerSec", Qt::CaseInsensitive) == 0)
 648                                                 {
 649                                                         bool ok = false;
 650                                                         unsigned int samplerate = val.toUInt(&ok);
 651                                                         if(ok) info.setFormatAudioSamplerate (samplerate);
 652                                                 }
 653                                                 if(key.compare("Channels", Qt::CaseInsensitive) == 0)
 654                                                 {
 655                                                         bool ok = false;
 656                                                         unsigned int channels = val.toUInt(&ok);
 657                                                         if(ok) info.setFormatAudioChannels(channels);
 658                                                 }
 659                                                 if(key.compare("BitsPerSample", Qt::CaseInsensitive) == 0)
 660                                                 {
 661                                                         bool ok = false;
 662                                                         unsigned int bitdepth = val.toUInt(&ok);
 663                                                         if(ok) info.setFormatAudioBitdepth(bitdepth);
 664                                                 }
 665                                         }
 666                                 }
 667                                 else
 668                                 {
 669                                         if(line.contains("[Audio Info]", Qt::CaseInsensitive))
 670                                         {
 671                                                 info.setFormatAudioType("Avisynth");
 672                                                 info.setFormatContainerType("Avisynth");
 673                                                 bInfoHeaderFound = true;
 674                                         }
 675                                 }
 676                         }
 677                 }
 678         }
 679
 680         process.waitForFinished();
 681         if(process.state() != QProcess::NotRunning)
 682         {
 683                 process.kill();
 684                 process.waitForFinished(-1);
 685         }
 686
 687         //Check exit code
 688         switch(process.exitCode())
 689         {
 690         case 0:
 691                 qDebug("Avisynth script was analyzed successfully.");
 692                 return true;
 693                 break;
 694         case -5:
 695                 qWarning("It appears that Avisynth is not installed on the system!");
 696                 return false;
 697                 break;
 698         default:
 699                 qWarning("Failed to open the Avisynth script, bad AVS file?");
 700                 return false;
 701                 break;
 702         }
 703 }
 704
 705 bool FileAnalyzer_ST::createTemplate(void)
 706 {
 707         if(m_templateFile)
 708         {
 709                 qWarning("Template file already exists!");
 710                 return true;
 711         }
 712
 713         QString templatePath = QString("%1/%2.txt").arg(lamexp_temp_folder2(), lamexp_rand_str());
 714
 715         QFile templateFile(templatePath);
 716         if(!templateFile.open(QIODevice::WriteOnly))
 717         {
 718                 return false;
 719         }
 720
 721         templateFile.write("General;");
 722         for(size_t i = 0; g_tags_gen[i]; i++)
 723         {
 724                 templateFile.write(QString("Gen_%1=%%1%\\n").arg(g_tags_gen[i]).toLatin1().constData());
 725         }
 726         templateFile.write("\\n\r\n");
 727
 728         templateFile.write("Audio;");
 729         for(size_t i = 0; g_tags_aud[i]; i++)
 730         {
 731                 templateFile.write(QString("Aud_%1=%%1%\\n").arg(g_tags_aud[i]).toLatin1().constData());
 732         }
 733         templateFile.write("\\n\r\n");
 734
 735         bool success = (templateFile.error() == QFile::NoError);
 736         templateFile.close();
 737
 738         if(!success)
 739         {
 740                 QFile::remove(templatePath);
 741                 return false;
 742         }
 743
 744         try
 745         {
 746                 m_templateFile = new LockedFile(templatePath);
 747         }
 748         catch(...)
 749         {
 750                 qWarning("Failed to lock template file!");
 751                 return false;
 752         }
 753
 754         return true;
 755 }
 756
 757 unsigned int FileAnalyzer_ST::parseYear(const QString &str)
 758 {
 759         if(str.startsWith("UTC", Qt::CaseInsensitive))
 760         {
 761                 QDate date = QDate::fromString(str.mid(3).trimmed().left(10), "yyyy-MM-dd");
 762                 if(date.isValid())
 763                 {
 764                         return date.year();
 765                 }
 766                 else
 767                 {
 768                         return 0;
 769                 }
 770         }
 771         else
 772         {
 773                 bool ok = false;
 774                 int year = str.toInt(&ok);
 775                 if(ok && year > 0)
 776                 {
 777                         return year;
 778                 }
 779                 else
 780                 {
 781                         return 0;
 782                 }
 783         }
 784 }
 785
 786 unsigned int FileAnalyzer_ST::parseDuration(const QString &str)
 787 {
 788         bool ok = false;
 789         unsigned int value = str.toUInt(&ok);
 790         return ok ? (value/1000) : 0;
 791 }
 792
 793 ////////////////////////////////////////////////////////////
 794 // Public Functions
 795 ////////////////////////////////////////////////////////////
 796
 797 unsigned int FileAnalyzer_ST::filesAccepted(void)
 798 {
 799         return m_filesAccepted;
 800 }
 801
 802 unsigned int FileAnalyzer_ST::filesRejected(void)
 803 {
 804         return m_filesRejected;
 805 }
 806
 807 unsigned int FileAnalyzer_ST::filesDenied(void)
 808 {
 809         return m_filesDenied;
 810 }
 811
 812 unsigned int FileAnalyzer_ST::filesDummyCDDA(void)
 813 {
 814         return m_filesDummyCDDA;
 815 }
 816
 817 unsigned int FileAnalyzer_ST::filesCueSheet(void)
 818 {
 819         return m_filesCueSheet;
 820 }
 821
 822 ////////////////////////////////////////////////////////////
 823 // EVENTS
 824 ////////////////////////////////////////////////////////////
 825
 826 /*NONE*/