src/Dialog_Processing.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 "Dialog_Processing.h"
  23
  24 #include "Global.h"
  25 #include "Resource.h"
  26 #include "Model_FileList.h"
  27 #include "Model_Progress.h"
  28 #include "Model_Settings.h"
  29 #include "Thread_Process.h"
  30 #include "Thread_DiskObserver.h"
  31 #include "Dialog_LogView.h"
  32 #include "Encoder_MP3.h"
  33 #include "Encoder_Vorbis.h"
  34 #include "Encoder_AAC.h"
  35 #include "Encoder_AAC_FHG.h"
  36 #include "Encoder_AC3.h"
  37 #include "Encoder_FLAC.h"
  38 #include "Encoder_Wave.h"
  39 #include "Filter_Downmix.h"
  40 #include "Filter_Normalize.h"
  41 #include "Filter_Resample.h"
  42 #include "Filter_ToneAdjust.h"
  43 #include "WinSevenTaskbar.h"
  44
  45 #include <QApplication>
  46 #include <QRect>
  47 #include <QDesktopWidget>
  48 #include <QMovie>
  49 #include <QMessageBox>
  50 #include <QTimer>
  51 #include <QCloseEvent>
  52 #include <QDesktopServices>
  53 #include <QUrl>
  54 #include <QUuid>
  55 #include <QFileInfo>
  56 #include <QDir>
  57 #include <QMenu>
  58 #include <QSystemTrayIcon>
  59 #include <QProcess>
  60 #include <QProgressDialog>
  61
  62 #include <MMSystem.h>
  63
  64 ////////////////////////////////////////////////////////////
  65
  66 //Maximum number of parallel instances
  67 #define MAX_INSTANCES 16
  68
  69 //Maximum number of CPU cores for auto-detection
  70 #define MAX_CPU_COUNT 4
  71
  72 ////////////////////////////////////////////////////////////
  73
  74 #define CHANGE_BACKGROUND_COLOR(WIDGET, COLOR) \
  75 { \
  76         QPalette palette = WIDGET->palette(); \
  77         palette.setColor(QPalette::Background, COLOR); \
  78         WIDGET->setPalette(palette); \
  79 }
  80
  81 #define SET_PROGRESS_TEXT(TXT) \
  82 { \
  83         label_progress->setText(TXT); \
  84         m_systemTray->setToolTip(QString().sprintf("LameXP v%d.%02d\n%ls", lamexp_version_major(), lamexp_version_minor(), QString(TXT).utf16())); \
  85 }
  86
  87 #define SET_FONT_BOLD(WIDGET,BOLD) { QFont _font = WIDGET->font(); _font.setBold(BOLD); WIDGET->setFont(_font); }
  88
  89 ////////////////////////////////////////////////////////////
  90 // Constructor
  91 ////////////////////////////////////////////////////////////
  92
  93 ProcessingDialog::ProcessingDialog(FileListModel *fileListModel, AudioFileModel *metaInfo, SettingsModel *settings, QWidget *parent)
  94 :
  95         QDialog(parent),
  96         m_systemTray(new QSystemTrayIcon(QIcon(":/icons/cd_go.png"), this)),
  97         m_settings(settings),
  98         m_metaInfo(metaInfo),
  99         m_shutdownFlag(false),
 100         m_diskObserver(NULL)
 101 {
 102         //Init the dialog, from the .ui file
 103         setupUi(this);
 104         setWindowFlags(windowFlags() ^ Qt::WindowContextHelpButtonHint);
 105
 106         //Setup version info
 107         label_versionInfo->setText(QString().sprintf("v%d.%02d %s (Build %d)", lamexp_version_major(), lamexp_version_minor(), lamexp_version_release(), lamexp_version_build()));
 108         label_versionInfo->installEventFilter(this);
 109
 110         //Register meta type
 111         qRegisterMetaType<QUuid>("QUuid");
 112
 113         //Center window in screen
 114         QRect desktopRect = QApplication::desktop()->screenGeometry();
 115         QRect thisRect = this->geometry();
 116         move((desktopRect.width() - thisRect.width()) / 2, (desktopRect.height() - thisRect.height()) / 2);
 117         setMinimumSize(thisRect.width(), thisRect.height());
 118
 119         //Enable buttons
 120         connect(button_AbortProcess, SIGNAL(clicked()), this, SLOT(abortEncoding()));
 121
 122         //Init progress indicator
 123         m_progressIndicator = new QMovie(":/images/Working.gif");
 124         label_headerWorking->setMovie(m_progressIndicator);
 125         progressBar->setValue(0);
 126
 127         //Init progress model
 128         m_progressModel = new ProgressModel();
 129         view_log->setModel(m_progressModel);
 130         view_log->verticalHeader()->setResizeMode(QHeaderView::ResizeToContents);
 131         view_log->verticalHeader()->hide();
 132         view_log->horizontalHeader()->setResizeMode(QHeaderView::ResizeToContents);
 133         view_log->horizontalHeader()->setResizeMode(0, QHeaderView::Stretch);
 134         view_log->viewport()->installEventFilter(this);
 135         connect(m_progressModel, SIGNAL(rowsInserted(QModelIndex,int,int)), this, SLOT(progressModelChanged()));
 136         connect(m_progressModel, SIGNAL(modelReset()), this, SLOT(progressModelChanged()));
 137         connect(view_log, SIGNAL(activated(QModelIndex)), this, SLOT(logViewDoubleClicked(QModelIndex)));
 138         connect(view_log->horizontalHeader(), SIGNAL(sectionResized(int,int,int)), this, SLOT(logViewSectionSizeChanged(int,int,int)));
 139
 140         //Create context menu
 141         m_contextMenu = new QMenu();
 142         QAction *contextMenuDetailsAction = m_contextMenu->addAction(QIcon(":/icons/zoom.png"), tr("Show details for selected job"));
 143         QAction *contextMenuShowFileAction = m_contextMenu->addAction(QIcon(":/icons/folder_go.png"), tr("Browse Output File Location"));
 144
 145         view_log->setContextMenuPolicy(Qt::CustomContextMenu);
 146         connect(view_log, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(contextMenuTriggered(QPoint)));
 147         connect(contextMenuDetailsAction, SIGNAL(triggered(bool)), this, SLOT(contextMenuDetailsActionTriggered()));
 148         connect(contextMenuShowFileAction, SIGNAL(triggered(bool)), this, SLOT(contextMenuShowFileActionTriggered()));
 149         SET_FONT_BOLD(contextMenuDetailsAction, true);
 150
 151         //Enque jobs
 152         if(fileListModel)
 153         {
 154                 for(int i = 0; i < fileListModel->rowCount(); i++)
 155                 {
 156                         m_pendingJobs.append(fileListModel->getFile(fileListModel->index(i,0)));
 157                 }
 158         }
 159
 160         //Translate
 161         label_headerStatus->setText(QString("<b>%1</b><br>%2").arg(tr("Encoding Files"), tr("Your files are being encoded, please be patient...")));
 162
 163         //Enable system tray icon
 164         connect(m_systemTray, SIGNAL(activated(QSystemTrayIcon::ActivationReason)), this, SLOT(systemTrayActivated(QSystemTrayIcon::ActivationReason)));
 165
 166         //Init other vars
 167         m_runningThreads = 0;
 168         m_currentFile = 0;
 169         m_allJobs.clear();
 170         m_succeededJobs.clear();
 171         m_failedJobs.clear();
 172         m_userAborted = false;
 173 }
 174
 175 ////////////////////////////////////////////////////////////
 176 // Destructor
 177 ////////////////////////////////////////////////////////////
 178
 179 ProcessingDialog::~ProcessingDialog(void)
 180 {
 181         view_log->setModel(NULL);
 182
 183         if(m_progressIndicator)
 184         {
 185                 m_progressIndicator->stop();
 186         }
 187
 188         if(m_diskObserver)
 189         {
 190                 m_diskObserver->stop();
 191                 m_diskObserver->wait(15000);
 192         }
 193
 194         LAMEXP_DELETE(m_progressIndicator);
 195         LAMEXP_DELETE(m_progressModel);
 196         LAMEXP_DELETE(m_contextMenu);
 197         LAMEXP_DELETE(m_systemTray);
 198         LAMEXP_DELETE(m_diskObserver);
 199
 200         WinSevenTaskbar::setOverlayIcon(this, NULL);
 201         WinSevenTaskbar::setTaskbarState(this, WinSevenTaskbar::WinSevenTaskbarNoState);
 202
 203         while(!m_threadList.isEmpty())
 204         {
 205                 ProcessThread *thread = m_threadList.takeFirst();
 206                 thread->terminate();
 207                 thread->wait(15000);
 208                 delete thread;
 209         }
 210 }
 211
 212 ////////////////////////////////////////////////////////////
 213 // EVENTS
 214 ////////////////////////////////////////////////////////////
 215
 216 void ProcessingDialog::showEvent(QShowEvent *event)
 217 {
 218         setCloseButtonEnabled(false);
 219         button_closeDialog->setEnabled(false);
 220         button_AbortProcess->setEnabled(false);
 221         m_systemTray->setVisible(true);
 222
 223         if(!SetPriorityClass(GetCurrentProcess(), ABOVE_NORMAL_PRIORITY_CLASS))
 224         {
 225                 SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
 226         }
 227
 228         QTimer::singleShot(1000, this, SLOT(initEncoding()));
 229 }
 230
 231 void ProcessingDialog::closeEvent(QCloseEvent *event)
 232 {
 233         if(!button_closeDialog->isEnabled())
 234         {
 235                 event->ignore();
 236         }
 237         else
 238         {
 239                 m_systemTray->setVisible(false);
 240         }
 241 }
 242
 243 bool ProcessingDialog::eventFilter(QObject *obj, QEvent *event)
 244 {
 245         static QColor defaultColor = QColor();
 246
 247         if(obj == label_versionInfo)
 248         {
 249                 if(event->type() == QEvent::Enter)
 250                 {
 251                         QPalette palette = label_versionInfo->palette();
 252                         defaultColor = palette.color(QPalette::Normal, QPalette::WindowText);
 253                         palette.setColor(QPalette::Normal, QPalette::WindowText, Qt::red);
 254                         label_versionInfo->setPalette(palette);
 255                 }
 256                 else if(event->type() == QEvent::Leave)
 257                 {
 258                         QPalette palette = label_versionInfo->palette();
 259                         palette.setColor(QPalette::Normal, QPalette::WindowText, defaultColor);
 260                         label_versionInfo->setPalette(palette);
 261                 }
 262                 else if(event->type() == QEvent::MouseButtonPress)
 263                 {
 264                         QUrl url(lamexp_website_url());
 265                         QDesktopServices::openUrl(url);
 266                 }
 267         }
 268
 269         return false;
 270 }
 271
 272 ////////////////////////////////////////////////////////////
 273 // SLOTS
 274 ////////////////////////////////////////////////////////////
 275
 276 void ProcessingDialog::initEncoding(void)
 277 {
 278         m_runningThreads = 0;
 279         m_currentFile = 0;
 280         m_allJobs.clear();
 281         m_succeededJobs.clear();
 282         m_failedJobs.clear();
 283         m_userAborted = false;
 284         m_playList.clear();
 285
 286         CHANGE_BACKGROUND_COLOR(frame_header, QColor(Qt::white));
 287         SET_PROGRESS_TEXT(tr("Encoding files, please wait..."));
 288         m_progressIndicator->start();
 289
 290         button_closeDialog->setEnabled(false);
 291         button_AbortProcess->setEnabled(true);
 292         progressBar->setRange(0, m_pendingJobs.count());
 293         checkBox_shutdownComputer->setEnabled(true);
 294         checkBox_shutdownComputer->setChecked(false);
 295
 296         WinSevenTaskbar::initTaskbar();
 297         WinSevenTaskbar::setTaskbarState(this, WinSevenTaskbar::WinSevenTaskbarNormalState);
 298         WinSevenTaskbar::setTaskbarProgress(this, 0, m_pendingJobs.count());
 299         WinSevenTaskbar::setOverlayIcon(this, &QIcon(":/icons/control_play_blue.png"));
 300
 301         if(!m_diskObserver)
 302         {
 303                 m_diskObserver = new DiskObserverThread(m_settings->customTempPathEnabled() ? m_settings->customTempPath() : lamexp_temp_folder2());
 304                 connect(m_diskObserver, SIGNAL(messageLogged(QString,bool)), m_progressModel, SLOT(addSystemMessage(QString,bool)), Qt::QueuedConnection);
 305                 m_diskObserver->start();
 306         }
 307
 308         int maximumInstances = max(min(m_settings->maximumInstances(), MAX_INSTANCES), 0);
 309         if(maximumInstances < 1)
 310         {
 311                 lamexp_cpu_t cpuFeatures = lamexp_detect_cpu_features();
 312                 maximumInstances = max(min(cpuFeatures.count, MAX_CPU_COUNT), 1);
 313         }
 314
 315         int parallelThreadCount = max(min(maximumInstances, m_pendingJobs.count()), 1);
 316         if(parallelThreadCount > 1)
 317         {
 318                 m_progressModel->addSystemMessage(tr("Multi-threading enabled: Running %1 instances in parallel!").arg(QString::number(parallelThreadCount)));
 319         }
 320
 321         for(int i = 0; i < parallelThreadCount; i++)
 322         {
 323                 startNextJob();
 324         }
 325 }
 326
 327 void ProcessingDialog::abortEncoding(void)
 328 {
 329         m_userAborted = true;
 330         button_AbortProcess->setEnabled(false);
 331
 332         SET_PROGRESS_TEXT(tr("Aborted! Waiting for running jobs to terminate..."));
 333
 334         for(int i = 0; i < m_threadList.count(); i++)
 335         {
 336                 m_threadList.at(i)->abort();
 337         }
 338 }
 339
 340 void ProcessingDialog::doneEncoding(void)
 341 {
 342         m_runningThreads--;
 343         progressBar->setValue(progressBar->value() + 1);
 344
 345         if(!m_userAborted)
 346         {
 347                 SET_PROGRESS_TEXT(tr("Encoding: %1 files of %2 completed so far, please wait...").arg(QString::number(progressBar->value()), QString::number(progressBar->maximum())));
 348                 WinSevenTaskbar::setTaskbarProgress(this, progressBar->value(), progressBar->maximum());
 349         }
 350
 351         int index = m_threadList.indexOf(dynamic_cast<ProcessThread*>(QWidget::sender()));
 352         if(index >= 0)
 353         {
 354                 m_threadList.takeAt(index)->deleteLater();
 355         }
 356
 357         if(!m_pendingJobs.isEmpty() && !m_userAborted)
 358         {
 359                 startNextJob();
 360                 qDebug("Running jobs: %u", m_runningThreads);
 361                 return;
 362         }
 363
 364         if(m_runningThreads > 0)
 365         {
 366                 qDebug("Running jobs: %u", m_runningThreads);
 367                 return;
 368         }
 369
 370         QApplication::setOverrideCursor(Qt::WaitCursor);
 371         qDebug("Running jobs: %u", m_runningThreads);
 372
 373         if(!m_userAborted && m_settings->createPlaylist() && !m_settings->outputToSourceDir())
 374         {
 375                 SET_PROGRESS_TEXT(tr("Creating the playlist file, please wait..."));
 376                 QApplication::processEvents();
 377                 writePlayList();
 378         }
 379
 380         if(m_userAborted)
 381         {
 382                 CHANGE_BACKGROUND_COLOR(frame_header, QColor("#FFF3BA"));
 383                 WinSevenTaskbar::setTaskbarState(this, WinSevenTaskbar::WinSevenTaskbarErrorState);
 384                 WinSevenTaskbar::setOverlayIcon(this, &QIcon(":/icons/error.png"));
 385                 SET_PROGRESS_TEXT((m_succeededJobs.count() > 0) ? tr("Process was aborted by the user after %1 file(s)!").arg(QString::number(m_succeededJobs.count())) : tr("Process was aborted prematurely by the user!"));
 386                 m_systemTray->showMessage(tr("LameXP - Aborted"), tr("Process was aborted by the user."), QSystemTrayIcon::Warning);
 387                 m_systemTray->setIcon(QIcon(":/icons/cd_delete.png"));
 388                 QApplication::processEvents();
 389                 if(m_settings->soundsEnabled()) PlaySound(MAKEINTRESOURCE(IDR_WAVE_ABORTED), GetModuleHandle(NULL), SND_RESOURCE | SND_SYNC);
 390         }
 391         else
 392         {
 393                 if(m_failedJobs.count() > 0)
 394                 {
 395                         CHANGE_BACKGROUND_COLOR(frame_header, QColor("#FFBABA"));
 396                         WinSevenTaskbar::setTaskbarState(this, WinSevenTaskbar::WinSevenTaskbarErrorState);
 397                         WinSevenTaskbar::setOverlayIcon(this, &QIcon(":/icons/exclamation.png"));
 398                         SET_PROGRESS_TEXT(tr("Error: %1 of %2 files failed. Double-click failed items for detailed information!").arg(QString::number(m_failedJobs.count()), QString::number(m_failedJobs.count() + m_succeededJobs.count())));
 399                         m_systemTray->showMessage(tr("LameXP - Error"), tr("At least one file has failed!"), QSystemTrayIcon::Critical);
 400                         m_systemTray->setIcon(QIcon(":/icons/cd_delete.png"));
 401                         QApplication::processEvents();
 402                         if(m_settings->soundsEnabled()) PlaySound(MAKEINTRESOURCE(IDR_WAVE_ERROR), GetModuleHandle(NULL), SND_RESOURCE | SND_SYNC);
 403                 }
 404                 else
 405                 {
 406                         CHANGE_BACKGROUND_COLOR(frame_header, QColor("#E0FFE2"));
 407                         WinSevenTaskbar::setTaskbarState(this, WinSevenTaskbar::WinSevenTaskbarNormalState);
 408                         WinSevenTaskbar::setOverlayIcon(this, &QIcon(":/icons/accept.png"));
 409                         SET_PROGRESS_TEXT(tr("All files completed successfully."));
 410                         m_systemTray->showMessage(tr("LameXP - Done"), tr("All files completed successfully."), QSystemTrayIcon::Information);
 411                         m_systemTray->setIcon(QIcon(":/icons/cd_add.png"));
 412                         QApplication::processEvents();
 413                         if(m_settings->soundsEnabled()) PlaySound(MAKEINTRESOURCE(IDR_WAVE_SUCCESS), GetModuleHandle(NULL), SND_RESOURCE | SND_SYNC);
 414                 }
 415         }
 416
 417         setCloseButtonEnabled(true);
 418         button_closeDialog->setEnabled(true);
 419         button_AbortProcess->setEnabled(false);
 420         checkBox_shutdownComputer->setEnabled(false);
 421
 422         m_progressModel->restoreHiddenItems();
 423         view_log->scrollToBottom();
 424         m_progressIndicator->stop();
 425         progressBar->setValue(progressBar->maximum());
 426         WinSevenTaskbar::setTaskbarProgress(this, progressBar->value(), progressBar->maximum());
 427
 428         QApplication::restoreOverrideCursor();
 429
 430         if(!m_userAborted && checkBox_shutdownComputer->isChecked())
 431         {
 432                 if(shutdownComputer())
 433                 {
 434                         m_shutdownFlag = true;
 435                         accept();
 436                 }
 437         }
 438 }
 439
 440 void ProcessingDialog::processFinished(const QUuid &jobId, const QString &outFileName, bool success)
 441 {
 442         if(success)
 443         {
 444                 m_playList.insert(jobId, outFileName);
 445                 m_succeededJobs.append(jobId);
 446         }
 447         else
 448         {
 449                 m_failedJobs.append(jobId);
 450         }
 451 }
 452
 453 void ProcessingDialog::progressModelChanged(void)
 454 {
 455         view_log->scrollToBottom();
 456 }
 457
 458 void ProcessingDialog::logViewDoubleClicked(const QModelIndex &index)
 459 {
 460         if(m_runningThreads == 0)
 461         {
 462                 const QStringList &logFile = m_progressModel->getLogFile(index);
 463
 464                 if(!logFile.isEmpty())
 465                 {
 466                         LogViewDialog *logView = new LogViewDialog(this);
 467                         logView->setWindowTitle(QString("LameXP - [%1]").arg(m_progressModel->data(index, Qt::DisplayRole).toString()));
 468                         logView->exec(logFile);
 469                         LAMEXP_DELETE(logView);
 470                 }
 471                 else
 472                 {
 473                         MessageBeep(MB_ICONWARNING);
 474                 }
 475         }
 476         else
 477         {
 478                 MessageBeep(MB_ICONWARNING);
 479         }
 480 }
 481
 482 void ProcessingDialog::logViewSectionSizeChanged(int logicalIndex, int oldSize, int newSize)
 483 {
 484         if(logicalIndex == 1)
 485         {
 486                 if(QHeaderView *hdr = view_log->horizontalHeader())
 487                 {
 488                         hdr->setMinimumSectionSize(max(hdr->minimumSectionSize(), hdr->sectionSize(1)));
 489                 }
 490         }
 491 }
 492
 493 void ProcessingDialog::contextMenuTriggered(const QPoint &pos)
 494 {
 495         QAbstractScrollArea *scrollArea = dynamic_cast<QAbstractScrollArea*>(QObject::sender());
 496         QWidget *sender = scrollArea ? scrollArea->viewport() : dynamic_cast<QWidget*>(QObject::sender());
 497
 498         if(pos.x() <= sender->width() && pos.y() <= sender->height() && pos.x() >= 0 && pos.y() >= 0)
 499         {
 500                 m_contextMenu->popup(sender->mapToGlobal(pos));
 501         }
 502 }
 503
 504 void ProcessingDialog::contextMenuDetailsActionTriggered(void)
 505 {
 506         QModelIndex index = view_log->indexAt(view_log->mapFromGlobal(m_contextMenu->pos()));
 507         logViewDoubleClicked(index.isValid() ? index : view_log->currentIndex());
 508 }
 509
 510 void ProcessingDialog::contextMenuShowFileActionTriggered(void)
 511 {
 512         QModelIndex index = view_log->indexAt(view_log->mapFromGlobal(m_contextMenu->pos()));
 513         const QUuid &jobId = m_progressModel->getJobId(index.isValid() ? index : view_log->currentIndex());
 514         QString filePath = m_playList.value(jobId, QString());
 515
 516         if(filePath.isEmpty())
 517         {
 518                 MessageBeep(MB_ICONWARNING);
 519                 return;
 520         }
 521
 522         if(QFileInfo(filePath).exists())
 523         {
 524                 QString systemRootPath;
 525
 526                 QDir systemRoot(lamexp_known_folder(lamexp_folder_systemfolder));
 527                 if(systemRoot.exists() && systemRoot.cdUp())
 528                 {
 529                         systemRootPath = systemRoot.canonicalPath();
 530                 }
 531
 532                 if(!systemRootPath.isEmpty())
 533                 {
 534                         QFileInfo explorer(QString("%1/explorer.exe").arg(systemRootPath));
 535                         if(explorer.exists() && explorer.isFile())
 536                         {
 537                                 QProcess::execute(explorer.canonicalFilePath(), QStringList() << "/select," << QDir::toNativeSeparators(QFileInfo(filePath).canonicalFilePath()));
 538                                 return;
 539                         }
 540                 }
 541                 else
 542                 {
 543                         qWarning("SystemRoot directory could not be detected!");
 544                 }
 545         }
 546         else
 547         {
 548                 qWarning("File not found: %s", filePath.toLatin1().constData());
 549                 MessageBeep(MB_ICONERROR);
 550         }
 551 }
 552
 553 ////////////////////////////////////////////////////////////
 554 // Private Functions
 555 ////////////////////////////////////////////////////////////
 556
 557 void ProcessingDialog::startNextJob(void)
 558 {
 559         if(m_pendingJobs.isEmpty())
 560         {
 561                 return;
 562         }
 563
 564         m_currentFile++;
 565         AudioFileModel currentFile = updateMetaInfo(m_pendingJobs.takeFirst());
 566         AbstractEncoder *encoder = NULL;
 567         bool nativeResampling = false;
 568
 569         //Create encoder instance
 570         switch(m_settings->compressionEncoder())
 571         {
 572         case SettingsModel::MP3Encoder:
 573                 {
 574                         MP3Encoder *mp3Encoder = new MP3Encoder();
 575                         mp3Encoder->setBitrate(m_settings->compressionBitrate());
 576                         mp3Encoder->setRCMode(m_settings->compressionRCMode());
 577                         mp3Encoder->setAlgoQuality(m_settings->lameAlgoQuality());
 578                         if(m_settings->bitrateManagementEnabled())
 579                         {
 580                                 mp3Encoder->setBitrateLimits(m_settings->bitrateManagementMinRate(), m_settings->bitrateManagementMaxRate());
 581                         }
 582                         if(m_settings->samplingRate() > 0)
 583                         {
 584                                 mp3Encoder->setSamplingRate(SettingsModel::samplingRates[m_settings->samplingRate()]);
 585                                 nativeResampling = true;
 586                         }
 587                         mp3Encoder->setChannelMode(m_settings->lameChannelMode());
 588                         mp3Encoder->setCustomParams(m_settings->customParametersLAME());
 589                         encoder = mp3Encoder;
 590                 }
 591                 break;
 592         case SettingsModel::VorbisEncoder:
 593                 {
 594                         VorbisEncoder *vorbisEncoder = new VorbisEncoder();
 595                         vorbisEncoder->setBitrate(m_settings->compressionBitrate());
 596                         vorbisEncoder->setRCMode(m_settings->compressionRCMode());
 597                         if(m_settings->bitrateManagementEnabled())
 598                         {
 599                                 vorbisEncoder->setBitrateLimits(m_settings->bitrateManagementMinRate(), m_settings->bitrateManagementMaxRate());
 600                         }
 601                         if(m_settings->samplingRate() > 0)
 602                         {
 603                                 vorbisEncoder->setSamplingRate(SettingsModel::samplingRates[m_settings->samplingRate()]);
 604                                 nativeResampling = true;
 605                         }
 606                         vorbisEncoder->setCustomParams(m_settings->customParametersOggEnc());
 607                         encoder = vorbisEncoder;
 608                 }
 609                 break;
 610         case SettingsModel::AACEncoder:
 611                 {
 612                         if(lamexp_check_tool("fhgaacenc.exe") && lamexp_check_tool("enc_fhgaac.dll"))
 613                         {
 614                                 FHGAACEncoder *aacEncoder = new FHGAACEncoder();
 615                                 aacEncoder->setBitrate(m_settings->compressionBitrate());
 616                                 aacEncoder->setRCMode(m_settings->compressionRCMode());
 617                                 aacEncoder->setProfile(m_settings->aacEncProfile());
 618                                 aacEncoder->setCustomParams(m_settings->customParametersAacEnc());
 619                                 encoder = aacEncoder;
 620                         }
 621                         else
 622                         {
 623                                 AACEncoder *aacEncoder = new AACEncoder();
 624                                 aacEncoder->setBitrate(m_settings->compressionBitrate());
 625                                 aacEncoder->setRCMode(m_settings->compressionRCMode());
 626                                 aacEncoder->setEnable2Pass(m_settings->neroAACEnable2Pass());
 627                                 aacEncoder->setProfile(m_settings->aacEncProfile());
 628                                 aacEncoder->setCustomParams(m_settings->customParametersAacEnc());
 629                                 encoder = aacEncoder;
 630                         }
 631                 }
 632                 break;
 633         case SettingsModel::AC3Encoder:
 634                 {
 635                         AC3Encoder *ac3Encoder = new AC3Encoder();
 636                         ac3Encoder->setBitrate(m_settings->compressionBitrate());
 637                         ac3Encoder->setRCMode(m_settings->compressionRCMode());
 638                         ac3Encoder->setCustomParams(m_settings->customParametersAften());
 639                         ac3Encoder->setAudioCodingMode(m_settings->aftenAudioCodingMode());
 640                         ac3Encoder->setDynamicRangeCompression(m_settings->aftenDynamicRangeCompression());
 641                         ac3Encoder->setExponentSearchSize(m_settings->aftenExponentSearchSize());
 642                         ac3Encoder->setFastBitAllocation(m_settings->aftenFastBitAllocation());
 643                         encoder = ac3Encoder;
 644                 }
 645                 break;
 646         case SettingsModel::FLACEncoder:
 647                 {
 648                         FLACEncoder *flacEncoder = new FLACEncoder();
 649                         flacEncoder->setBitrate(m_settings->compressionBitrate());
 650                         flacEncoder->setRCMode(m_settings->compressionRCMode());
 651                         flacEncoder->setCustomParams(m_settings->customParametersFLAC());
 652                         encoder = flacEncoder;
 653                 }
 654                 break;
 655         case SettingsModel::PCMEncoder:
 656                 {
 657                         WaveEncoder *waveEncoder = new WaveEncoder();
 658                         waveEncoder->setBitrate(m_settings->compressionBitrate());
 659                         waveEncoder->setRCMode(m_settings->compressionRCMode());
 660                         encoder = waveEncoder;
 661                 }
 662                 break;
 663         default:
 664                 throw "Unsupported encoder!";
 665         }
 666
 667         //Create processing thread
 668         ProcessThread *thread = new ProcessThread
 669         (
 670                 currentFile,
 671                 (m_settings->outputToSourceDir() ? QFileInfo(currentFile.filePath()).absolutePath() : m_settings->outputDir()),
 672                 (m_settings->customTempPathEnabled() ? m_settings->customTempPath() : lamexp_temp_folder2()),
 673                 encoder,
 674                 m_settings->prependRelativeSourcePath()
 675         );
 676
 677         //Add audio filters
 678         if(m_settings->forceStereoDownmix())
 679         {
 680                 thread->addFilter(new DownmixFilter());
 681         }
 682         if((m_settings->samplingRate() > 0) && !nativeResampling)
 683         {
 684                 if(SettingsModel::samplingRates[m_settings->samplingRate()] != currentFile.formatAudioSamplerate() || currentFile.formatAudioSamplerate() == 0)
 685                 {
 686                         thread->addFilter(new ResampleFilter(SettingsModel::samplingRates[m_settings->samplingRate()]));
 687                 }
 688         }
 689         if((m_settings->toneAdjustBass() != 0) || (m_settings->toneAdjustTreble() != 0))
 690         {
 691                 thread->addFilter(new ToneAdjustFilter(m_settings->toneAdjustBass(), m_settings->toneAdjustTreble()));
 692         }
 693         if(m_settings->normalizationFilterEnabled())
 694         {
 695                 thread->addFilter(new NormalizeFilter(m_settings->normalizationFilterMaxVolume()));
 696         }
 697         if(m_settings->renameOutputFilesEnabled() && (!m_settings->renameOutputFilesPattern().simplified().isEmpty()))
 698         {
 699                 thread->setRenamePattern(m_settings->renameOutputFilesPattern());
 700         }
 701
 702         m_threadList.append(thread);
 703         m_allJobs.append(thread->getId());
 704
 705         //Connect thread signals
 706         connect(thread, SIGNAL(finished()), this, SLOT(doneEncoding()), Qt::QueuedConnection);
 707         connect(thread, SIGNAL(processStateInitialized(QUuid,QString,QString,int)), m_progressModel, SLOT(addJob(QUuid,QString,QString,int)), Qt::QueuedConnection);
 708         connect(thread, SIGNAL(processStateChanged(QUuid,QString,int)), m_progressModel, SLOT(updateJob(QUuid,QString,int)), Qt::QueuedConnection);
 709         connect(thread, SIGNAL(processStateFinished(QUuid,QString,bool)), this, SLOT(processFinished(QUuid,QString,bool)), Qt::QueuedConnection);
 710         connect(thread, SIGNAL(processMessageLogged(QUuid,QString)), m_progressModel, SLOT(appendToLog(QUuid,QString)), Qt::QueuedConnection);
 711
 712         //Give it a go!
 713         m_runningThreads++;
 714         thread->start();
 715 }
 716
 717 void ProcessingDialog::writePlayList(void)
 718 {
 719         if(m_succeededJobs.count() <= 0 || m_allJobs.count() <= 0)
 720         {
 721                 qWarning("WritePlayList: Nothing to do!");
 722                 return;
 723         }
 724
 725         //Init local variables
 726         const static char *invalidChars = "\\/:*?\"<>|";
 727         QStringList list;
 728         bool useUtf8 = false;
 729         int counter = 1;
 730
 731         //Generate playlist name
 732         QString playListName = (m_metaInfo->fileAlbum().isEmpty() ? "Playlist" : m_metaInfo->fileAlbum());
 733         if(!m_metaInfo->fileArtist().isEmpty())
 734         {
 735                 playListName = QString("%1 - %2").arg(m_metaInfo->fileArtist(), playListName);
 736         }
 737
 738         //Clean playlist name
 739         for(int i = 0; invalidChars[i]; i++)
 740         {
 741                 playListName = playListName.replace(invalidChars[i], ' ').simplified();
 742         }
 743
 744         //Create list of audio files
 745         for(int i = 0; i < m_allJobs.count(); i++)
 746         {
 747                 if(!m_succeededJobs.contains(m_allJobs.at(i))) continue;
 748                 list << QDir::toNativeSeparators(QDir(m_settings->outputDir()).relativeFilePath(m_playList.value(m_allJobs.at(i), "N/A")));
 749         }
 750
 751         //Do we need an UTF-8 playlist?
 752         for(int i = 0; i < list.count(); i++)
 753         {
 754                 if(wcscmp(QWCHAR(QString::fromLatin1(list.at(i).toLatin1().constData())), QWCHAR(list.at(i))))
 755                 {
 756                         useUtf8 = true;
 757                         break;
 758                 }
 759         }
 760
 761         //Generate playlist output file
 762         QString playListFile = QString("%1/%2.%3").arg(m_settings->outputDir(), playListName, (useUtf8 ? "m3u8" : "m3u"));
 763         while(QFileInfo(playListFile).exists())
 764         {
 765                 playListFile = QString("%1/%2 (%3).%4").arg(m_settings->outputDir(), playListName, QString::number(++counter), (useUtf8 ? "m3u8" : "m3u"));
 766         }
 767
 768         //Now write playlist to output file
 769         QFile playList(playListFile);
 770         if(playList.open(QIODevice::WriteOnly))
 771         {
 772                 if(useUtf8)
 773                 {
 774                         playList.write("\xef\xbb\xbf");
 775                 }
 776                 playList.write("#EXTM3U\r\n");
 777                 while(!list.isEmpty())
 778                 {
 779                         playList.write(useUtf8 ? list.takeFirst().toUtf8().constData() : list.takeFirst().toLatin1().constData());
 780                         playList.write("\r\n");
 781                 }
 782                 playList.close();
 783         }
 784         else
 785         {
 786                 QMessageBox::warning(this, tr("Playlist creation failed"), QString("%1<br><nobr>%2</nobr>").arg(tr("The playlist file could not be created:"), playListFile));
 787         }
 788 }
 789
 790 AudioFileModel ProcessingDialog::updateMetaInfo(const AudioFileModel &audioFile)
 791 {
 792         if(!m_settings->writeMetaTags())
 793         {
 794                 return AudioFileModel(audioFile, false);
 795         }
 796
 797         AudioFileModel result = audioFile;
 798         result.updateMetaInfo(*m_metaInfo);
 799
 800         if(m_metaInfo->filePosition() == UINT_MAX)
 801         {
 802                 result.setFilePosition(m_currentFile);
 803         }
 804
 805         return result;
 806 }
 807
 808 void ProcessingDialog::setCloseButtonEnabled(bool enabled)
 809 {
 810         HMENU hMenu = GetSystemMenu((HWND) winId(), FALSE);
 811         EnableMenuItem(hMenu, SC_CLOSE, MF_BYCOMMAND | (enabled ? MF_ENABLED : MF_GRAYED));
 812 }
 813
 814 void ProcessingDialog::systemTrayActivated(QSystemTrayIcon::ActivationReason reason)
 815 {
 816         if(reason == QSystemTrayIcon::DoubleClick)
 817         {
 818                 SetForegroundWindow(this->winId());
 819         }
 820 }
 821
 822 bool ProcessingDialog::shutdownComputer(void)
 823 {
 824         const int iTimeout = 30;
 825         const Qt::WindowFlags flags = Qt::WindowStaysOnTopHint | Qt::CustomizeWindowHint | Qt::WindowTitleHint | Qt::MSWindowsFixedSizeDialogHint | Qt::WindowSystemMenuHint;
 826         const QString text = QString("%1%2%1").arg(QString().fill(' ', 18), tr("Warning: Computer will shutdown in %1 seconds..."));
 827
 828         qWarning("Initiating shutdown sequence!");
 829
 830         QProgressDialog progressDialog(text.arg(iTimeout), tr("Cancel Shutdown"), 0, iTimeout + 1, this, flags);
 831         QPushButton *cancelButton = new QPushButton(tr("Cancel Shutdown"), &progressDialog);
 832         cancelButton->setIcon(QIcon(":/icons/power_on.png"));
 833         progressDialog.setModal(true);
 834         progressDialog.setAutoClose(false);
 835         progressDialog.setAutoReset(false);
 836         progressDialog.setWindowIcon(QIcon(":/icons/power_off.png"));
 837         progressDialog.setCancelButton(cancelButton);
 838         progressDialog.show();
 839
 840         QApplication::processEvents();
 841
 842         if(m_settings->soundsEnabled())
 843         {
 844                 QApplication::setOverrideCursor(Qt::WaitCursor);
 845                 PlaySound(MAKEINTRESOURCE(IDR_WAVE_SHUTDOWN), GetModuleHandle(NULL), SND_RESOURCE | SND_SYNC);
 846                 QApplication::restoreOverrideCursor();
 847         }
 848
 849         QTimer timer;
 850         timer.setInterval(1000);
 851         timer.start();
 852
 853         QEventLoop eventLoop(this);
 854         connect(&timer, SIGNAL(timeout()), &eventLoop, SLOT(quit()));
 855         connect(&progressDialog, SIGNAL(canceled()), &eventLoop, SLOT(quit()));
 856
 857         for(int i = 1; i <= iTimeout; i++)
 858         {
 859                 eventLoop.exec();
 860                 if(progressDialog.wasCanceled())
 861                 {
 862                         progressDialog.close();
 863                         return false;
 864                 }
 865                 progressDialog.setValue(i+1);
 866                 progressDialog.setLabelText(text.arg(iTimeout-i));
 867                 if(iTimeout-i == 3) progressDialog.setCancelButton(NULL);
 868                 QApplication::processEvents();
 869                 PlaySound(MAKEINTRESOURCE((i < iTimeout) ? IDR_WAVE_BEEP : IDR_WAVE_BEEP_LONG), GetModuleHandle(NULL), SND_RESOURCE | SND_SYNC);
 870         }
 871
 872         progressDialog.close();
 873         return true;
 874 }