1 ///////////////////////////////////////////////////////////////////////////////
2 // LameXP - Audio Encoder Front-End
3 // Copyright (C) 2004-2017 LoRd_MuldeR <MuldeR2@GMX.de>
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.
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.
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.
20 // http://www.gnu.org/licenses/gpl-2.0.txt
21 ///////////////////////////////////////////////////////////////////////////////
23 #include "Thread_Process.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"
39 #include <MUtils/Global.h>
40 #include <MUtils/OSSupport.h>
41 #include <MUtils/Version.h>
48 #include <QMutexLocker>
50 #include <QThreadPool>
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)
61 ////////////////////////////////////////////////////////////
63 ////////////////////////////////////////////////////////////
65 ProcessThread::ProcessThread(const AudioFileModel
&audioFile
, const QString
&outputDirectory
, const QString
&tempDirectory
, AbstractEncoder
*encoder
, const bool prependRelativeSourcePath
)
67 m_audioFile(audioFile
),
68 m_outputDirectory(outputDirectory
),
69 m_tempDirectory(tempDirectory
),
71 m_jobId(QUuid::createUuid()),
72 m_prependRelativeSourcePath(prependRelativeSourcePath
),
73 m_renamePattern("<BaseName>"),
74 m_overwriteMode(OverwriteMode_KeepBoth
),
75 m_keepDateTime(false),
77 m_propDetect(new WaveProperties())
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
);
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
);
85 m_currentStep
= UnknownStep
;
88 ProcessThread::~ProcessThread(void)
90 while(!m_tempFiles
.isEmpty())
92 MUtils::remove_file(m_tempFiles
.takeFirst());
95 while(!m_filters
.isEmpty())
97 delete m_filters
.takeFirst();
100 MUTILS_DELETE(m_encoder
);
101 MUTILS_DELETE(m_propDetect
);
103 emit
processFinished();
106 ////////////////////////////////////////////////////////////
108 ////////////////////////////////////////////////////////////
110 bool ProcessThread::init(void)
112 if(m_initialized
.testAndSetOrdered((-1), 0))
114 //Initialize job status
115 qDebug("Process thread %s has started.", m_jobId
.toString().toLatin1().constData());
116 emit
processStateInitialized(m_jobId
, QFileInfo(m_audioFile
.filePath()).fileName(), tr("Starting..."), ProgressModel::JobRunning
);
119 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
))));
120 handleMessage("\n-------------------------------\n");
125 qWarning("[ProcessThread::init] Job %s already initialialized, skipping!", m_jobId
.toString().toLatin1().constData());
129 bool ProcessThread::start(QThreadPool
*const pool
)
131 //Make sure object was initialized correctly
132 if (m_initialized
< 0)
134 MUTILS_THROW("Object not initialized yet!");
137 if (m_initialized
.testAndSetOrdered(0, 1))
139 m_outFileName
.clear();
140 m_aborted
.fetchAndStoreOrdered(0);
141 bool bSuccess
= false;
143 //Generate output file name
144 switch(generateOutFileName(m_outFileName
))
147 //File name generated successfully :-)
152 //File name already exists -> skipping!
153 emit
processStateChanged(m_jobId
, tr("Skipped."), ProgressModel::JobSkipped
);
154 emit
processStateFinished(m_jobId
, m_outFileName
, -1);
157 //File name could not be generated
158 emit
processStateChanged(m_jobId
, tr("Not found!"), ProgressModel::JobFailed
);
159 emit
processStateFinished(m_jobId
, m_outFileName
, 0);
165 emit
processFinished();
171 qWarning("[ProcessThread::start] Job %s already started, skipping!", m_jobId
.toString().toLatin1().constData());
175 ////////////////////////////////////////////////////////////
176 // Thread Entry Point
177 ////////////////////////////////////////////////////////////
179 void ProcessThread::run()
185 catch(const std::exception
&error
)
187 MUTILS_PRINT_ERROR("\nGURU MEDITATION !!!\n\nException error:\n%s\n", error
.what());
188 MUtils::OS::fatal_exit(L
"Unhandeled C++ exception error, application will exit!");
192 MUTILS_PRINT_ERROR("\nGURU MEDITATION !!!\n\nUnknown exception error!\n");
193 MUtils::OS::fatal_exit(L
"Unhandeled C++ exception error, application will exit!");
197 void ProcessThread::processFile()
200 bool bSuccess
= true;
202 //Make sure object was initialized correctly
203 if(m_initialized
< 1)
205 MUTILS_THROW("Object not initialized yet!");
208 QString sourceFile
= m_audioFile
.filePath();
210 //-----------------------------------------------------
211 // Decode source file
212 //-----------------------------------------------------
214 const AudioFileModel_TechInfo
&formatInfo
= m_audioFile
.techInfo();
215 if(!m_filters
.isEmpty() || !m_encoder
->isFormatSupported(formatInfo
.containerType(), formatInfo
.containerProfile(), formatInfo
.audioType(), formatInfo
.audioProfile(), formatInfo
.audioVersion()))
217 m_currentStep
= DecodingStep
;
218 AbstractDecoder
*decoder
= DecoderRegistry::lookup(formatInfo
.containerType(), formatInfo
.containerProfile(), formatInfo
.audioType(), formatInfo
.audioProfile(), formatInfo
.audioVersion());
222 QString tempFile
= generateTempFileName();
224 connect(decoder
, SIGNAL(statusUpdated(int)), this, SLOT(handleUpdate(int)), Qt::DirectConnection
);
225 connect(decoder
, SIGNAL(messageLogged(QString
)), this, SLOT(handleMessage(QString
)), Qt::DirectConnection
);
227 bSuccess
= decoder
->decode(sourceFile
, tempFile
, m_aborted
);
228 MUTILS_DELETE(decoder
);
232 sourceFile
= tempFile
;
233 m_audioFile
.techInfo().setContainerType(QString::fromLatin1("Wave"));
234 m_audioFile
.techInfo().setAudioType(QString::fromLatin1("PCM"));
236 if(QFileInfo(sourceFile
).size() >= 4294967296i64
)
238 handleMessage(tr("WARNING: Decoded file size exceeds 4 GB, problems might occur!\n"));
241 handleMessage("\n-------------------------------\n");
246 if(QFileInfo(m_outFileName
).exists() && (QFileInfo(m_outFileName
).size() < 512)) QFile::remove(m_outFileName
);
247 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()));
248 emit
processStateChanged(m_jobId
, tr("Unsupported!"), ProgressModel::JobFailed
);
249 emit
processStateFinished(m_jobId
, m_outFileName
, 0);
254 //-----------------------------------------------------
255 // Update audio properties after decode
256 //-----------------------------------------------------
258 if(bSuccess
&& (!m_aborted
) && IS_WAVE(m_audioFile
.techInfo()))
260 if(m_encoder
->supportedSamplerates() || m_encoder
->supportedBitdepths() || m_encoder
->supportedChannelCount() || m_encoder
->needsTimingInfo() || !m_filters
.isEmpty())
262 m_currentStep
= AnalyzeStep
;
263 bSuccess
= m_propDetect
->detect(sourceFile
, &m_audioFile
.techInfo(), m_aborted
);
267 handleMessage("\n-------------------------------\n");
269 //Do we need to take care if Stereo downmix?
270 const unsigned int *const supportedChannelCount
= m_encoder
->supportedChannelCount();
271 if(supportedChannelCount
&& supportedChannelCount
[0])
273 insertDownmixFilter(supportedChannelCount
);
276 //Do we need to take care of downsampling the input?
277 const unsigned int *const supportedSamplerates
= m_encoder
->supportedSamplerates();
278 const unsigned int *const supportedBitdepths
= m_encoder
->supportedBitdepths();
279 if((supportedSamplerates
&& supportedSamplerates
[0]) || (supportedBitdepths
&& supportedBitdepths
[0]))
281 insertDownsampleFilter(supportedSamplerates
, supportedBitdepths
);
287 //-----------------------------------------------------
288 // Apply all audio filters
289 //-----------------------------------------------------
291 while(bSuccess
&& (!m_filters
.isEmpty()) && (!m_aborted
))
293 QString tempFile
= generateTempFileName();
294 AbstractFilter
*poFilter
= m_filters
.takeFirst();
295 m_currentStep
= FilteringStep
;
297 connect(poFilter
, SIGNAL(statusUpdated(int)), this, SLOT(handleUpdate(int)), Qt::DirectConnection
);
298 connect(poFilter
, SIGNAL(messageLogged(QString
)), this, SLOT(handleMessage(QString
)), Qt::DirectConnection
);
300 const AbstractFilter::FilterResult filterResult
= poFilter
->apply(sourceFile
, tempFile
, &m_audioFile
.techInfo(), m_aborted
);
301 switch (filterResult
)
303 case AbstractFilter::FILTER_SUCCESS
:
304 sourceFile
= tempFile
;
306 case AbstractFilter::FILTER_FAILURE
:
311 handleMessage("\n-------------------------------\n");
315 //-----------------------------------------------------
317 //-----------------------------------------------------
319 if(bSuccess
&& (!m_aborted
))
321 m_currentStep
= EncodingStep
;
322 bSuccess
= m_encoder
->encode(sourceFile
, m_audioFile
.metaInfo(), m_audioFile
.techInfo().duration(), m_audioFile
.techInfo().audioChannels(), m_outFileName
, m_aborted
);
326 if((!bSuccess
) || MUTILS_BOOLIFY(m_aborted
))
328 QFileInfo
fileInfo(m_outFileName
);
329 if(fileInfo
.exists() && (fileInfo
.size() < 1024))
331 QFile::remove(m_outFileName
);
335 //Make sure output file exists
336 if(bSuccess
&& (!m_aborted
))
338 const QFileInfo
fileInfo(m_outFileName
);
339 bSuccess
= fileInfo
.exists() && fileInfo
.isFile() && (fileInfo
.size() >= 1024);
342 //-----------------------------------------------------
344 //-----------------------------------------------------
346 if (bSuccess
&& (!m_aborted
) && m_keepDateTime
)
348 updateFileTime(m_audioFile
.filePath(), m_outFileName
);
351 MUtils::OS::sleep_ms(12);
354 emit
processStateChanged(m_jobId
, (MUTILS_BOOLIFY(m_aborted
) ? tr("Aborted!") : (bSuccess
? tr("Done.") : tr("Failed!"))), ((bSuccess
&& (!m_aborted
)) ? ProgressModel::JobComplete
: ProgressModel::JobFailed
));
355 emit
processStateFinished(m_jobId
, m_outFileName
, (bSuccess
? 1 : 0));
357 qDebug("Process thread is done.");
360 ////////////////////////////////////////////////////////////
362 ////////////////////////////////////////////////////////////
364 void ProcessThread::handleUpdate(int progress
)
366 //qDebug("Progress: %d\n", progress);
368 switch(m_currentStep
)
371 emit
processStateChanged(m_jobId
, QString("%1 (%2%)").arg(tr("Encoding"), QString::number(progress
)), ProgressModel::JobRunning
);
374 emit
processStateChanged(m_jobId
, QString("%1 (%2%)").arg(tr("Analyzing"), QString::number(progress
)), ProgressModel::JobRunning
);
377 emit
processStateChanged(m_jobId
, QString("%1 (%2%)").arg(tr("Filtering"), QString::number(progress
)), ProgressModel::JobRunning
);
380 emit
processStateChanged(m_jobId
, QString("%1 (%2%)").arg(tr("Decoding"), QString::number(progress
)), ProgressModel::JobRunning
);
385 void ProcessThread::handleMessage(const QString
&line
)
387 emit
processMessageLogged(m_jobId
, line
);
390 ////////////////////////////////////////////////////////////
392 ////////////////////////////////////////////////////////////
394 int ProcessThread::generateOutFileName(QString
&outFileName
)
398 //Make sure the source file exists
399 const QFileInfo
sourceFile(m_audioFile
.filePath());
400 if(!(sourceFile
.exists() && sourceFile
.isFile()))
402 handleMessage(QString("%1\n%2").arg(tr("The source audio file could not be found:"), sourceFile
.absoluteFilePath()));
406 //Make sure the source file readable
407 QFile
readTest(sourceFile
.canonicalFilePath());
408 if(!readTest
.open(QIODevice::ReadOnly
))
410 handleMessage(QString("%1\n%2").arg(tr("The source audio file could not be opened for reading:"), QDir::toNativeSeparators(readTest
.fileName())));
418 const QString baseName
= sourceFile
.completeBaseName();
419 QDir
targetDir(MUtils::clean_file_path(m_outputDirectory
.isEmpty() ? sourceFile
.canonicalPath() : m_outputDirectory
, false));
421 //Prepend relative source file path?
422 if(m_prependRelativeSourcePath
&& !m_outputDirectory
.isEmpty())
424 QDir sourceDir
= sourceFile
.dir();
425 if (!sourceDir
.isRoot())
428 while ((!sourceDir
.isRoot()) && (++depth
<= 0xFF))
430 if (!sourceDir
.cdUp()) break;
432 const QString postfix
= QFileInfo(sourceDir
.relativeFilePath(sourceFile
.canonicalFilePath())).path();
433 targetDir
.setPath(MUtils::clean_file_path(QString("%1/%2").arg(targetDir
.absolutePath(), postfix
), false));
437 //Make sure output directory does exist
438 if(!targetDir
.exists())
440 targetDir
.mkpath(".");
441 if(!targetDir
.exists())
443 handleMessage(QString("%1\n%2").arg(tr("The target output directory doesn't exist and could NOT be created:"), QDir::toNativeSeparators(targetDir
.absolutePath())));
448 //Make sure that the output dir is writable
449 QFile
writeTest(QString("%1/.%2").arg(targetDir
.canonicalPath(), MUtils::next_rand_str()));
450 if(!writeTest
.open(QIODevice::ReadWrite
))
452 handleMessage(QString("%1\n%2").arg(tr("The target output directory is NOT writable:"), QDir::toNativeSeparators(targetDir
.absolutePath())));
460 //Apply rename pattern
461 const QString fileName
= MUtils::clean_file_name(applyRegularExpression(applyRenamePattern(baseName
, m_audioFile
.metaInfo())), true);
463 //Generate full output path
464 const QString fileExt
= m_renameFileExt
.isEmpty() ? QString::fromUtf8(m_encoder
->toEncoderInfo()->extension()) : m_renameFileExt
;
465 outFileName
= QString("%1/%2.%3").arg(targetDir
.canonicalPath(), fileName
, fileExt
);
467 //Skip file, if target file exists (optional!)
468 if((m_overwriteMode
== OverwriteMode_SkipExisting
) && QFileInfo(outFileName
).exists())
470 handleMessage(QString("%1\n%2\n").arg(tr("Target output file already exists, going to skip this file:"), QDir::toNativeSeparators(outFileName
)));
471 handleMessage(tr("If you don't want existing files to be skipped, please change the overwrite mode!"));
475 //Delete file, if target file exists (optional!)
476 if((m_overwriteMode
== OverwriteMode_Overwrite
) && QFileInfo(outFileName
).exists() && QFileInfo(outFileName
).isFile())
478 handleMessage(QString("%1\n%2\n").arg(tr("Target output file already exists, going to delete existing file:"), QDir::toNativeSeparators(outFileName
)));
479 if(sourceFile
.canonicalFilePath().compare(QFileInfo(outFileName
).absoluteFilePath(), Qt::CaseInsensitive
) != 0)
481 for(int i
= 0; i
< 16; i
++)
483 if(QFile::remove(outFileName
))
487 MUtils::OS::sleep_ms(1);
490 if(QFileInfo(outFileName
).exists())
492 handleMessage(QString("%1\n").arg(tr("Failed to delete existing target file, will save to another file name!")));
498 //Generate final name
499 while(QFileInfo(outFileName
).exists() && (n
< (INT_MAX
/2)))
501 outFileName
= QString("%1/%2 (%3).%4").arg(targetDir
.canonicalPath(), fileName
, QString::number(++n
), fileExt
);
505 QFile
placeholder(outFileName
);
506 if(placeholder
.open(QIODevice::WriteOnly
))
514 QString
ProcessThread::applyRenamePattern(const QString
&baseName
, const AudioFileModel_MetaInfo
&metaInfo
)
516 QString fileName
= m_renamePattern
;
518 fileName
.replace("<BaseName>", STRDEF(baseName
, tr("Unknown File Name")), Qt::CaseInsensitive
);
519 fileName
.replace("<TrackNo>", QString().sprintf("%02d", metaInfo
.position()), Qt::CaseInsensitive
);
520 fileName
.replace("<Title>", STRDEF(metaInfo
.title(), tr("Unknown Title")) , Qt::CaseInsensitive
);
521 fileName
.replace("<Artist>", STRDEF(metaInfo
.artist(), tr("Unknown Artist")), Qt::CaseInsensitive
);
522 fileName
.replace("<Album>", STRDEF(metaInfo
.album(), tr("Unknown Album")), Qt::CaseInsensitive
);
523 fileName
.replace("<Year>", QString().sprintf("%04d", metaInfo
.year()), Qt::CaseInsensitive
);
524 fileName
.replace("<Comment>", STRDEF(metaInfo
.comment(), tr("Unknown Comment")), Qt::CaseInsensitive
);
526 return fileName
.trimmed().isEmpty() ? baseName
: fileName
;
529 QString
ProcessThread::applyRegularExpression(const QString
&baseName
)
531 if(m_renameRegExp_Search
.isEmpty() || m_renameRegExp_Replace
.isEmpty())
536 QRegExp
regExp(m_renameRegExp_Search
);
537 if(!regExp
.isValid())
539 qWarning("Invalid regular expression detected -> cannot rename!");
543 const QString fileName
= QString(baseName
).replace(regExp
, m_renameRegExp_Replace
);
544 return fileName
.trimmed().isEmpty() ? baseName
: fileName
;
547 QString
ProcessThread::generateTempFileName(void)
549 const QString tempFileName
= MUtils::make_temp_file(m_tempDirectory
, "wav", true);
550 if(tempFileName
.isEmpty())
552 return QString("%1/~whoops%2.wav").arg(m_tempDirectory
, QString::number(MUtils::next_rand_u32()));
555 m_tempFiles
<< tempFileName
;
559 bool ProcessThread::insertDownsampleFilter(const unsigned int *const supportedSamplerates
, const unsigned int *const supportedBitdepths
)
561 int targetSampleRate
= 0, targetBitDepth
= 0;
563 /* Adjust sample rate */
564 if(supportedSamplerates
&& m_audioFile
.techInfo().audioSamplerate())
566 const unsigned int inputRate
= m_audioFile
.techInfo().audioSamplerate();
567 unsigned int currentDiff
= UINT_MAX
, minimumDiff
= UINT_MAX
, bestRate
= UINT_MAX
;
569 //Find the most suitable supported sampling rate
570 for(int i
= 0; supportedSamplerates
[i
]; i
++)
572 currentDiff
= DIFF(inputRate
, supportedSamplerates
[i
]);
573 if((currentDiff
< minimumDiff
) || ((currentDiff
== minimumDiff
) && (bestRate
< supportedSamplerates
[i
])))
575 bestRate
= supportedSamplerates
[i
];
576 minimumDiff
= currentDiff
;
577 if(!(minimumDiff
> 0)) break;
581 if(bestRate
!= inputRate
)
583 targetSampleRate
= (bestRate
!= UINT_MAX
) ? bestRate
: supportedSamplerates
[0];
587 /* Adjust bit depth (word size) */
588 if(supportedBitdepths
&& m_audioFile
.techInfo().audioBitdepth())
590 const unsigned int inputBPS
= m_audioFile
.techInfo().audioBitdepth();
591 bool bAdjustBitdepth
= true;
593 //Is the input bit depth supported exactly? (including IEEE Float)
594 for(int i
= 0; supportedBitdepths
[i
]; i
++)
596 if(supportedBitdepths
[i
] == inputBPS
) bAdjustBitdepth
= false;
601 unsigned int currentDiff
= UINT_MAX
, minimumDiff
= UINT_MAX
, bestBPS
= UINT_MAX
;
602 const unsigned int originalBPS
= (inputBPS
== AudioFileModel::BITDEPTH_IEEE_FLOAT32
) ? 32 : inputBPS
;
604 //Find the most suitable supported bit depth
605 for(int i
= 0; supportedBitdepths
[i
]; i
++)
607 if(supportedBitdepths
[i
] == AudioFileModel::BITDEPTH_IEEE_FLOAT32
) continue;
609 currentDiff
= DIFF(originalBPS
, supportedBitdepths
[i
]);
610 if((currentDiff
< minimumDiff
) || ((currentDiff
== minimumDiff
) && (bestBPS
< supportedBitdepths
[i
])))
612 bestBPS
= supportedBitdepths
[i
];
613 minimumDiff
= currentDiff
;
614 if(!(minimumDiff
> 0)) break;
618 if(bestBPS
!= originalBPS
)
620 targetBitDepth
= (bestBPS
!= UINT_MAX
) ? bestBPS
: supportedBitdepths
[0];
625 //Check if downsampling filter is already in the chain
626 if (targetSampleRate
|| targetBitDepth
)
628 for (int i
= 0; i
< m_filters
.count(); i
++)
630 if (dynamic_cast<ResampleFilter
*>(m_filters
.at(i
)))
632 qWarning("Encoder requires downsampling, but user has already set resamling filter!");
633 handleMessage("WARNING: Encoder may need resampling, but already using resample filter. Encoding *may* fail!\n");
634 targetSampleRate
= targetBitDepth
= 0;
639 /* Insert the filter */
640 if(targetSampleRate
|| targetBitDepth
)
642 m_filters
.append(new ResampleFilter(targetSampleRate
, targetBitDepth
));
646 return false; /*did not insert the resample filter */
649 bool ProcessThread::insertDownmixFilter(const unsigned int *const supportedChannels
)
651 //Determine number of channels in source
652 const unsigned int channels
= m_audioFile
.techInfo().audioChannels();
653 bool requiresDownmix
= (channels
> 0);
655 //Check whether encoder requires downmixing
658 for (int i
= 0; supportedChannels
[i
]; i
++)
660 if (supportedChannels
[i
] == channels
)
662 requiresDownmix
= false;
668 //Check if downmixing filter is already in the chain
671 for (int i
= 0; i
< m_filters
.count(); i
++)
673 if (dynamic_cast<DownmixFilter
*>(m_filters
.at(i
)))
675 qWarning("Encoder requires Stereo downmix, but user has already forced downmix!");
676 handleMessage("WARNING: Encoder may need downmixning, but already using downmixning filter. Encoding *may* fail!\n");
677 requiresDownmix
= false;
683 //Now add the downmixing filter, if needed
686 m_filters
.append(new DownmixFilter());
690 return false; /*did not insert the downmix filter*/
693 bool ProcessThread::updateFileTime(const QString
&originalFile
, const QString
&modifiedFile
)
695 bool success
= false;
697 QFileInfo
originalFileInfo(originalFile
);
698 const QDateTime timeCreated
= originalFileInfo
.created(), timeLastMod
= originalFileInfo
.lastModified();
699 if (timeCreated
.isValid() && timeLastMod
.isValid())
701 if (!MUtils::OS::set_file_time(modifiedFile
, timeCreated
, timeLastMod
))
703 qWarning("Failed to update creation/modified time of output file: \"%s\"", MUTILS_UTF8(modifiedFile
));
708 qWarning("Failed to read creation/modified time of source file: \"%s\"", MUTILS_UTF8(originalFile
));
714 ////////////////////////////////////////////////////////////
716 ////////////////////////////////////////////////////////////
718 void ProcessThread::addFilter(AbstractFilter
*filter
)
720 m_filters
.append(filter
);
723 void ProcessThread::setRenamePattern(const QString
&pattern
)
725 const QString newPattern
= pattern
.simplified();
726 if(!newPattern
.isEmpty()) m_renamePattern
= newPattern
;
729 void ProcessThread::setRenameRegExp(const QString
&search
, const QString
&replace
)
731 const QString newSearch
= search
.trimmed(), newReplace
= replace
.simplified();
732 if((!newSearch
.isEmpty()) && (!newReplace
.isEmpty()))
734 m_renameRegExp_Search
= newSearch
;
735 m_renameRegExp_Replace
= newReplace
;
739 void ProcessThread::setRenameFileExt(const QString
&fileExtension
)
741 m_renameFileExt
= MUtils::clean_file_name(fileExtension
, false).simplified();
742 while(m_renameFileExt
.startsWith('.'))
744 m_renameFileExt
= m_renameFileExt
.mid(1).trimmed();
748 void ProcessThread::setOverwriteMode(const bool &bSkipExistingFile
, const bool &bReplacesExisting
)
750 if(bSkipExistingFile
&& bReplacesExisting
)
752 qWarning("Inconsistent overwrite flags -> reverting to default!");
753 m_overwriteMode
= OverwriteMode_KeepBoth
;
757 m_overwriteMode
= OverwriteMode_KeepBoth
;
758 if(bSkipExistingFile
) m_overwriteMode
= OverwriteMode_SkipExisting
;
759 if(bReplacesExisting
) m_overwriteMode
= OverwriteMode_Overwrite
;
763 void ProcessThread::setKeepDateTime(const bool &keepDateTime
)
765 m_keepDateTime
= keepDateTime
;
768 ////////////////////////////////////////////////////////////
770 ////////////////////////////////////////////////////////////