src/Thread_Process.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // LameXP - Audio Encoder Front-End
   3 // Copyright (C) 2004-2014 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 *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(125);
 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         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         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         QString fileName = applyRenamePattern(baseName, m_audioFile.metaInfo());
 441
 442         //Generate full output path
 443         outFileName = QString("%1/%2.%3").arg(targetDir.canonicalPath(), fileName, m_encoder->extension());
 444
 445         //Skip file, if target file exists (optional!)
 446         if((m_overwriteMode == OverwriteMode_SkipExisting) && QFileInfo(outFileName).exists())
 447         {
 448                 handleMessage(QString("%1\n%2\n").arg(tr("Target output file already exists, going to skip this file:"), QDir::toNativeSeparators(outFileName)));
 449                 handleMessage(tr("If you don't want existing files to be skipped, please change the overwrite mode!"));
 450                 return -1;
 451         }
 452
 453         //Delete file, if target file exists (optional!)
 454         if((m_overwriteMode == OverwriteMode_Overwrite) && QFileInfo(outFileName).exists() && QFileInfo(outFileName).isFile())
 455         {
 456                 handleMessage(QString("%1\n%2\n").arg(tr("Target output file already exists, going to delete existing file:"), QDir::toNativeSeparators(outFileName)));
 457                 if(sourceFile.canonicalFilePath().compare(QFileInfo(outFileName).absoluteFilePath(), Qt::CaseInsensitive) != 0)
 458                 {
 459                         for(int i = 0; i < 16; i++)
 460                         {
 461                                 if(QFile::remove(outFileName))
 462                                 {
 463                                         break;
 464                                 }
 465                                 MUtils::OS::sleep_ms(125);
 466                         }
 467                 }
 468                 if(QFileInfo(outFileName).exists())
 469                 {
 470                         handleMessage(QString("%1\n").arg(tr("Failed to delete existing target file, will save to another file name!")));
 471                 }
 472         }
 473
 474         int n = 1;
 475
 476         //Generate final name
 477         while(QFileInfo(outFileName).exists() && (n < (INT_MAX/2)))
 478         {
 479                 outFileName = QString("%1/%2 (%3).%4").arg(targetDir.canonicalPath(), fileName, QString::number(++n), m_encoder->extension());
 480         }
 481
 482         //Create placeholder
 483         QFile placeholder(outFileName);
 484         if(placeholder.open(QIODevice::WriteOnly))
 485         {
 486                 placeholder.close();
 487         }
 488
 489         return 1;
 490 }
 491
 492 QString ProcessThread::applyRenamePattern(const QString &baseName, const AudioFileModel_MetaInfo &metaInfo)
 493 {
 494         QString fileName = m_renamePattern;
 495
 496         fileName.replace("<BaseName>", STRDEF(baseName, tr("Unknown File Name")), Qt::CaseInsensitive);
 497         fileName.replace("<TrackNo>", QString().sprintf("%02d", metaInfo.position()), Qt::CaseInsensitive);
 498         fileName.replace("<Title>", STRDEF(metaInfo.title(), tr("Unknown Title")) , Qt::CaseInsensitive);
 499         fileName.replace("<Artist>", STRDEF(metaInfo.artist(), tr("Unknown Artist")), Qt::CaseInsensitive);
 500         fileName.replace("<Album>", STRDEF(metaInfo.album(), tr("Unknown Album")), Qt::CaseInsensitive);
 501         fileName.replace("<Year>", QString().sprintf("%04d", metaInfo.year()), Qt::CaseInsensitive);
 502         fileName.replace("<Comment>", STRDEF(metaInfo.comment(), tr("Unknown Comment")), Qt::CaseInsensitive);
 503         fileName = lamexp_clean_filename(fileName).simplified();
 504
 505         return fileName;
 506 }
 507
 508 QString ProcessThread::generateTempFileName(void)
 509 {
 510         bool bOkay = false;
 511         QString tempFileName;
 512
 513         for(int i = 0; i < 4096; i++)
 514         {
 515                 tempFileName = QString("%1/%2.wav").arg(m_tempDirectory, MUtils::rand_str());
 516                 if(m_tempFiles.contains(tempFileName, Qt::CaseInsensitive) || QFileInfo(tempFileName).exists())
 517                 {
 518                         continue;
 519                 }
 520
 521                 QFile file(tempFileName);
 522                 if(file.open(QFile::ReadWrite))
 523                 {
 524                         file.close();
 525                         bOkay = true;
 526                         break;
 527                 }
 528         }
 529
 530         if(!bOkay)
 531         {
 532                 qWarning("Failed to generate unique temp file name!");
 533                 return QString("%1/~whoops.wav").arg(m_tempDirectory);
 534         }
 535
 536         m_tempFiles << tempFileName;
 537         return tempFileName;
 538 }
 539
 540 void ProcessThread::insertDownsampleFilter(void)
 541 {
 542         int targetSampleRate = 0;
 543         int targetBitDepth = 0;
 544
 545         /* Adjust sample rate */
 546         if(m_encoder->supportedSamplerates() && m_audioFile.techInfo().audioSamplerate())
 547         {
 548                 bool applyDownsampling = true;
 549
 550                 //Check if downsampling filter is already in the chain
 551                 for(int i = 0; i < m_filters.count(); i++)
 552                 {
 553                         if(dynamic_cast<ResampleFilter*>(m_filters.at(i)))
 554                         {
 555                                 qWarning("Encoder requires downsampling, but user has already set resamling filter!");
 556                                 handleMessage("WARNING: Encoder may need resampling, but already using resample filter. Encoding *may* fail!\n");
 557                                 applyDownsampling = false;
 558                         }
 559                 }
 560
 561                 //Now determine the target sample rate, if required
 562                 if(applyDownsampling)
 563                 {
 564                         const unsigned int *supportedRates = m_encoder->supportedSamplerates();
 565                         const unsigned int inputRate = m_audioFile.techInfo().audioSamplerate();
 566                         unsigned int currentDiff = UINT_MAX, minimumDiff = UINT_MAX, bestRate = UINT_MAX;
 567
 568                         //Find the most suitable supported sampling rate
 569                         for(int i = 0; supportedRates[i]; i++)
 570                         {
 571                                 currentDiff = DIFF(inputRate, supportedRates[i]);
 572                                 if((currentDiff < minimumDiff) || ((currentDiff == minimumDiff) && (bestRate < supportedRates[i])))
 573                                 {
 574                                         bestRate = supportedRates[i];
 575                                         minimumDiff = currentDiff;
 576                                         if(!(minimumDiff > 0)) break;
 577                                 }
 578                         }
 579
 580                         if(bestRate != inputRate)
 581                         {
 582                                 targetSampleRate = (bestRate != UINT_MAX) ? bestRate : supportedRates[0];
 583                         }
 584                 }
 585         }
 586
 587         /* Adjust bit depth (word size) */
 588         if(m_encoder->supportedBitdepths() && m_audioFile.techInfo().audioBitdepth())
 589         {
 590                 const unsigned int inputBPS = m_audioFile.techInfo().audioBitdepth();
 591                 const unsigned int *supportedBPS = m_encoder->supportedBitdepths();
 592
 593                 bool bAdjustBitdepth = true;
 594
 595                 //Is the input bit depth supported exactly? (including IEEE Float)
 596                 for(int i = 0; supportedBPS[i]; i++)
 597                 {
 598                         if(supportedBPS[i] == inputBPS) bAdjustBitdepth = false;
 599                 }
 600
 601                 if(bAdjustBitdepth)
 602                 {
 603                         unsigned int currentDiff = UINT_MAX, minimumDiff = UINT_MAX, bestBPS = UINT_MAX;
 604                         const unsigned int originalBPS = (inputBPS == AudioFileModel::BITDEPTH_IEEE_FLOAT32) ? 32 : inputBPS;
 605
 606                         //Find the most suitable supported bit depth
 607                         for(int i = 0; supportedBPS[i]; i++)
 608                         {
 609                                 if(supportedBPS[i] == AudioFileModel::BITDEPTH_IEEE_FLOAT32) continue;
 610
 611                                 currentDiff = DIFF(originalBPS, supportedBPS[i]);
 612                                 if((currentDiff < minimumDiff) || ((currentDiff == minimumDiff) && (bestBPS < supportedBPS[i])))
 613                                 {
 614                                         bestBPS = supportedBPS[i];
 615                                         minimumDiff = currentDiff;
 616                                         if(!(minimumDiff > 0)) break;
 617                                 }
 618                         }
 619
 620                         if(bestBPS != originalBPS)
 621                         {
 622                                 targetBitDepth = (bestBPS != UINT_MAX) ? bestBPS : supportedBPS[0];
 623                         }
 624                 }
 625         }
 626
 627         /* Insert the filter */
 628         if(targetSampleRate || targetBitDepth)
 629         {
 630                 m_filters.append(new ResampleFilter(targetSampleRate, targetBitDepth));
 631         }
 632 }
 633
 634 void ProcessThread::insertDownmixFilter(void)
 635 {
 636         bool applyDownmixing = true;
 637
 638         //Check if downmixing filter is already in the chain
 639         for(int i = 0; i < m_filters.count(); i++)
 640         {
 641                 if(dynamic_cast<DownmixFilter*>(m_filters.at(i)))
 642                 {
 643                         qWarning("Encoder requires Stereo downmix, but user has already forced downmix!");
 644                         handleMessage("WARNING: Encoder may need downmixning, but already using downmixning filter. Encoding *may* fail!\n");
 645                         applyDownmixing = false;
 646                 }
 647         }
 648
 649         //Now add the downmixing filter, if needed
 650         if(applyDownmixing)
 651         {
 652                 bool requiresDownmix = true;
 653                 const unsigned int *supportedChannels = m_encoder->supportedChannelCount();
 654                 unsigned int channels = m_audioFile.techInfo().audioChannels();
 655
 656                 for(int i = 0; supportedChannels[i]; i++)
 657                 {
 658                         if(supportedChannels[i] == channels)
 659                         {
 660                                 requiresDownmix = false;
 661                                 break;
 662                         }
 663                 }
 664
 665                 if(requiresDownmix)
 666                 {
 667                         m_filters.append(new DownmixFilter());
 668                 }
 669         }
 670 }
 671
 672 ////////////////////////////////////////////////////////////
 673 // PUBLIC FUNCTIONS
 674 ////////////////////////////////////////////////////////////
 675
 676 void ProcessThread::addFilter(AbstractFilter *filter)
 677 {
 678         m_filters.append(filter);
 679 }
 680
 681 void ProcessThread::setRenamePattern(const QString &pattern)
 682 {
 683         QString newPattern = pattern.simplified();
 684         if(!newPattern.isEmpty()) m_renamePattern = newPattern;
 685 }
 686
 687 void ProcessThread::setOverwriteMode(const bool &bSkipExistingFile, const bool &bReplacesExisting)
 688 {
 689         if(bSkipExistingFile && bReplacesExisting)
 690         {
 691                 qWarning("Inconsistent overwrite flags -> reverting to default!");
 692                 m_overwriteMode = OverwriteMode_KeepBoth;
 693         }
 694         else
 695         {
 696                 m_overwriteMode = OverwriteMode_KeepBoth;
 697                 if(bSkipExistingFile) m_overwriteMode = OverwriteMode_SkipExisting;
 698                 if(bReplacesExisting) m_overwriteMode = OverwriteMode_Overwrite;
 699         }
 700 }
 701
 702 ////////////////////////////////////////////////////////////
 703 // EVENTS
 704 ////////////////////////////////////////////////////////////
 705
 706 /*NONE*/