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 #include "PlaylistImporter.h"
  28
  29 #include <QDir>
  30 #include <QFileInfo>
  31 #include <QProcess>
  32 #include <QDate>
  33 #include <QTime>
  34 #include <QDebug>
  35
  36 #include <math.h>
  37
  38 ////////////////////////////////////////////////////////////
  39 // Constructor
  40 ////////////////////////////////////////////////////////////
  41
  42 FileAnalyzer::FileAnalyzer(const QStringList &inputFiles)
  43 :
  44         m_inputFiles(inputFiles),
  45         m_mediaInfoBin(lamexp_lookup_tool("mediainfo.exe")),
  46         m_avs2wavBin(lamexp_lookup_tool("avs2wav.exe")),
  47         m_abortFlag(false)
  48 {
  49         m_bSuccess = false;
  50         m_bAborted = false;
  51
  52         if(m_mediaInfoBin.isEmpty())
  53         {
  54                 qFatal("Invalid path to MediaInfo binary. Tool not initialized properly.");
  55         }
  56
  57         m_filesAccepted = 0;
  58         m_filesRejected = 0;
  59         m_filesDenied = 0;
  60         m_filesDummyCDDA = 0;
  61         m_filesCueSheet = 0;
  62 }
  63
  64 ////////////////////////////////////////////////////////////
  65 // Thread Main
  66 ////////////////////////////////////////////////////////////
  67
  68 void FileAnalyzer::run()
  69 {
  70         m_bSuccess = false;
  71         m_bAborted = false;
  72
  73         m_filesAccepted = 0;
  74         m_filesRejected = 0;
  75         m_filesDenied = 0;
  76         m_filesDummyCDDA = 0;
  77         m_filesCueSheet = 0;
  78
  79         m_inputFiles.sort();
  80         m_abortFlag = false;
  81
  82         while(!m_inputFiles.isEmpty())
  83         {
  84                 int fileType = fileTypeNormal;
  85                 QString currentFile = QDir::fromNativeSeparators(m_inputFiles.takeFirst());
  86                 qDebug64("Analyzing: %1", currentFile);
  87                 emit fileSelected(QFileInfo(currentFile).fileName());
  88                 AudioFileModel file = analyzeFile(currentFile, &fileType);
  89
  90                 if(m_abortFlag)
  91                 {
  92                         MessageBeep(MB_ICONERROR);
  93                         m_bAborted = true;
  94                         qWarning("Operation cancelled by user!");
  95                         return;
  96                 }
  97
  98                 if(fileType == fileTypeDenied)
  99                 {
 100                         m_filesDenied++;
 101                         qWarning("Cannot access file for reading, skipping!");
 102                         continue;
 103                 }
 104                 if(fileType == fileTypeCDDA)
 105                 {
 106                         m_filesDummyCDDA++;
 107                         qWarning("Dummy CDDA file detected, skipping!");
 108                         continue;
 109                 }
 110
 111                 if(file.fileName().isEmpty() || file.formatContainerType().isEmpty() || file.formatAudioType().isEmpty())
 112                 {
 113                         if(PlaylistImporter::importPlaylist(m_inputFiles, currentFile))
 114                         {
 115                                 qDebug("Imported playlist file.");
 116                         }
 117                         else if(!QFileInfo(currentFile).suffix().compare("cue", Qt::CaseInsensitive))
 118                         {
 119                                 qWarning("Cue Sheet file detected, skipping!");
 120                                 m_filesCueSheet++;
 121                         }
 122                         else if(!QFileInfo(currentFile).suffix().compare("avs", Qt::CaseInsensitive))
 123                         {
 124                                 qDebug("Found a potential Avisynth script, investigating...");
 125                                 if(analyzeAvisynthFile(currentFile, file))
 126                                 {
 127                                         m_filesAccepted++;
 128                                         emit fileAnalyzed(file);
 129                                 }
 130                                 else
 131                                 {
 132                                         qDebug64("Rejected Avisynth file: %1", file.filePath());
 133                                         m_filesRejected++;
 134                                 }
 135                         }
 136                         else
 137                         {
 138                                 qDebug64("Rejected file of unknown type: %1", file.filePath());
 139                                 m_filesRejected++;
 140                         }
 141                         continue;
 142                 }
 143
 144                 m_filesAccepted++;
 145                 emit fileAnalyzed(file);
 146         }
 147
 148         qDebug("All files added.\n");
 149         m_bSuccess = true;
 150 }
 151
 152 ////////////////////////////////////////////////////////////
 153 // Privtae Functions
 154 ////////////////////////////////////////////////////////////
 155
 156 const AudioFileModel FileAnalyzer::analyzeFile(const QString &filePath, int *type)
 157 {
 158         *type = fileTypeNormal;
 159
 160         AudioFileModel audioFile(filePath);
 161         m_currentSection = sectionOther;
 162         m_currentCover = coverNone;
 163
 164         QFile readTest(filePath);
 165         if(!readTest.open(QIODevice::ReadOnly))
 166         {
 167                 *type = fileTypeDenied;
 168                 return audioFile;
 169         }
 170
 171         if(checkFile_CDDA(readTest))
 172         {
 173                 *type = fileTypeCDDA;
 174                 return audioFile;
 175         }
 176
 177         readTest.close();
 178
 179         QProcess process;
 180         process.setProcessChannelMode(QProcess::MergedChannels);
 181         process.setReadChannel(QProcess::StandardOutput);
 182         process.start(m_mediaInfoBin, QStringList() << QDir::toNativeSeparators(filePath));
 183
 184         if(!process.waitForStarted())
 185         {
 186                 qWarning("MediaInfo process failed to create!");
 187                 qWarning("Error message: \"%s\"\n", process.errorString().toLatin1().constData());
 188                 process.kill();
 189                 process.waitForFinished(-1);
 190                 return audioFile;
 191         }
 192
 193         while(process.state() != QProcess::NotRunning)
 194         {
 195                 if(m_abortFlag)
 196                 {
 197                         process.kill();
 198                         qWarning("Process was aborted on user request!");
 199                         break;
 200                 }
 201
 202                 if(!process.waitForReadyRead())
 203                 {
 204                         if(process.state() == QProcess::Running)
 205                         {
 206                                 qWarning("MediaInfo time out. Killing process and skipping file!");
 207                                 process.kill();
 208                                 process.waitForFinished(-1);
 209                                 return audioFile;
 210                         }
 211                 }
 212
 213                 QByteArray data;
 214
 215                 while(process.canReadLine())
 216                 {
 217                         QString line = QString::fromUtf8(process.readLine().constData()).simplified();
 218                         if(!line.isEmpty())
 219                         {
 220                                 int index = line.indexOf(':');
 221                                 if(index > 0)
 222                                 {
 223                                         QString key = line.left(index-1).trimmed();
 224                                         QString val = line.mid(index+1).trimmed();
 225                                         if(!key.isEmpty() && !val.isEmpty())
 226                                         {
 227                                                 updateInfo(audioFile, key, val);
 228                                         }
 229                                 }
 230                                 else
 231                                 {
 232                                         updateSection(line);
 233                                 }
 234                         }
 235                 }
 236         }
 237
 238         if(audioFile.fileName().isEmpty())
 239         {
 240                 QString baseName = QFileInfo(filePath).fileName();
 241                 int index = baseName.lastIndexOf(".");
 242
 243                 if(index >= 0)
 244                 {
 245                         baseName = baseName.left(index);
 246                 }
 247
 248                 baseName = baseName.replace("_", " ").simplified();
 249                 index = baseName.lastIndexOf(" - ");
 250
 251                 if(index >= 0)
 252                 {
 253                         baseName = baseName.mid(index + 3).trimmed();
 254                 }
 255
 256                 audioFile.setFileName(baseName);
 257         }
 258
 259         process.waitForFinished();
 260         if(process.state() != QProcess::NotRunning)
 261         {
 262                 process.kill();
 263                 process.waitForFinished(-1);
 264         }
 265
 266         if(m_currentCover != coverNone)
 267         {
 268                 retrieveCover(audioFile, filePath);
 269         }
 270
 271         return audioFile;
 272 }
 273
 274 void FileAnalyzer::updateSection(const QString &section)
 275 {
 276         if(section.startsWith("General", Qt::CaseInsensitive))
 277         {
 278                 m_currentSection = sectionGeneral;
 279         }
 280         else if(!section.compare("Audio", Qt::CaseInsensitive) || section.startsWith("Audio #1", Qt::CaseInsensitive))
 281         {
 282                 m_currentSection = sectionAudio;
 283         }
 284         else if(section.startsWith("Audio", Qt::CaseInsensitive) || section.startsWith("Video", Qt::CaseInsensitive) || section.startsWith("Text", Qt::CaseInsensitive) ||
 285                 section.startsWith("Menu", Qt::CaseInsensitive) || section.startsWith("Image", Qt::CaseInsensitive) || section.startsWith("Chapters", Qt::CaseInsensitive))
 286         {
 287                 m_currentSection = sectionOther;
 288         }
 289         else
 290         {
 291                 m_currentSection = sectionOther;
 292                 qWarning("Unknown section: %s", section.toUtf8().constData());
 293         }
 294 }
 295
 296 void FileAnalyzer::updateInfo(AudioFileModel &audioFile, const QString &key, const QString &value)
 297 {
 298         switch(m_currentSection)
 299         {
 300         case sectionGeneral:
 301                 if(!key.compare("Title", Qt::CaseInsensitive) || !key.compare("Track", Qt::CaseInsensitive) || !key.compare("Track Name", Qt::CaseInsensitive))
 302                 {
 303                         if(audioFile.fileName().isEmpty()) audioFile.setFileName(value);
 304                 }
 305                 else if(!key.compare("Duration", Qt::CaseInsensitive))
 306                 {
 307                         if(!audioFile.fileDuration()) audioFile.setFileDuration(parseDuration(value));
 308                 }
 309                 else if(!key.compare("Artist", Qt::CaseInsensitive) || !key.compare("Performer", Qt::CaseInsensitive))
 310                 {
 311                         if(audioFile.fileArtist().isEmpty()) audioFile.setFileArtist(value);
 312                 }
 313                 else if(!key.compare("Album", Qt::CaseInsensitive))
 314                 {
 315                         if(audioFile.fileAlbum().isEmpty()) audioFile.setFileAlbum(value);
 316                 }
 317                 else if(!key.compare("Genre", Qt::CaseInsensitive))
 318                 {
 319                         if(audioFile.fileGenre().isEmpty()) audioFile.setFileGenre(value);
 320                 }
 321                 else if(!key.compare("Year", Qt::CaseInsensitive) || !key.compare("Recorded Date", Qt::CaseInsensitive) || !key.compare("Encoded Date", Qt::CaseInsensitive))
 322                 {
 323                         if(!audioFile.fileYear()) audioFile.setFileYear(parseYear(value));
 324                 }
 325                 else if(!key.compare("Comment", Qt::CaseInsensitive))
 326                 {
 327                         if(audioFile.fileComment().isEmpty()) audioFile.setFileComment(value);
 328                 }
 329                 else if(!key.compare("Track Name/Position", Qt::CaseInsensitive))
 330                 {
 331                         if(!audioFile.filePosition()) audioFile.setFilePosition(value.toInt());
 332                 }
 333                 else if(!key.compare("Format", Qt::CaseInsensitive))
 334                 {
 335                         if(audioFile.formatContainerType().isEmpty()) audioFile.setFormatContainerType(value);
 336                 }
 337                 else if(!key.compare("Format Profile", Qt::CaseInsensitive))
 338                 {
 339                         if(audioFile.formatContainerProfile().isEmpty()) audioFile.setFormatContainerProfile(value);
 340                 }
 341                 else if(!key.compare("Cover", Qt::CaseInsensitive) || !key.compare("Cover type", Qt::CaseInsensitive))
 342                 {
 343                         if(m_currentCover == coverNone) m_currentCover = coverJpeg;
 344                 }
 345                 else if(!key.compare("Cover MIME", Qt::CaseInsensitive))
 346                 {
 347                         QString temp = value.split(" ", QString::SkipEmptyParts, Qt::CaseInsensitive).first();
 348                         if(!temp.compare("image/jpeg", Qt::CaseInsensitive))
 349                         {
 350                                 m_currentCover = coverJpeg;
 351                         }
 352                         else if(!temp.compare("image/png", Qt::CaseInsensitive))
 353                         {
 354                                 m_currentCover = coverPng;
 355                         }
 356                         else if(!temp.compare("image/gif", Qt::CaseInsensitive))
 357                         {
 358                                 m_currentCover = coverGif;
 359                         }
 360                 }
 361                 break;
 362
 363         case sectionAudio:
 364                 if(!key.compare("Year", Qt::CaseInsensitive) || !key.compare("Recorded Date", Qt::CaseInsensitive) || !key.compare("Encoded Date", Qt::CaseInsensitive))
 365                 {
 366                         if(!audioFile.fileYear()) audioFile.setFileYear(parseYear(value));
 367                 }
 368                 else if(!key.compare("Format", Qt::CaseInsensitive))
 369                 {
 370                         if(audioFile.formatAudioType().isEmpty()) audioFile.setFormatAudioType(value);
 371                 }
 372                 else if(!key.compare("Format Profile", Qt::CaseInsensitive))
 373                 {
 374                         if(audioFile.formatAudioProfile().isEmpty()) audioFile.setFormatAudioProfile(value);
 375                 }
 376                 else if(!key.compare("Format Version", Qt::CaseInsensitive))
 377                 {
 378                         if(audioFile.formatAudioVersion().isEmpty()) audioFile.setFormatAudioVersion(value);
 379                 }
 380                 else if(!key.compare("Channel(s)", Qt::CaseInsensitive))
 381                 {
 382                         if(!audioFile.formatAudioChannels()) audioFile.setFormatAudioChannels(value.split(" ", QString::SkipEmptyParts).first().toUInt());
 383                 }
 384                 else if(!key.compare("Sampling rate", Qt::CaseInsensitive))
 385                 {
 386                         if(!audioFile.formatAudioSamplerate())
 387                         {
 388                                 bool ok = false;
 389                                 float fTemp = abs(value.split(" ", QString::SkipEmptyParts).first().toFloat(&ok));
 390                                 if(ok) audioFile.setFormatAudioSamplerate(static_cast<unsigned int>(floor(fTemp * 1000.0f + 0.5f)));
 391                         }
 392                 }
 393                 else if(!key.compare("Bit depth", Qt::CaseInsensitive))
 394                 {
 395                         if(!audioFile.formatAudioBitdepth()) audioFile.setFormatAudioBitdepth(value.split(" ", QString::SkipEmptyParts).first().toUInt());
 396                 }
 397                 else if(!key.compare("Duration", Qt::CaseInsensitive))
 398                 {
 399                         if(!audioFile.fileDuration()) audioFile.setFileDuration(parseDuration(value));
 400                 }
 401                 else if(!key.compare("Bit rate", Qt::CaseInsensitive))
 402                 {
 403                         if(!audioFile.formatAudioBitrate())
 404                         {
 405                                 bool ok = false;
 406                                 unsigned int uiTemp = value.split(" ", QString::SkipEmptyParts).first().toUInt(&ok);
 407                                 if(ok)
 408                                 {
 409                                         audioFile.setFormatAudioBitrate(uiTemp);
 410                                 }
 411                                 else
 412                                 {
 413                                         float fTemp = abs(value.split(" ", QString::SkipEmptyParts).first().toFloat(&ok));
 414                                         if(ok) audioFile.setFormatAudioBitrate(static_cast<unsigned int>(floor(fTemp + 0.5f)));
 415                                 }
 416                         }
 417                 }
 418                 else if(!key.compare("Bit rate mode", Qt::CaseInsensitive))
 419                 {
 420                         if(audioFile.formatAudioBitrateMode() == AudioFileModel::BitrateModeUndefined)
 421                         {
 422                                 if(!value.compare("Constant", Qt::CaseInsensitive)) audioFile.setFormatAudioBitrateMode(AudioFileModel::BitrateModeConstant);
 423                                 if(!value.compare("Variable", Qt::CaseInsensitive)) audioFile.setFormatAudioBitrateMode(AudioFileModel::BitrateModeVariable);
 424                         }
 425                 }
 426                 break;
 427         }
 428 }
 429
 430 unsigned int FileAnalyzer::parseYear(const QString &str)
 431 {
 432         if(str.startsWith("UTC", Qt::CaseInsensitive))
 433         {
 434                 QDate date = QDate::fromString(str.mid(3).trimmed().left(10), "yyyy-MM-dd");
 435                 if(date.isValid())
 436                 {
 437                         return date.year();
 438                 }
 439                 else
 440                 {
 441                         return 0;
 442                 }
 443         }
 444         else
 445         {
 446                 bool ok = false;
 447                 int year = str.toInt(&ok);
 448                 if(ok && year > 0)
 449                 {
 450                         return year;
 451                 }
 452                 else
 453                 {
 454                         return 0;
 455                 }
 456         }
 457 }
 458
 459 unsigned int FileAnalyzer::parseDuration(const QString &str)
 460 {
 461         QTime time;
 462
 463         time = QTime::fromString(str, "z'ms'");
 464         if(time.isValid())
 465         {
 466                 return max(1, (time.hour() * 60 * 60) + (time.minute() * 60) + time.second());
 467         }
 468
 469         time = QTime::fromString(str, "s's 'z'ms'");
 470         if(time.isValid())
 471         {
 472                 return max(1, (time.hour() * 60 * 60) + (time.minute() * 60) + time.second());
 473         }
 474
 475         time = QTime::fromString(str, "m'mn 's's'");
 476         if(time.isValid())
 477         {
 478                 return max(1, (time.hour() * 60 * 60) + (time.minute() * 60) + time.second());
 479         }
 480
 481         time = QTime::fromString(str, "h'h 'm'mn'");
 482         if(time.isValid())
 483         {
 484                 return max(1, (time.hour() * 60 * 60) + (time.minute() * 60) + time.second());
 485         }
 486
 487         return 0;
 488 }
 489
 490 bool FileAnalyzer::checkFile_CDDA(QFile &file)
 491 {
 492         file.reset();
 493         QByteArray data = file.read(128);
 494
 495         int i = data.indexOf("RIFF");
 496         int j = data.indexOf("CDDA");
 497         int k = data.indexOf("fmt ");
 498
 499         return ((i >= 0) && (j >= 0) && (k >= 0) && (k > j) && (j > i));
 500 }
 501
 502 void FileAnalyzer::retrieveCover(AudioFileModel &audioFile, const QString &filePath)
 503 {
 504         qDebug64("Retrieving cover from: %1", filePath);
 505         QString extension;
 506
 507         switch(m_currentCover)
 508         {
 509         case coverPng:
 510                 extension = QString::fromLatin1("png");
 511                 break;
 512         case coverGif:
 513                 extension = QString::fromLatin1("gif");
 514                 break;
 515         default:
 516                 extension = QString::fromLatin1("jpg");
 517                 break;
 518         }
 519
 520         QProcess process;
 521         process.setProcessChannelMode(QProcess::MergedChannels);
 522         process.setReadChannel(QProcess::StandardOutput);
 523         process.start(m_mediaInfoBin, QStringList() << "-f" << QDir::toNativeSeparators(filePath));
 524
 525         if(!process.waitForStarted())
 526         {
 527                 qWarning("MediaInfo process failed to create!");
 528                 qWarning("Error message: \"%s\"\n", process.errorString().toLatin1().constData());
 529                 process.kill();
 530                 process.waitForFinished(-1);
 531                 return;
 532         }
 533
 534         while(process.state() != QProcess::NotRunning)
 535         {
 536                 if(m_abortFlag)
 537                 {
 538                         process.kill();
 539                         qWarning("Process was aborted on user request!");
 540                         break;
 541                 }
 542
 543                 if(!process.waitForReadyRead())
 544                 {
 545                         if(process.state() == QProcess::Running)
 546                         {
 547                                 qWarning("MediaInfo time out. Killing process and skipping file!");
 548                                 process.kill();
 549                                 process.waitForFinished(-1);
 550                                 return;
 551                         }
 552                 }
 553
 554                 while(process.canReadLine())
 555                 {
 556                         QString line = QString::fromUtf8(process.readLine().constData()).simplified();
 557                         if(!line.isEmpty())
 558                         {
 559                                 int index = line.indexOf(':');
 560                                 if(index > 0)
 561                                 {
 562                                         QString key = line.left(index-1).trimmed();
 563                                         QString val = line.mid(index+1).trimmed();
 564                                         if(!key.isEmpty() && !val.isEmpty())
 565                                         {
 566                                                 if(!key.compare("Cover_Data", Qt::CaseInsensitive))
 567                                                 {
 568                                                         if(val.indexOf(" ") > 0)
 569                                                         {
 570                                                                 val = val.split(" ", QString::SkipEmptyParts, Qt::CaseInsensitive).first();
 571                                                         }
 572                                                         QByteArray coverData = QByteArray::fromBase64(val.toLatin1());
 573                                                         QFile coverFile(QString("%1/%2.%3").arg(lamexp_temp_folder2(), lamexp_rand_str(), extension));
 574                                                         if(coverFile.open(QIODevice::WriteOnly))
 575                                                         {
 576                                                                 coverFile.write(coverData);
 577                                                                 coverFile.close();
 578                                                                 audioFile.setFileCover(coverFile.fileName(), true);
 579                                                         }
 580                                                         break;
 581                                                 }
 582                                         }
 583                                 }
 584                         }
 585                 }
 586         }
 587
 588         process.waitForFinished();
 589         if(process.state() != QProcess::NotRunning)
 590         {
 591                 process.kill();
 592                 process.waitForFinished(-1);
 593         }
 594 }
 595
 596 bool FileAnalyzer::analyzeAvisynthFile(const QString &filePath, AudioFileModel &info)
 597 {
 598         QProcess process;
 599         process.setProcessChannelMode(QProcess::MergedChannels);
 600         process.setReadChannel(QProcess::StandardOutput);
 601         process.start(m_avs2wavBin, QStringList() << QDir::toNativeSeparators(filePath) << "?");
 602
 603         if(!process.waitForStarted())
 604         {
 605                 qWarning("AVS2WAV process failed to create!");
 606                 qWarning("Error message: \"%s\"\n", process.errorString().toLatin1().constData());
 607                 process.kill();
 608                 process.waitForFinished(-1);
 609                 return false;
 610         }
 611
 612         bool bInfoHeaderFound = false;
 613
 614         while(process.state() != QProcess::NotRunning)
 615         {
 616                 if(m_abortFlag)
 617                 {
 618                         process.kill();
 619                         qWarning("Process was aborted on user request!");
 620                         break;
 621                 }
 622
 623                 if(!process.waitForReadyRead())
 624                 {
 625                         if(process.state() == QProcess::Running)
 626                         {
 627                                 qWarning("AVS2WAV time out. Killing process and skipping file!");
 628                                 process.kill();
 629                                 process.waitForFinished(-1);
 630                                 return false;
 631                         }
 632                 }
 633
 634                 QByteArray data;
 635
 636                 while(process.canReadLine())
 637                 {
 638                         QString line = QString::fromUtf8(process.readLine().constData()).simplified();
 639                         if(!line.isEmpty())
 640                         {
 641                                 int index = line.indexOf(':');
 642                                 if(index > 0)
 643                                 {
 644                                         QString key = line.left(index).trimmed();
 645                                         QString val = line.mid(index+1).trimmed();
 646
 647                                         if(bInfoHeaderFound && !key.isEmpty() && !val.isEmpty())
 648                                         {
 649                                                 if(key.compare("TotalSeconds", Qt::CaseInsensitive) == 0)
 650                                                 {
 651                                                         bool ok = false;
 652                                                         unsigned int duration = val.toUInt(&ok);
 653                                                         if(ok) info.setFileDuration(duration);
 654                                                 }
 655                                                 if(key.compare("SamplesPerSec", Qt::CaseInsensitive) == 0)
 656                                                 {
 657                                                         bool ok = false;
 658                                                         unsigned int samplerate = val.toUInt(&ok);
 659                                                         if(ok) info.setFormatAudioSamplerate (samplerate);
 660                                                 }
 661                                                 if(key.compare("Channels", Qt::CaseInsensitive) == 0)
 662                                                 {
 663                                                         bool ok = false;
 664                                                         unsigned int channels = val.toUInt(&ok);
 665                                                         if(ok) info.setFormatAudioChannels(channels);
 666                                                 }
 667                                                 if(key.compare("BitsPerSample", Qt::CaseInsensitive) == 0)
 668                                                 {
 669                                                         bool ok = false;
 670                                                         unsigned int bitdepth = val.toUInt(&ok);
 671                                                         if(ok) info.setFormatAudioBitdepth(bitdepth);
 672                                                 }
 673                                         }
 674                                 }
 675                                 else
 676                                 {
 677                                         if(line.contains("[Audio Info]", Qt::CaseInsensitive))
 678                                         {
 679                                                 info.setFormatAudioType("Avisynth");
 680                                                 info.setFormatContainerType("Avisynth");
 681                                                 bInfoHeaderFound = true;
 682                                         }
 683                                 }
 684                         }
 685                 }
 686         }
 687
 688         process.waitForFinished();
 689         if(process.state() != QProcess::NotRunning)
 690         {
 691                 process.kill();
 692                 process.waitForFinished(-1);
 693         }
 694
 695         //Check exit code
 696         switch(process.exitCode())
 697         {
 698         case 0:
 699                 qDebug("Avisynth script was analyzed successfully.");
 700                 return true;
 701                 break;
 702         case -5:
 703                 qWarning("It appears that Avisynth is not installed on the system!");
 704                 return false;
 705                 break;
 706         default:
 707                 qWarning("Failed to open the Avisynth script, bad AVS file?");
 708                 return false;
 709                 break;
 710         }
 711 }
 712
 713 ////////////////////////////////////////////////////////////
 714 // Public Functions
 715 ////////////////////////////////////////////////////////////
 716
 717 unsigned int FileAnalyzer::filesAccepted(void)
 718 {
 719         return m_filesAccepted;
 720 }
 721
 722 unsigned int FileAnalyzer::filesRejected(void)
 723 {
 724         return m_filesRejected;
 725 }
 726
 727 unsigned int FileAnalyzer::filesDenied(void)
 728 {
 729         return m_filesDenied;
 730 }
 731
 732 unsigned int FileAnalyzer::filesDummyCDDA(void)
 733 {
 734         return m_filesDummyCDDA;
 735 }
 736
 737 unsigned int FileAnalyzer::filesCueSheet(void)
 738 {
 739         return m_filesCueSheet;
 740 }
 741
 742 ////////////////////////////////////////////////////////////
 743 // EVENTS
 744 ////////////////////////////////////////////////////////////
 745
 746 /*NONE*/