src/Thread_CueSplitter.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // LameXP - Audio Encoder Front-End
   3 // Copyright (C) 2004-2011 LoRd_MuldeR <MuldeR2@GMX.de>
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 2 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License along
  16 // with this program; if not, write to the Free Software Foundation, Inc.,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 // http://www.gnu.org/licenses/gpl-2.0.txt
  20 ///////////////////////////////////////////////////////////////////////////////
  21
  22 #include "Thread_CueSplitter.h"
  23
  24 #include "Global.h"
  25 #include "LockedFile.h"
  26 #include "Model_AudioFile.h"
  27 #include "Model_CueSheet.h"
  28 #include "Registry_Decoder.h"
  29 #include "Decoder_Abstract.h"
  30
  31 #include <QDir>
  32 #include <QFileInfo>
  33 #include <QProcess>
  34 #include <QDate>
  35 #include <QTime>
  36 #include <QDebug>
  37
  38 #include <math.h>
  39 #include <float.h>
  40 #include <limits>
  41
  42 ////////////////////////////////////////////////////////////
  43 // Constructor
  44 ////////////////////////////////////////////////////////////
  45
  46 CueSplitter::CueSplitter(const QString &outputDir, const QString &baseName, CueSheetModel *model, const QList<AudioFileModel> &inputFilesInfo)
  47 :
  48         m_model(model),
  49         m_outputDir(outputDir),
  50         m_baseName(baseName),
  51         m_soxBin(lamexp_lookup_tool("sox.exe"))
  52 {
  53         if(m_soxBin.isEmpty())
  54         {
  55                 qFatal("Invalid path to SoX binary. Tool not initialized properly.");
  56         }
  57
  58         m_decompressedFiles.clear();
  59         m_tempFiles.clear();
  60
  61         qDebug("\n[CueSplitter]");
  62
  63         int nInputFiles = inputFilesInfo.count();
  64         for(int i = 0; i < nInputFiles; i++)
  65         {
  66                 m_inputFilesInfo.insert(inputFilesInfo[i].filePath(), inputFilesInfo[i]);
  67                 qDebug("File %02d: <%s>", i, inputFilesInfo[i].filePath().toUtf8().constData());
  68         }
  69
  70         qDebug("All input files added.");
  71         m_bSuccess = false;
  72 }
  73
  74 CueSplitter::~CueSplitter(void)
  75 {
  76         while(!m_tempFiles.isEmpty())
  77         {
  78                 lamexp_remove_file(m_tempFiles.takeFirst());
  79         }
  80 }
  81
  82 ////////////////////////////////////////////////////////////
  83 // Thread Main
  84 ////////////////////////////////////////////////////////////
  85
  86 void CueSplitter::run()
  87 {
  88         m_bSuccess = false;
  89         m_bAborted = false;
  90         m_abortFlag = false;
  91         m_nTracksSuccess = 0;
  92         m_nTracksSkipped = 0;
  93         m_decompressedFiles.clear();
  94         m_activeFile.clear();
  95
  96         if(!QDir(m_outputDir).exists())
  97         {
  98                 qWarning("Output directory \"%s\" does not exist!", m_outputDir.toUtf8().constData());
  99                 return;
 100         }
 101
 102         QStringList inputFileList = m_inputFilesInfo.keys();
 103         int nInputFiles = inputFileList.count();
 104
 105         //Decompress all input files
 106         for(int i = 0; i < nInputFiles; i++)
 107         {
 108                 AudioFileModel &inputFileInfo = m_inputFilesInfo[inputFileList.at(i)];
 109                 if(inputFileInfo.formatContainerType().compare("Wave", Qt::CaseInsensitive) || inputFileInfo.formatAudioType().compare("PCM", Qt::CaseInsensitive))
 110                 {
 111                         AbstractDecoder *decoder = DecoderRegistry::lookup(inputFileInfo.formatContainerType(), inputFileInfo.formatContainerProfile(), inputFileInfo.formatAudioType(), inputFileInfo.formatAudioProfile(), inputFileInfo.formatAudioVersion());
 112                         if(decoder)
 113                         {
 114                                 m_activeFile = shortName(QFileInfo(inputFileList.at(i)).fileName());
 115                                 emit fileSelected(m_activeFile);
 116                                 QString tempFile = QString("%1/~%2.wav").arg(m_outputDir, lamexp_rand_str());
 117                                 connect(decoder, SIGNAL(statusUpdated(int)), this, SLOT(handleUpdate(int)), Qt::DirectConnection);
 118                                 if(decoder->decode(inputFileList.at(i), tempFile, &m_abortFlag))
 119                                 {
 120                                         m_decompressedFiles.insert(inputFileList.at(i), tempFile);
 121                                         m_tempFiles.append(tempFile);
 122                                 }
 123                                 else
 124                                 {
 125                                         qWarning("Failed to decompress file: <%s>", inputFileList.at(i).toLatin1().constData());
 126                                         lamexp_remove_file(tempFile);
 127                                 }
 128                                 m_activeFile.clear();
 129                                 LAMEXP_DELETE(decoder);
 130                         }
 131                         else
 132                         {
 133                                 qWarning("Unsupported input file: <%s>", inputFileList.at(i).toLatin1().constData());
 134                         }
 135                 }
 136                 else
 137                 {
 138                         m_decompressedFiles.insert(inputFileList.at(i), inputFileList.at(i));
 139                 }
 140                 if(m_abortFlag)
 141                 {
 142                         m_bAborted = true;
 143                         qWarning("The user has requested to abort the process!");
 144                         return;
 145                 }
 146         }
 147
 148         int nFiles = m_model->getFileCount();
 149         QString albumPerformer = m_model->getAlbumPerformer();
 150         QString albumTitle = m_model->getAlbumTitle();
 151
 152         //Now split all files
 153         for(int i = 0; i < nFiles; i++)
 154         {
 155                 int nTracks = m_model->getTrackCount(i);
 156                 QString trackFile = m_model->getFileName(i);
 157                 int maxProgress = 0;
 158
 159                 //Process all tracks
 160                 for(int j = 0; j < nTracks; j++)
 161                 {
 162                         int trackNo = m_model->getTrackNo(i, j);
 163                         double trackOffset = std::numeric_limits<double>::quiet_NaN();
 164                         double trackLength = std::numeric_limits<double>::quiet_NaN();
 165                         m_model->getTrackIndex(i, j, &trackOffset, &trackLength);
 166
 167                         if((trackNo < 0) || _isnan(trackOffset) || _isnan(trackLength))
 168                         {
 169                                 qWarning("Failed to fetch information for track #%d of file #%d!", j, i);
 170                                 continue;
 171                         }
 172
 173                         //Setup meta info
 174                         AudioFileModel trackMetaInfo(QString().sprintf("cue://File%02d/Track%02d", i, j));
 175                         trackMetaInfo.setFileName(m_model->getTrackTitle(i, j));
 176                         trackMetaInfo.setFileArtist(m_model->getTrackPerformer(i, j));
 177                         trackMetaInfo.setFilePosition(trackNo);
 178
 179                         if(!albumTitle.isEmpty())
 180                         {
 181                                 trackMetaInfo.setFileAlbum(albumTitle);
 182                         }
 183                         if(!albumPerformer.isEmpty() && trackMetaInfo.fileArtist().isEmpty())
 184                         {
 185                                 trackMetaInfo.setFileArtist(albumPerformer);
 186                         }
 187                         if(_finite(trackLength))
 188                         {
 189                                 trackMetaInfo.setFileDuration(static_cast<unsigned int>(abs(trackLength)));
 190                         }
 191
 192                         //Generate output file name
 193                         QString trackTitle = trackMetaInfo.fileName().isEmpty() ? QString().sprintf("Track %02d", trackNo) : trackMetaInfo.fileName();
 194                         QString outputFile = QString("%1/[%2] %3 - %4.wav").arg(m_outputDir, QString().sprintf("%02d", trackNo), m_baseName, trackTitle);
 195                         for(int n = 2; QFileInfo(outputFile).exists(); n++)
 196                         {
 197                                 outputFile = QString("%1/[%2] %3 - %4 (%5).wav").arg(m_outputDir, QString().sprintf("%02d", trackNo), m_baseName, trackTitle, QString::number(n));
 198                         }
 199
 200                         //Call split function
 201                         emit fileSelected(shortName(QFileInfo(outputFile).fileName()));
 202                         splitFile(outputFile,  trackNo, trackFile, trackOffset, trackLength, trackMetaInfo, maxProgress);
 203
 204                         if(m_abortFlag)
 205                         {
 206                                 m_bAborted = true;
 207                                 qWarning("The user has requested to abort the process!");
 208                                 return;
 209                         }
 210                 }
 211         }
 212
 213         qDebug("All files were split.\n");
 214         m_bSuccess = true;
 215 }
 216
 217 ////////////////////////////////////////////////////////////
 218 // Slots
 219 ////////////////////////////////////////////////////////////
 220
 221 void CueSplitter::handleUpdate(int progress)
 222 {
 223         emit fileSelected(QString("%1 [%2%]").arg(m_activeFile, QString::number(progress)));
 224 }
 225
 226 ////////////////////////////////////////////////////////////
 227 // Privtae Functions
 228 ////////////////////////////////////////////////////////////
 229
 230 void CueSplitter::splitFile(const QString &output, const int trackNo, const QString &file, const double offset, const double length, const AudioFileModel &metaInfo, int &maxProgress)
 231 {
 232         qDebug("[Track %02d]", trackNo);
 233         qDebug("File: <%s>", file.toUtf8().constData());
 234         qDebug("Offset: <%f> <%s>", offset, indexToString(offset).toLatin1().constData());
 235         qDebug("Length: <%f> <%s>", length, indexToString(length).toLatin1().constData());
 236         qDebug("Artist: <%s>", metaInfo.fileArtist().toUtf8().constData());
 237         qDebug("Title: <%s>", metaInfo.fileName().toUtf8().constData());
 238
 239         if(!m_decompressedFiles.contains(file))
 240         {
 241                 qWarning("Unknown or unsupported input file, skipping!");
 242                 m_nTracksSkipped++;
 243                 return;
 244         }
 245
 246         QString baseName = shortName(QFileInfo(output).fileName());
 247         QString decompressedInput = m_decompressedFiles[file];
 248         qDebug("Input: <%s>", decompressedInput.toUtf8().constData());
 249
 250         emit fileSelected(QString("%1 [%2%]").arg(baseName, QString::number(maxProgress)));
 251
 252         AudioFileModel outFileInfo(metaInfo);
 253         outFileInfo.setFilePath(output);
 254         outFileInfo.setFormatContainerType("Wave");
 255         outFileInfo.setFormatAudioType("PCM");
 256
 257         QStringList args;
 258         args << "-S" << "-V3";
 259         args << "--guard" << "--temp" << ".";
 260         args << QDir::toNativeSeparators(decompressedInput);
 261         args << QDir::toNativeSeparators(output);
 262
 263         //Add trim parameters, if needed
 264         if(_finite(offset))
 265         {
 266                 args << "trim";
 267                 args << indexToString(offset);
 268
 269                 if(_finite(length))
 270                 {
 271                         args << indexToString(length);
 272                 }
 273         }
 274
 275         QRegExp rxProgress("In:(\\d+)(\\.\\d+)*%", Qt::CaseInsensitive);
 276         QRegExp rxChannels("Channels\\s*:\\s*(\\d+)", Qt::CaseInsensitive);
 277         QRegExp rxSamplerate("Sample Rate\\s*:\\s*(\\d+)", Qt::CaseInsensitive);
 278         QRegExp rxPrecision("Precision\\s*:\\s*(\\d+)-bit", Qt::CaseInsensitive);
 279         QRegExp rxDuration("Duration\\s*:\\s*(\\d\\d):(\\d\\d):(\\d\\d).(\\d\\d)", Qt::CaseInsensitive);
 280
 281         QProcess process;
 282         process.setProcessChannelMode(QProcess::MergedChannels);
 283         process.setReadChannel(QProcess::StandardOutput);
 284         process.setWorkingDirectory(m_outputDir);
 285         process.start(m_soxBin, args);
 286
 287         if(!process.waitForStarted())
 288         {
 289                 qWarning("SoX process failed to create!");
 290                 qWarning("Error message: \"%s\"\n", process.errorString().toLatin1().constData());
 291                 process.kill();
 292                 process.waitForFinished(-1);
 293                 m_nTracksSkipped++;
 294                 return;
 295         }
 296
 297         while(process.state() != QProcess::NotRunning)
 298         {
 299                 if(m_abortFlag)
 300                 {
 301                         process.kill();
 302                         qWarning("Process was aborted on user request!");
 303                         break;
 304                 }
 305                 process.waitForReadyRead(m_processTimeoutInterval);
 306                 if(!process.bytesAvailable() && process.state() == QProcess::Running)
 307                 {
 308                         process.kill();
 309                         qWarning("SoX process timed out <-- killing!");
 310                         break;
 311                 }
 312                 while(process.bytesAvailable() > 0)
 313                 {
 314                         QByteArray line = process.readLine();
 315                         QString text = QString::fromUtf8(line.constData()).simplified();
 316                         if(rxProgress.lastIndexIn(text) >= 0)
 317                         {
 318                                 bool ok = false;
 319                                 int progress = rxProgress.cap(1).toInt(&ok);
 320                                 if(ok)
 321                                 {
 322                                         maxProgress = max(maxProgress, progress);
 323                                         emit fileSelected(QString("%1 [%2%]").arg(baseName, QString::number(maxProgress)));
 324                                 }
 325                         }
 326                         else if(rxChannels.lastIndexIn(text) >= 0)
 327                         {
 328                                 bool ok = false;
 329                                 unsigned int channels = rxChannels.cap(1).toUInt(&ok);
 330                                 if(ok) outFileInfo.setFormatAudioChannels(channels);
 331                         }
 332                         else if(rxSamplerate.lastIndexIn(text) >= 0)
 333                         {
 334                                 bool ok = false;
 335                                 unsigned int samplerate = rxSamplerate.cap(1).toUInt(&ok);
 336                                 if(ok) outFileInfo.setFormatAudioSamplerate(samplerate);
 337                         }
 338                         else if(rxPrecision.lastIndexIn(text) >= 0)
 339                         {
 340                                 bool ok = false;
 341                                 unsigned int precision = rxPrecision.cap(1).toUInt(&ok);
 342                                 if(ok) outFileInfo.setFormatAudioBitdepth(precision);
 343                         }
 344                         else if(rxDuration.lastIndexIn(text) >= 0)
 345                         {
 346                                 bool ok1 = false, ok2 = false, ok3 = false;
 347                                 unsigned int hh = rxDuration.cap(1).toUInt(&ok1);
 348                                 unsigned int mm = rxDuration.cap(2).toUInt(&ok2);
 349                                 unsigned int ss = rxDuration.cap(3).toUInt(&ok3);
 350                                 if(ok1 && ok2 && ok3)
 351                                 {
 352                                         unsigned intputLen = (hh * 3600) + (mm * 60) + ss;
 353                                         if(length == std::numeric_limits<double>::infinity())
 354                                         {
 355                                                 qDebug("Duration updated from SoX info!");
 356                                                 int duration = intputLen - static_cast<int>(floor(offset + 0.5));
 357                                                 if(duration < 0) qWarning("Track is out of bounds: Track offset exceeds input file duration!");
 358                                                 outFileInfo.setFileDuration(max(0, duration));
 359                                         }
 360                                         else
 361                                         {
 362                                                 unsigned int trackEnd = static_cast<unsigned int>(floor(offset + 0.5)) + static_cast<unsigned int>(floor(length + 0.5));
 363                                                 if(trackEnd > intputLen) qWarning("Track is out of bounds: End of track exceeds input file duration!");
 364                                         }
 365                                 }
 366                         }
 367                 }
 368         }
 369
 370         process.waitForFinished();
 371         if(process.state() != QProcess::NotRunning)
 372         {
 373                 process.kill();
 374                 process.waitForFinished(-1);
 375         }
 376
 377         if(process.exitStatus() != QProcess::NormalExit || QFileInfo(output).size() == 0)
 378         {
 379                 qWarning("Splitting has failed !!!");
 380                 m_nTracksSkipped++;
 381                 return;
 382         }
 383
 384         emit fileSplit(outFileInfo);
 385         m_nTracksSuccess++;
 386 }
 387
 388 QString CueSplitter::indexToString(const double index) const
 389 {
 390         if(!_finite(index) || (index < 0.0) || (index > 86400.0))
 391         {
 392                 return QString();
 393         }
 394
 395         QTime time = QTime().addMSecs(static_cast<int>(floor(0.5 + (index * 1000.0))));
 396         return time.toString(time.hour() ? "H:mm:ss.zzz" : "m:ss.zzz");
 397 }
 398
 399 QString CueSplitter::shortName(const QString &longName) const
 400 {
 401         static const int maxLen = 54;
 402
 403         if(longName.length() > maxLen)
 404         {
 405                 return QString("%1...%2").arg(longName.left(maxLen/2).trimmed(), longName.right(maxLen/2).trimmed());
 406         }
 407
 408         return longName;
 409 }
 410
 411 ////////////////////////////////////////////////////////////
 412 // EVENTS
 413 ////////////////////////////////////////////////////////////
 414
 415 /*NONE*/