src/Thread_Process.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // LameXP - Audio Encoder Front-End
   3 // Copyright (C) 2004-2015 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, but always including the *additional*
   9 // restrictions defined in the "License.txt" file.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License along
  17 // with this program; if not, write to the Free Software Foundation, Inc.,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20 // http://www.gnu.org/licenses/gpl-2.0.txt
  21 ///////////////////////////////////////////////////////////////////////////////
  22
  23 #include "Thread_Process.h"
  24
  25 //Internal
  26 #include "Global.h"
  27 #include "Model_AudioFile.h"
  28 #include "Model_Progress.h"
  29 #include "Encoder_Abstract.h"
  30 #include "Decoder_Abstract.h"
  31 #include "Filter_Abstract.h"
  32 #include "Filter_Downmix.h"
  33 #include "Filter_Resample.h"
  34 #include "Tool_WaveProperties.h"
  35 #include "Registry_Decoder.h"
  36 #include "Model_Settings.h"
  37
  38 //MUtils
  39 #include <MUtils/Global.h>
  40 #include <MUtils/OSSupport.h>
  41 #include <MUtils/Version.h>
  42
  43 //Qt
  44 #include <QUuid>
  45 #include <QFileInfo>
  46 #include <QDir>
  47 #include <QMutex>
  48 #include <QMutexLocker>
  49 #include <QDate>
  50 #include <QThreadPool>
  51
  52 //CRT
  53 #include <limits.h>
  54 #include <time.h>
  55 #include <stdlib.h>
  56
  57 #define DIFF(X,Y) ((X > Y) ? (X-Y) : (Y-X))
  58 #define IS_WAVE(X) ((X.containerType().compare("Wave", Qt::CaseInsensitive) == 0) && (X.audioType().compare("PCM", Qt::CaseInsensitive) == 0))
  59 #define STRDEF(STR,DEF) ((!STR.isEmpty()) ? STR : DEF)
  60
  61 ////////////////////////////////////////////////////////////
  62 // Constructor
  63 ////////////////////////////////////////////////////////////
  64
  65 ProcessThread::ProcessThread(const AudioFileModel &audioFile, const QString &outputDirectory, const QString &tempDirectory, AbstractEncoder *encoder, const bool prependRelativeSourcePath)
  66 :
  67         m_audioFile(audioFile),
  68         m_outputDirectory(outputDirectory),
  69         m_tempDirectory(tempDirectory),
  70         m_encoder(encoder),
  71         m_jobId(QUuid::createUuid()),
  72         m_prependRelativeSourcePath(prependRelativeSourcePath),
  73         m_renamePattern("<BaseName>"),
  74         m_overwriteMode(OverwriteMode_KeepBoth),
  75         m_initialized(-1),
  76         m_aborted(false),
  77         m_propDetect(new WaveProperties())
  78 {
  79         connect(m_encoder, SIGNAL(statusUpdated(int)), this, SLOT(handleUpdate(int)), Qt::DirectConnection);
  80         connect(m_encoder, SIGNAL(messageLogged(QString)), this, SLOT(handleMessage(QString)), Qt::DirectConnection);
  81
  82         connect(m_propDetect, SIGNAL(statusUpdated(int)), this, SLOT(handleUpdate(int)), Qt::DirectConnection);
  83         connect(m_propDetect, SIGNAL(messageLogged(QString)), this, SLOT(handleMessage(QString)), Qt::DirectConnection);
  84
  85         m_currentStep = UnknownStep;
  86 }
  87
  88 ProcessThread::~ProcessThread(void)
  89 {
  90         while(!m_tempFiles.isEmpty())
  91         {
  92                 MUtils::remove_file(m_tempFiles.takeFirst());
  93         }
  94
  95         while(!m_filters.isEmpty())
  96         {
  97                 delete m_filters.takeFirst();
  98         }
  99
 100         MUTILS_DELETE(m_encoder);
 101         MUTILS_DELETE(m_propDetect);
 102
 103         emit processFinished();
 104 }
 105
 106 ////////////////////////////////////////////////////////////
 107 // Init Function
 108 ////////////////////////////////////////////////////////////
 109
 110 bool ProcessThread::init(void)
 111 {
 112         if(m_initialized < 0)
 113         {
 114                 m_initialized = 0;
 115
 116                 //Initialize job status
 117                 qDebug("Process thread %s has started.", m_jobId.toString().toLatin1().constData());
 118                 emit processStateInitialized(m_jobId, QFileInfo(m_audioFile.filePath()).fileName(), tr("Starting..."), ProgressModel::JobRunning);
 119
 120                 //Initialize log
 121                 handleMessage(QString().sprintf("LameXP v%u.%02u (Build #%u), compiled on %s at %s", lamexp_version_major(), lamexp_version_minor(), lamexp_version_build(), MUTILS_UTF8(MUtils::Version::app_build_date().toString(Qt::ISODate)), MUTILS_UTF8(MUtils::Version::app_build_time().toString(Qt::ISODate))));
 122                 handleMessage("\n-------------------------------\n");
 123
 124                 return true;
 125         }
 126
 127         qWarning("[ProcessThread::init] Job %s already initialialized, skipping!", m_jobId.toString().toLatin1().constData());
 128         return false;
 129 }
 130
 131 bool ProcessThread::start(QThreadPool *const pool)
 132 {
 133         //Make sure object was initialized correctly
 134         if(m_initialized < 0)
 135         {
 136                 MUTILS_THROW("Object not initialized yet!");
 137         }
 138
 139         if(m_initialized < 1)
 140         {
 141                 m_initialized = 1;
 142
 143                 m_outFileName.clear();
 144                 bool bSuccess = false;
 145
 146                 //Generate output file name
 147                 switch(generateOutFileName(m_outFileName))
 148                 {
 149                 case 1:
 150                         //File name generated successfully :-)
 151                         bSuccess = true;
 152                         pool->start(this);
 153                         break;
 154                 case -1:
 155                         //File name already exists -> skipping!
 156                         emit processStateChanged(m_jobId, tr("Skipped."), ProgressModel::JobSkipped);
 157                         emit processStateFinished(m_jobId, m_outFileName, -1);
 158                         break;
 159                 default:
 160                         //File name could not be generated
 161                         emit processStateChanged(m_jobId, tr("Not found!"), ProgressModel::JobFailed);
 162                         emit processStateFinished(m_jobId, m_outFileName, 0);
 163                         break;
 164                 }
 165
 166                 if(!bSuccess)
 167                 {
 168                         emit processFinished();
 169                 }
 170
 171                 return bSuccess;
 172         }
 173
 174         qWarning("[ProcessThread::start] Job %s already started, skipping!", m_jobId.toString().toLatin1().constData());
 175         return false;
 176 }
 177
 178 ////////////////////////////////////////////////////////////
 179 // Thread Entry Point
 180 ////////////////////////////////////////////////////////////
 181
 182 void ProcessThread::run()
 183 {
 184         try
 185         {
 186                 processFile();
 187         }
 188         catch(const std::exception &error)
 189         {
 190                 MUTILS_PRINT_ERROR("\nGURU MEDITATION !!!\n\nException error:\n%s\n", error.what());
 191                 MUtils::OS::fatal_exit(L"Unhandeled C++ exception error, application will exit!");
 192         }
 193         catch(...)
 194         {
 195                 MUTILS_PRINT_ERROR("\nGURU MEDITATION !!!\n\nUnknown exception error!\n");
 196                 MUtils::OS::fatal_exit(L"Unhandeled C++ exception error, application will exit!");
 197         }
 198 }
 199
 200 void ProcessThread::processFile()
 201 {
 202         m_aborted = false;
 203         bool bSuccess = true;
 204
 205         //Make sure object was initialized correctly
 206         if(m_initialized < 1)
 207         {
 208                 MUTILS_THROW("Object not initialized yet!");
 209         }
 210
 211         QString sourceFile = m_audioFile.filePath();
 212
 213         //------------------
 214         //Decode source file
 215         //------------------
 216         const AudioFileModel_TechInfo &formatInfo = m_audioFile.techInfo();
 217         if(!m_filters.isEmpty() || !m_encoder->isFormatSupported(formatInfo.containerType(), formatInfo.containerProfile(), formatInfo.audioType(), formatInfo.audioProfile(), formatInfo.audioVersion()))
 218         {
 219                 m_currentStep = DecodingStep;
 220                 AbstractDecoder *decoder = DecoderRegistry::lookup(formatInfo.containerType(), formatInfo.containerProfile(), formatInfo.audioType(), formatInfo.audioProfile(), formatInfo.audioVersion());
 221
 222                 if(decoder)
 223                 {
 224                         QString tempFile = generateTempFileName();
 225
 226                         connect(decoder, SIGNAL(statusUpdated(int)), this, SLOT(handleUpdate(int)), Qt::DirectConnection);
 227                         connect(decoder, SIGNAL(messageLogged(QString)), this, SLOT(handleMessage(QString)), Qt::DirectConnection);
 228
 229                         bSuccess = decoder->decode(sourceFile, tempFile, &m_aborted);
 230                         MUTILS_DELETE(decoder);
 231
 232                         if(bSuccess)
 233                         {
 234                                 sourceFile = tempFile;
 235                                 m_audioFile.techInfo().setContainerType(QString::fromLatin1("Wave"));
 236                                 m_audioFile.techInfo().setAudioType(QString::fromLatin1("PCM"));
 237
 238                                 if(QFileInfo(sourceFile).size() >= 4294967296i64)
 239                                 {
 240                                         handleMessage(tr("WARNING: Decoded file size exceeds 4 GB, problems might occur!\n"));
 241                                 }
 242
 243                                 handleMessage("\n-------------------------------\n");
 244                         }
 245                 }
 246                 else
 247                 {
 248                         if(QFileInfo(m_outFileName).exists() && (QFileInfo(m_outFileName).size() < 512)) QFile::remove(m_outFileName);
 249                         handleMessage(QString("%1\n%2\n\n%3\t%4\n%5\t%6").arg(tr("The format of this file is NOT supported:"), m_audioFile.filePath(), tr("Container Format:"), m_audioFile.containerInfo(), tr("Audio Format:"), m_audioFile.audioCompressInfo()));
 250                         emit processStateChanged(m_jobId, tr("Unsupported!"), ProgressModel::JobFailed);
 251                         emit processStateFinished(m_jobId, m_outFileName, 0);
 252                         return;
 253                 }
 254         }
 255
 256         //------------------------------------
 257         //Update audio properties after decode
 258         //------------------------------------
 259         if(bSuccess && !m_aborted && IS_WAVE(m_audioFile.techInfo()))
 260         {
 261                 if(m_encoder->supportedSamplerates() || m_encoder->supportedBitdepths() || m_encoder->supportedChannelCount() || m_encoder->needsTimingInfo() || !m_filters.isEmpty())
 262                 {
 263                         m_currentStep = AnalyzeStep;
 264                         bSuccess = m_propDetect->detect(sourceFile, &m_audioFile.techInfo(), &m_aborted);
 265
 266                         if(bSuccess)
 267                         {
 268                                 handleMessage("\n-------------------------------\n");
 269
 270                                 //Do we need to take care if Stereo downmix?
 271                                 if(m_encoder->supportedChannelCount())
 272                                 {
 273                                         insertDownmixFilter();
 274                                 }
 275
 276                                 //Do we need to take care of downsampling the input?
 277                                 if(m_encoder->supportedSamplerates() || m_encoder->supportedBitdepths())
 278                                 {
 279                                         insertDownsampleFilter();
 280                                 }
 281                         }
 282                 }
 283         }
 284
 285         //-----------------------
 286         //Apply all audio filters
 287         //-----------------------
 288         if(bSuccess)
 289         {
 290                 while(!m_filters.isEmpty() && !m_aborted)
 291                 {
 292                         QString tempFile = generateTempFileName();
 293                         AbstractFilter *poFilter = m_filters.takeFirst();
 294                         m_currentStep = FilteringStep;
 295
 296                         connect(poFilter, SIGNAL(statusUpdated(int)), this, SLOT(handleUpdate(int)), Qt::DirectConnection);
 297                         connect(poFilter, SIGNAL(messageLogged(QString)), this, SLOT(handleMessage(QString)), Qt::DirectConnection);
 298
 299                         if(poFilter->apply(sourceFile, tempFile, &m_audioFile.techInfo(), &m_aborted))
 300                         {
 301                                 sourceFile = tempFile;
 302                         }
 303
 304                         handleMessage("\n-------------------------------\n");
 305                         delete poFilter;
 306                 }
 307         }
 308
 309         //-----------------
 310         //Encode audio file
 311         //-----------------
 312         if(bSuccess && !m_aborted)
 313         {
 314                 m_currentStep = EncodingStep;
 315                 bSuccess = m_encoder->encode(sourceFile, m_audioFile.metaInfo(), m_audioFile.techInfo().duration(), m_outFileName, &m_aborted);
 316         }
 317
 318         //Clean-up
 319         if((!bSuccess) || m_aborted)
 320         {
 321                 QFileInfo fileInfo(m_outFileName);
 322                 if(fileInfo.exists() && (fileInfo.size() < 512))
 323                 {
 324                         QFile::remove(m_outFileName);
 325                 }
 326         }
 327
 328         //Make sure output file exists
 329         if(bSuccess && (!m_aborted))
 330         {
 331                 QFileInfo fileInfo(m_outFileName);
 332                 bSuccess = fileInfo.exists() && fileInfo.isFile() && (fileInfo.size() > 0);
 333         }
 334
 335         MUtils::OS::sleep_ms(25);
 336
 337         //Report result
 338         emit processStateChanged(m_jobId, (m_aborted ? tr("Aborted!") : (bSuccess ? tr("Done.") : tr("Failed!"))), ((bSuccess && !m_aborted) ? ProgressModel::JobComplete : ProgressModel::JobFailed));
 339         emit processStateFinished(m_jobId, m_outFileName, (bSuccess ? 1 : 0));
 340
 341         qDebug("Process thread is done.");
 342 }
 343
 344 ////////////////////////////////////////////////////////////
 345 // SLOTS
 346 ////////////////////////////////////////////////////////////
 347
 348 void ProcessThread::handleUpdate(int progress)
 349 {
 350         //qDebug("Progress: %d\n", progress);
 351
 352         switch(m_currentStep)
 353         {
 354         case EncodingStep:
 355                 emit processStateChanged(m_jobId, QString("%1 (%2%)").arg(tr("Encoding"), QString::number(progress)), ProgressModel::JobRunning);
 356                 break;
 357         case AnalyzeStep:
 358                 emit processStateChanged(m_jobId, QString("%1 (%2%)").arg(tr("Analyzing"), QString::number(progress)), ProgressModel::JobRunning);
 359                 break;
 360         case FilteringStep:
 361                 emit processStateChanged(m_jobId, QString("%1 (%2%)").arg(tr("Filtering"), QString::number(progress)), ProgressModel::JobRunning);
 362                 break;
 363         case DecodingStep:
 364                 emit processStateChanged(m_jobId, QString("%1 (%2%)").arg(tr("Decoding"), QString::number(progress)), ProgressModel::JobRunning);
 365                 break;
 366         }
 367 }
 368
 369 void ProcessThread::handleMessage(const QString &line)
 370 {
 371         emit processMessageLogged(m_jobId, line);
 372 }
 373
 374 ////////////////////////////////////////////////////////////
 375 // PRIVAE FUNCTIONS
 376 ////////////////////////////////////////////////////////////
 377
 378 int ProcessThread::generateOutFileName(QString &outFileName)
 379 {
 380         outFileName.clear();
 381
 382         //Make sure the source file exists
 383         const QFileInfo sourceFile(m_audioFile.filePath());
 384         if(!(sourceFile.exists() && sourceFile.isFile()))
 385         {
 386                 handleMessage(QString("%1\n%2").arg(tr("The source audio file could not be found:"), sourceFile.absoluteFilePath()));
 387                 return 0;
 388         }
 389
 390         //Make sure the source file readable
 391         QFile readTest(sourceFile.canonicalFilePath());
 392         if(!readTest.open(QIODevice::ReadOnly))
 393         {
 394                 handleMessage(QString("%1\n%2").arg(tr("The source audio file could not be opened for reading:"), QDir::toNativeSeparators(readTest.fileName())));
 395                 return 0;
 396         }
 397         else
 398         {
 399                 readTest.close();
 400         }
 401
 402         const QString baseName = sourceFile.completeBaseName();
 403         QDir targetDir(m_outputDirectory.isEmpty() ? sourceFile.canonicalPath() : m_outputDirectory);
 404
 405         //Prepend relative source file path?
 406         if(m_prependRelativeSourcePath && !m_outputDirectory.isEmpty())
 407         {
 408                 QDir rootDir = sourceFile.dir();
 409                 while(!rootDir.isRoot())
 410                 {
 411                         if(!rootDir.cdUp()) break;
 412                 }
 413                 targetDir.setPath(QString("%1/%2").arg(targetDir.absolutePath(), QFileInfo(rootDir.relativeFilePath(sourceFile.canonicalFilePath())).path()));
 414         }
 415
 416         //Make sure output directory does exist
 417         if(!targetDir.exists())
 418         {
 419                 targetDir.mkpath(".");
 420                 if(!targetDir.exists())
 421                 {
 422                         handleMessage(QString("%1\n%2").arg(tr("The target output directory doesn't exist and could NOT be created:"), QDir::toNativeSeparators(targetDir.absolutePath())));
 423                         return 0;
 424                 }
 425         }
 426
 427         //Make sure that the output dir is writable
 428         QFile writeTest(QString("%1/.%2").arg(targetDir.canonicalPath(), MUtils::rand_str()));
 429         if(!writeTest.open(QIODevice::ReadWrite))
 430         {
 431                 handleMessage(QString("%1\n%2").arg(tr("The target output directory is NOT writable:"), QDir::toNativeSeparators(targetDir.absolutePath())));
 432                 return 0;
 433         }
 434         else
 435         {
 436                 writeTest.remove();
 437         }
 438
 439         //Apply rename pattern
 440         const QString fileName = MUtils::clean_file_name(applyRegularExpression(applyRenamePattern(baseName, m_audioFile.metaInfo())));
 441
 442         //Generate full output path
 443
 444         const QString fileExt = m_renameFileExt.isEmpty() ?  QString::fromUtf8(m_encoder->toEncoderInfo()->extension()) : m_renameFileExt;
 445         outFileName = QString("%1/%2.%3").arg(targetDir.canonicalPath(), fileName, fileExt);
 446
 447         //Skip file, if target file exists (optional!)
 448         if((m_overwriteMode == OverwriteMode_SkipExisting) && QFileInfo(outFileName).exists())
 449         {
 450                 handleMessage(QString("%1\n%2\n").arg(tr("Target output file already exists, going to skip this file:"), QDir::toNativeSeparators(outFileName)));
 451                 handleMessage(tr("If you don't want existing files to be skipped, please change the overwrite mode!"));
 452                 return -1;
 453         }
 454
 455         //Delete file, if target file exists (optional!)
 456         if((m_overwriteMode == OverwriteMode_Overwrite) && QFileInfo(outFileName).exists() && QFileInfo(outFileName).isFile())
 457         {
 458                 handleMessage(QString("%1\n%2\n").arg(tr("Target output file already exists, going to delete existing file:"), QDir::toNativeSeparators(outFileName)));
 459                 if(sourceFile.canonicalFilePath().compare(QFileInfo(outFileName).absoluteFilePath(), Qt::CaseInsensitive) != 0)
 460                 {
 461                         for(int i = 0; i < 16; i++)
 462                         {
 463                                 if(QFile::remove(outFileName))
 464                                 {
 465                                         break;
 466                                 }
 467                                 MUtils::OS::sleep_ms(1);
 468                         }
 469                 }
 470                 if(QFileInfo(outFileName).exists())
 471                 {
 472                         handleMessage(QString("%1\n").arg(tr("Failed to delete existing target file, will save to another file name!")));
 473                 }
 474         }
 475
 476         int n = 1;
 477
 478         //Generate final name
 479         while(QFileInfo(outFileName).exists() && (n < (INT_MAX/2)))
 480         {
 481                 outFileName = QString("%1/%2 (%3).%4").arg(targetDir.canonicalPath(), fileName, QString::number(++n), fileExt);
 482         }
 483
 484         //Create placeholder
 485         QFile placeholder(outFileName);
 486         if(placeholder.open(QIODevice::WriteOnly))
 487         {
 488                 placeholder.close();
 489         }
 490
 491         return 1;
 492 }
 493
 494 QString ProcessThread::applyRenamePattern(const QString &baseName, const AudioFileModel_MetaInfo &metaInfo)
 495 {
 496         QString fileName = m_renamePattern;
 497
 498         fileName.replace("<BaseName>", STRDEF(baseName, tr("Unknown File Name")),         Qt::CaseInsensitive);
 499         fileName.replace("<TrackNo>",  QString().sprintf("%02d", metaInfo.position()),    Qt::CaseInsensitive);
 500         fileName.replace("<Title>",    STRDEF(metaInfo.title(), tr("Unknown Title")) ,    Qt::CaseInsensitive);
 501         fileName.replace("<Artist>",   STRDEF(metaInfo.artist(), tr("Unknown Artist")),   Qt::CaseInsensitive);
 502         fileName.replace("<Album>",    STRDEF(metaInfo.album(), tr("Unknown Album")),     Qt::CaseInsensitive);
 503         fileName.replace("<Year>",     QString().sprintf("%04d", metaInfo.year()),        Qt::CaseInsensitive);
 504         fileName.replace("<Comment>",  STRDEF(metaInfo.comment(), tr("Unknown Comment")), Qt::CaseInsensitive);
 505
 506         return fileName;
 507 }
 508
 509 QString ProcessThread::applyRegularExpression(const QString &fileName)
 510 {
 511         if(m_renameRegExp_Search.isEmpty() || m_renameRegExp_Replace.isEmpty())
 512         {
 513                 return fileName;
 514         }
 515
 516         QRegExp regExp(m_renameRegExp_Search);
 517         if(!regExp.isValid())
 518         {
 519                 qWarning("Invalid regular expression detected -> cannot rename!");
 520                 return fileName;
 521         }
 522
 523         return (QString(fileName).replace(regExp, m_renameRegExp_Replace));
 524 }
 525
 526 QString ProcessThread::generateTempFileName(void)
 527 {
 528         const QString tempFileName = MUtils::make_temp_file(m_tempDirectory, "wav", true);
 529         if(tempFileName.isEmpty())
 530         {
 531                 return QString("%1/~whoops%2.wav").arg(m_tempDirectory, QString::number(MUtils::next_rand32()));
 532         }
 533
 534         m_tempFiles << tempFileName;
 535         return tempFileName;
 536 }
 537
 538 void ProcessThread::insertDownsampleFilter(void)
 539 {
 540         int targetSampleRate = 0;
 541         int targetBitDepth = 0;
 542
 543         /* Adjust sample rate */
 544         if(m_encoder->supportedSamplerates() && m_audioFile.techInfo().audioSamplerate())
 545         {
 546                 bool applyDownsampling = true;
 547
 548                 //Check if downsampling filter is already in the chain
 549                 for(int i = 0; i < m_filters.count(); i++)
 550                 {
 551                         if(dynamic_cast<ResampleFilter*>(m_filters.at(i)))
 552                         {
 553                                 qWarning("Encoder requires downsampling, but user has already set resamling filter!");
 554                                 handleMessage("WARNING: Encoder may need resampling, but already using resample filter. Encoding *may* fail!\n");
 555                                 applyDownsampling = false;
 556                         }
 557                 }
 558
 559                 //Now determine the target sample rate, if required
 560                 if(applyDownsampling)
 561                 {
 562                         const unsigned int *supportedRates = m_encoder->supportedSamplerates();
 563                         const unsigned int inputRate = m_audioFile.techInfo().audioSamplerate();
 564                         unsigned int currentDiff = UINT_MAX, minimumDiff = UINT_MAX, bestRate = UINT_MAX;
 565
 566                         //Find the most suitable supported sampling rate
 567                         for(int i = 0; supportedRates[i]; i++)
 568                         {
 569                                 currentDiff = DIFF(inputRate, supportedRates[i]);
 570                                 if((currentDiff < minimumDiff) || ((currentDiff == minimumDiff) && (bestRate < supportedRates[i])))
 571                                 {
 572                                         bestRate = supportedRates[i];
 573                                         minimumDiff = currentDiff;
 574                                         if(!(minimumDiff > 0)) break;
 575                                 }
 576                         }
 577
 578                         if(bestRate != inputRate)
 579                         {
 580                                 targetSampleRate = (bestRate != UINT_MAX) ? bestRate : supportedRates[0];
 581                         }
 582                 }
 583         }
 584
 585         /* Adjust bit depth (word size) */
 586         if(m_encoder->supportedBitdepths() && m_audioFile.techInfo().audioBitdepth())
 587         {
 588                 const unsigned int inputBPS = m_audioFile.techInfo().audioBitdepth();
 589                 const unsigned int *supportedBPS = m_encoder->supportedBitdepths();
 590
 591                 bool bAdjustBitdepth = true;
 592
 593                 //Is the input bit depth supported exactly? (including IEEE Float)
 594                 for(int i = 0; supportedBPS[i]; i++)
 595                 {
 596                         if(supportedBPS[i] == inputBPS) bAdjustBitdepth = false;
 597                 }
 598
 599                 if(bAdjustBitdepth)
 600                 {
 601                         unsigned int currentDiff = UINT_MAX, minimumDiff = UINT_MAX, bestBPS = UINT_MAX;
 602                         const unsigned int originalBPS = (inputBPS == AudioFileModel::BITDEPTH_IEEE_FLOAT32) ? 32 : inputBPS;
 603
 604                         //Find the most suitable supported bit depth
 605                         for(int i = 0; supportedBPS[i]; i++)
 606                         {
 607                                 if(supportedBPS[i] == AudioFileModel::BITDEPTH_IEEE_FLOAT32) continue;
 608
 609                                 currentDiff = DIFF(originalBPS, supportedBPS[i]);
 610                                 if((currentDiff < minimumDiff) || ((currentDiff == minimumDiff) && (bestBPS < supportedBPS[i])))
 611                                 {
 612                                         bestBPS = supportedBPS[i];
 613                                         minimumDiff = currentDiff;
 614                                         if(!(minimumDiff > 0)) break;
 615                                 }
 616                         }
 617
 618                         if(bestBPS != originalBPS)
 619                         {
 620                                 targetBitDepth = (bestBPS != UINT_MAX) ? bestBPS : supportedBPS[0];
 621                         }
 622                 }
 623         }
 624
 625         /* Insert the filter */
 626         if(targetSampleRate || targetBitDepth)
 627         {
 628                 m_filters.append(new ResampleFilter(targetSampleRate, targetBitDepth));
 629         }
 630 }
 631
 632 void ProcessThread::insertDownmixFilter(void)
 633 {
 634         bool applyDownmixing = true;
 635
 636         //Check if downmixing filter is already in the chain
 637         for(int i = 0; i < m_filters.count(); i++)
 638         {
 639                 if(dynamic_cast<DownmixFilter*>(m_filters.at(i)))
 640                 {
 641                         qWarning("Encoder requires Stereo downmix, but user has already forced downmix!");
 642                         handleMessage("WARNING: Encoder may need downmixning, but already using downmixning filter. Encoding *may* fail!\n");
 643                         applyDownmixing = false;
 644                 }
 645         }
 646
 647         //Now add the downmixing filter, if needed
 648         if(applyDownmixing)
 649         {
 650                 bool requiresDownmix = true;
 651                 const unsigned int *supportedChannels = m_encoder->supportedChannelCount();
 652                 unsigned int channels = m_audioFile.techInfo().audioChannels();
 653
 654                 for(int i = 0; supportedChannels[i]; i++)
 655                 {
 656                         if(supportedChannels[i] == channels)
 657                         {
 658                                 requiresDownmix = false;
 659                                 break;
 660                         }
 661                 }
 662
 663                 if(requiresDownmix)
 664                 {
 665                         m_filters.append(new DownmixFilter());
 666                 }
 667         }
 668 }
 669
 670 ////////////////////////////////////////////////////////////
 671 // PUBLIC FUNCTIONS
 672 ////////////////////////////////////////////////////////////
 673
 674 void ProcessThread::addFilter(AbstractFilter *filter)
 675 {
 676         m_filters.append(filter);
 677 }
 678
 679 void ProcessThread::setRenamePattern(const QString &pattern)
 680 {
 681         const QString newPattern = pattern.simplified();
 682         if(!newPattern.isEmpty()) m_renamePattern = newPattern;
 683 }
 684
 685 void ProcessThread::setRenameRegExp(const QString &search, const QString &replace)
 686 {
 687         const QString newSearch = search.trimmed(), newReplace = replace.simplified();
 688         if((!newSearch.isEmpty()) && (!newReplace.isEmpty()))
 689         {
 690                 m_renameRegExp_Search  = newSearch;
 691                 m_renameRegExp_Replace = newReplace;
 692         }
 693 }
 694
 695 void ProcessThread::setRenameFileExt(const QString &fileExtension)
 696 {
 697         m_renameFileExt = MUtils::clean_file_name(fileExtension).simplified();
 698         while(m_renameFileExt.startsWith('.'))
 699         {
 700                 m_renameFileExt = m_renameFileExt.mid(1).trimmed();
 701         }
 702 }
 703
 704 void ProcessThread::setOverwriteMode(const bool &bSkipExistingFile, const bool &bReplacesExisting)
 705 {
 706         if(bSkipExistingFile && bReplacesExisting)
 707         {
 708                 qWarning("Inconsistent overwrite flags -> reverting to default!");
 709                 m_overwriteMode = OverwriteMode_KeepBoth;
 710         }
 711         else
 712         {
 713                 m_overwriteMode = OverwriteMode_KeepBoth;
 714                 if(bSkipExistingFile) m_overwriteMode = OverwriteMode_SkipExisting;
 715                 if(bReplacesExisting) m_overwriteMode = OverwriteMode_Overwrite;
 716         }
 717 }
 718
 719 ////////////////////////////////////////////////////////////
 720 // EVENTS
 721 ////////////////////////////////////////////////////////////
 722
 723 /*NONE*/