src/Model_CueSheet.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // LameXP - Audio Encoder Front-End
   3 // Copyright (C) 2004-2013 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 "Global.h"
  23 #include "Model_CueSheet.h"
  24 #include "Model_AudioFile.h"
  25 #include "Genres.h"
  26
  27 #include <QApplication>
  28 #include <QDir>
  29 #include <QFileInfo>
  30 #include <QFont>
  31 #include <QTime>
  32 #include <QTextCodec>
  33 #include <QTextStream>
  34 #include <QMutexLocker>
  35
  36 #include <float.h>
  37 #include <limits>
  38
  39 #define UNQUOTE(STR) STR.split("\"",  QString::SkipEmptyParts).first().trimmed()
  40
  41 ////////////////////////////////////////////////////////////
  42 // Helper Classes
  43 ////////////////////////////////////////////////////////////
  44
  45 class CueSheetItem
  46 {
  47 public:
  48         virtual const char* type(void) = 0;
  49         virtual bool isValid(void) { return false; }
  50 };
  51
  52 class CueSheetTrack : public CueSheetItem
  53 {
  54 public:
  55         CueSheetTrack(CueSheetFile *parent, int trackNo)
  56         :
  57                 m_parent(parent)
  58         {
  59                 m_startIndex = std::numeric_limits<double>::quiet_NaN();
  60                 m_duration = std::numeric_limits<double>::infinity();
  61                 m_metaInfo.setPosition(trackNo);
  62         }
  63
  64         //Getter
  65         CueSheetFile *parent(void) { return m_parent; }
  66         double startIndex(void) { return m_startIndex; }
  67         double duration(void) { return m_duration; }
  68         AudioFileModel_MetaInfo &metaInfo(void) { return m_metaInfo; }
  69
  70         //Setter
  71         void setStartIndex(double startIndex) { m_startIndex = startIndex; }
  72         void setDuration(double duration) { m_duration = duration; }
  73
  74         //Misc
  75         virtual bool isValid(void) { return !(_isnan(m_startIndex) || (m_metaInfo.position() == 0)); }
  76         virtual const char* type(void) { return "CueSheetTrack"; }
  77
  78 private:
  79         double m_startIndex;
  80         double m_duration;
  81         AudioFileModel_MetaInfo m_metaInfo;
  82         CueSheetFile *const m_parent;
  83 };
  84
  85 class CueSheetFile : public CueSheetItem
  86 {
  87 public:
  88         CueSheetFile(const QString &fileName) : m_fileName(fileName) {}
  89         ~CueSheetFile(void) { while(!m_tracks.isEmpty()) delete m_tracks.takeLast(); }
  90
  91         //Getter
  92         QString fileName(void) { return m_fileName; }
  93         CueSheetTrack *track(int index) { return m_tracks.at(index); }
  94         int trackCount(void) { return m_tracks.count(); }
  95
  96         //Modifier
  97         void addTrack(CueSheetTrack *track) { m_tracks.append(track); }
  98         void clearTracks(void) { while(!m_tracks.isEmpty()) delete m_tracks.takeLast(); }
  99
 100         //Misc
 101         virtual bool isValid(void) { return m_tracks.count() > 0; }
 102         virtual const char* type(void) { return "CueSheetFile"; }
 103
 104 private:
 105         const QString m_fileName;
 106         QList<CueSheetTrack*> m_tracks;
 107 };
 108
 109 ////////////////////////////////////////////////////////////
 110 // Constructor & Destructor
 111 ////////////////////////////////////////////////////////////
 112
 113 QMutex CueSheetModel::m_mutex(QMutex::Recursive);
 114
 115 CueSheetModel::CueSheetModel()
 116 :
 117         m_fileIcon(":/icons/music.png"),
 118         m_trackIcon(":/icons/control_play_blue.png")
 119 {
 120         /*nothing to do*/
 121 }
 122
 123 CueSheetModel::~CueSheetModel(void)
 124 {
 125         while(!m_files.isEmpty()) delete m_files.takeLast();
 126 }
 127
 128 ////////////////////////////////////////////////////////////
 129 // Model Functions
 130 ////////////////////////////////////////////////////////////
 131
 132 QModelIndex CueSheetModel::index(int row, int column, const QModelIndex &parent) const
 133 {
 134         QMutexLocker lock(&m_mutex);
 135
 136         if(!parent.isValid())
 137         {
 138                 return (row < m_files.count()) ? createIndex(row, column, m_files.at(row)) : QModelIndex();
 139         }
 140
 141         CueSheetItem *parentItem = static_cast<CueSheetItem*>(parent.internalPointer());
 142         if(CueSheetFile *filePtr = dynamic_cast<CueSheetFile*>(parentItem))
 143         {
 144                 return (row < filePtr->trackCount()) ? createIndex(row, column, filePtr->track(row)) : QModelIndex();
 145         }
 146
 147         return QModelIndex();
 148 }
 149
 150 int CueSheetModel::columnCount(const QModelIndex &parent) const
 151 {
 152         QMutexLocker lock(&m_mutex);
 153         return 4;
 154 }
 155
 156 int CueSheetModel::rowCount(const QModelIndex &parent) const
 157 {
 158         QMutexLocker lock(&m_mutex);
 159
 160         if(!parent.isValid())
 161         {
 162                 return m_files.count();
 163         }
 164
 165         CueSheetItem *parentItem = static_cast<CueSheetItem*>(parent.internalPointer());
 166         if(CueSheetFile *filePtr = dynamic_cast<CueSheetFile*>(parentItem))
 167         {
 168                 return filePtr->trackCount();
 169         }
 170
 171         return 0;
 172 }
 173
 174 QModelIndex CueSheetModel::parent(const QModelIndex &child) const
 175 {
 176         QMutexLocker lock(&m_mutex);
 177
 178         if(child.isValid())
 179         {
 180                 CueSheetItem *childItem = static_cast<CueSheetItem*>(child.internalPointer());
 181                 if(CueSheetTrack *trackPtr = dynamic_cast<CueSheetTrack*>(childItem))
 182                 {
 183                         return createIndex(m_files.indexOf(trackPtr->parent()), 0, trackPtr->parent());
 184                 }
 185         }
 186
 187         return QModelIndex();
 188 }
 189
 190 QVariant CueSheetModel::headerData (int section, Qt::Orientation orientation, int role) const
 191 {
 192         QMutexLocker lock(&m_mutex);
 193
 194         if(role == Qt::DisplayRole)
 195         {
 196                 switch(section)
 197                 {
 198                 case 0:
 199                         return tr("No.");
 200                         break;
 201                 case 1:
 202                         return tr("File / Track");
 203                         break;
 204                 case 2:
 205                         return tr("Index");
 206                         break;
 207                 case 3:
 208                         return tr("Duration");
 209                         break;
 210                 default:
 211                         return QVariant();
 212                         break;
 213                 }
 214         }
 215         else
 216         {
 217                 return QVariant();
 218         }
 219 }
 220
 221 QVariant CueSheetModel::data(const QModelIndex &index, int role) const
 222 {
 223         QMutexLocker lock(&m_mutex);
 224
 225         if(role == Qt::DisplayRole)
 226         {
 227                 CueSheetItem *item = reinterpret_cast<CueSheetItem*>(index.internalPointer());
 228
 229                 if(CueSheetFile *filePtr = dynamic_cast<CueSheetFile*>(item))
 230                 {
 231                         switch(index.column())
 232                         {
 233                         case 0:
 234                                 return tr("File %1").arg(QString().sprintf("%02d", index.row() + 1)).append(" ");
 235                                 break;
 236                         case 1:
 237                                 return QFileInfo(filePtr->fileName()).fileName();
 238                                 break;
 239                         default:
 240                                 return QVariant();
 241                                 break;
 242                         }
 243                 }
 244                 else if(CueSheetTrack *trackPtr = dynamic_cast<CueSheetTrack*>(item))
 245                 {
 246                         const AudioFileModel_MetaInfo &trackInfo = trackPtr->metaInfo();
 247                         switch(index.column())
 248                         {
 249                         case 0:
 250                                 return tr("Track %1").arg(QString().sprintf("%02d", trackInfo.position())).append(" ");
 251                                 break;
 252                         case 1:
 253                                 if(!trackInfo.title().isEmpty() && !trackInfo.artist().isEmpty())
 254                                 {
 255                                         return QString("%1 - %2").arg(trackInfo.artist(), trackInfo.title());
 256                                 }
 257                                 else if(!trackInfo.title().isEmpty())
 258                                 {
 259                                         return QString("%1 - %2").arg(tr("Unknown Artist"), trackInfo.title());
 260                                 }
 261                                 else if(!trackInfo.artist().isEmpty())
 262                                 {
 263                                         return QString("%1 - %2").arg(trackInfo.artist(), tr("Unknown Title"));
 264                                 }
 265                                 else
 266                                 {
 267                                         return QString("%1 - %2").arg(tr("Unknown Artist"), tr("Unknown Title"));
 268                                 }
 269                                 break;
 270                         case 2:
 271                                 return indexToString(trackPtr->startIndex());
 272                                 break;
 273                         case 3:
 274                                 return indexToString(trackPtr->duration());
 275                                 break;
 276                         default:
 277                                 return QVariant();
 278                                 break;
 279                         }
 280                 }
 281         }
 282         else if(role == Qt::ToolTipRole)
 283         {
 284                 CueSheetItem *item = reinterpret_cast<CueSheetItem*>(index.internalPointer());
 285
 286                 if(CueSheetFile *filePtr = dynamic_cast<CueSheetFile*>(item))
 287                 {
 288                         return QDir::toNativeSeparators(filePtr->fileName());
 289                 }
 290                 else if(CueSheetTrack *trackPtr = dynamic_cast<CueSheetTrack*>(item))
 291                 {
 292                         return QDir::toNativeSeparators(trackPtr->parent()->fileName());
 293                 }
 294         }
 295         else if(role == Qt::DecorationRole)
 296         {
 297                 if(index.column() == 0)
 298                 {
 299                         CueSheetItem *item = reinterpret_cast<CueSheetItem*>(index.internalPointer());
 300
 301                         if(dynamic_cast<CueSheetFile*>(item))
 302                         {
 303                                 return m_fileIcon;
 304                         }
 305                         else if(dynamic_cast<CueSheetTrack*>(item))
 306                         {
 307                                 return m_trackIcon;
 308                         }
 309                 }
 310         }
 311         else if(role == Qt::FontRole)
 312         {
 313                 QFont font("Monospace");
 314                 font.setStyleHint(QFont::TypeWriter);
 315                 if((index.column() == 1))
 316                 {
 317                         CueSheetItem *item = reinterpret_cast<CueSheetItem*>(index.internalPointer());
 318                         font.setBold(dynamic_cast<CueSheetFile*>(item) != NULL);
 319                 }
 320                 return font;
 321         }
 322         else if(role == Qt::ForegroundRole)
 323         {
 324                 if((index.column() == 1))
 325                 {
 326                         CueSheetItem *item = reinterpret_cast<CueSheetItem*>(index.internalPointer());
 327                         if(CueSheetFile *filePtr = dynamic_cast<CueSheetFile*>(item))
 328                         {
 329                                 return (QFileInfo(filePtr->fileName()).size() > 4) ? QColor("mediumblue") : QColor("darkred");
 330                         }
 331                 }
 332                 else if((index.column() == 3))
 333                 {
 334                         CueSheetItem *item = reinterpret_cast<CueSheetItem*>(index.internalPointer());
 335                         if(CueSheetTrack *trackPtr = dynamic_cast<CueSheetTrack*>(item))
 336                         {
 337                                 if(trackPtr->duration() == std::numeric_limits<double>::infinity())
 338                                 {
 339                                         return QColor("dimgrey");
 340                                 }
 341                         }
 342                 }
 343         }
 344
 345         return QVariant();
 346 }
 347
 348 void CueSheetModel::clearData(void)
 349 {
 350         QMutexLocker lock(&m_mutex);
 351
 352         beginResetModel();
 353         while(!m_files.isEmpty()) delete m_files.takeLast();
 354         endResetModel();
 355 }
 356
 357 ////////////////////////////////////////////////////////////
 358 // External API
 359 ////////////////////////////////////////////////////////////
 360
 361 int CueSheetModel::getFileCount(void)
 362 {
 363         QMutexLocker lock(&m_mutex);
 364         return m_files.count();
 365 }
 366
 367 QString CueSheetModel::getFileName(int fileIndex)
 368 {
 369         QMutexLocker lock(&m_mutex);
 370
 371         if(fileIndex < 0 || fileIndex >= m_files.count())
 372         {
 373                 return QString();
 374         }
 375
 376         return m_files.at(fileIndex)->fileName();
 377 }
 378
 379 int CueSheetModel::getTrackCount(int fileIndex)
 380 {
 381         QMutexLocker lock(&m_mutex);
 382
 383         if(fileIndex < 0 || fileIndex >= m_files.count())
 384         {
 385                 return -1;
 386         }
 387
 388         return m_files.at(fileIndex)->trackCount();
 389 }
 390
 391 const AudioFileModel_MetaInfo *CueSheetModel::getTrackInfo(int fileIndex, int trackIndex)
 392 {
 393         QMutexLocker lock(&m_mutex);
 394
 395         if(fileIndex >= 0 && fileIndex < m_files.count())
 396         {
 397                 CueSheetFile *currentFile = m_files.at(fileIndex);
 398                 if(trackIndex >= 0 && trackIndex < currentFile->trackCount())
 399                 {
 400                         return &currentFile->track(trackIndex)->metaInfo();
 401                 }
 402         }
 403
 404         return NULL;
 405 }
 406
 407 bool CueSheetModel::getTrackIndex(int fileIndex, int trackIndex, double *startIndex, double *duration)
 408 {
 409         QMutexLocker lock(&m_mutex);
 410
 411         *startIndex = std::numeric_limits<double>::quiet_NaN();
 412         *duration = std::numeric_limits<double>::quiet_NaN();
 413
 414         if(fileIndex >= 0 && fileIndex < m_files.count())
 415         {
 416                 CueSheetFile *currentFile = m_files.at(fileIndex);
 417                 if(trackIndex >= 0 && trackIndex < currentFile->trackCount())
 418                 {
 419                         CueSheetTrack *currentTrack = currentFile->track(trackIndex);
 420                         *startIndex = currentTrack->startIndex();
 421                         *duration = currentTrack->duration();
 422                         return true;
 423                 }
 424         }
 425
 426         return false;
 427 }
 428
 429 const AudioFileModel_MetaInfo *CueSheetModel::getAlbumInfo(void)
 430 {
 431         QMutexLocker lock(&m_mutex);
 432         return &m_albumInfo;
 433 }
 434
 435 ////////////////////////////////////////////////////////////
 436 // Cue Sheet Parser
 437 ////////////////////////////////////////////////////////////
 438
 439 int CueSheetModel::loadCueSheet(const QString &cueFileName, QCoreApplication *application, QTextCodec *forceCodec)
 440 {
 441         QMutexLocker lock(&m_mutex);
 442         const QTextCodec *codec = (forceCodec != NULL) ? forceCodec : QTextCodec::codecForName("System");
 443
 444         QFile cueFile(cueFileName);
 445         if(!cueFile.open(QIODevice::ReadOnly))
 446         {
 447                 return ErrorIOFailure;
 448         }
 449
 450         clearData();
 451
 452         beginResetModel();
 453         int iResult = parseCueFile(cueFile, QDir(QFileInfo(cueFile).canonicalPath()), application, codec);
 454         endResetModel();
 455
 456         return iResult;
 457 }
 458
 459 int CueSheetModel::parseCueFile(QFile &cueFile, const QDir &baseDir, QCoreApplication *application, const QTextCodec *codec)
 460 {
 461         cueFile.reset();
 462         qDebug("\n[Cue Sheet Import]");
 463         bool bForceLatin1 = false;
 464
 465         //Reject very large files, as parsing might take until forever
 466         if(cueFile.size() >= 10485760i64)
 467         {
 468                 qWarning("File is very big. Probably not a Cue Sheet. Rejecting...");
 469                 return 2;
 470         }
 471
 472         //Test selected Codepage for decoding errors
 473         qDebug("Character encoding is: %s.", codec->name().constData());
 474         const QString replacementSymbol = QString(QChar(QChar::ReplacementCharacter));
 475         QByteArray testData = cueFile.peek(1048576);
 476         if((!testData.isEmpty()) && codec->toUnicode(testData.constData(), testData.size()).contains(replacementSymbol))
 477         {
 478                 qWarning("Decoding error using selected codepage (%s). Enforcing Latin-1.", codec->name().constData());
 479                 bForceLatin1 = true;
 480         }
 481         testData.clear();
 482
 483         //Init text stream
 484         QTextStream cueStream(&cueFile);
 485         cueStream.setAutoDetectUnicode(false);
 486         cueStream.setCodec(bForceLatin1 ? "latin1" : codec->name());
 487         cueStream.seek(0i64);
 488
 489         //Create regular expressions
 490         QRegExp rxFile("^FILE\\s+(\"[^\"]+\"|\\S+)\\s+(\\w+)$", Qt::CaseInsensitive);
 491         QRegExp rxTrack("^TRACK\\s+(\\d+)\\s(\\w+)$", Qt::CaseInsensitive);
 492         QRegExp rxIndex("^INDEX\\s+(\\d+)\\s+([0-9:]+)$", Qt::CaseInsensitive);
 493         QRegExp rxTitle("^TITLE\\s+(\"[^\"]+\"|\\S+)$", Qt::CaseInsensitive);
 494         QRegExp rxPerformer("^PERFORMER\\s+(\"[^\"]+\"|\\S+)$", Qt::CaseInsensitive);
 495         QRegExp rxGenre("^REM\\s+GENRE\\s+(\"[^\"]+\"|\\S+)$", Qt::CaseInsensitive);
 496         QRegExp rxYear("^REM\\s+DATE\\s+(\\d+)$", Qt::CaseInsensitive);
 497
 498         bool bPreamble = true;
 499         bool bUnsupportedTrack = false;
 500
 501         CueSheetFile *currentFile = NULL;
 502         CueSheetTrack *currentTrack = NULL;
 503
 504         m_albumInfo.reset();
 505
 506         //Loop over the Cue Sheet until all lines were processed
 507         for(int lines = 0; lines < INT_MAX; lines++)
 508         {
 509                 if(application)
 510                 {
 511                         application->processEvents();
 512                         if(lines < 128) lamexp_sleep(10);
 513                 }
 514
 515                 if(cueStream.atEnd())
 516                 {
 517                         qDebug("End of Cue Sheet file.");
 518                         break;
 519                 }
 520
 521                 QString line = cueStream.readLine().trimmed();
 522
 523                 /* --- FILE --- */
 524                 if(rxFile.indexIn(line) >= 0)
 525                 {
 526                         qDebug("%03d File: <%s> <%s>", lines, rxFile.cap(1).toUtf8().constData(), rxFile.cap(2).toUtf8().constData());
 527                         if(currentFile)
 528                         {
 529                                 if(currentTrack)
 530                                 {
 531                                         if(currentTrack->isValid())
 532                                         {
 533                                                 currentFile->addTrack(currentTrack);
 534                                                 currentTrack = NULL;
 535                                         }
 536                                         else
 537                                         {
 538                                                 LAMEXP_DELETE(currentTrack);
 539                                         }
 540                                 }
 541                                 if(currentFile->isValid())
 542                                 {
 543                                         m_files.append(currentFile);
 544                                         currentFile = NULL;
 545                                 }
 546                                 else
 547                                 {
 548                                         LAMEXP_DELETE(currentFile);
 549                                 }
 550                         }
 551                         else
 552                         {
 553                                 LAMEXP_DELETE(currentTrack);
 554                         }
 555                         if(!rxFile.cap(2).compare("WAVE", Qt::CaseInsensitive) || !rxFile.cap(2).compare("MP3", Qt::CaseInsensitive) || !rxFile.cap(2).compare("AIFF", Qt::CaseInsensitive))
 556                         {
 557                                 currentFile = new CueSheetFile(baseDir.absoluteFilePath(UNQUOTE(rxFile.cap(1))));
 558                                 qDebug("%03d File path: <%s>", lines, currentFile->fileName().toUtf8().constData());
 559                         }
 560                         else
 561                         {
 562                                 bUnsupportedTrack = true;
 563                                 qWarning("%03d Skipping unsupported file of type '%s'.", lines, rxFile.cap(2).toUtf8().constData());
 564                                 currentFile = NULL;
 565                         }
 566                         bPreamble = false;
 567                         currentTrack = NULL;
 568                         continue;
 569                 }
 570
 571                 /* --- TRACK --- */
 572                 if(rxTrack.indexIn(line) >= 0)
 573                 {
 574                         if(currentFile)
 575                         {
 576                                 qDebug("%03d   Track: <%s> <%s>", lines, rxTrack.cap(1).toUtf8().constData(), rxTrack.cap(2).toUtf8().constData());
 577                                 if(currentTrack)
 578                                 {
 579                                         if(currentTrack->isValid())
 580                                         {
 581                                                 currentFile->addTrack(currentTrack);
 582                                                 currentTrack = NULL;
 583                                         }
 584                                         else
 585                                         {
 586                                                 LAMEXP_DELETE(currentTrack);
 587                                         }
 588                                 }
 589                                 if(!rxTrack.cap(2).compare("AUDIO", Qt::CaseInsensitive))
 590                                 {
 591                                         currentTrack = new CueSheetTrack(currentFile, rxTrack.cap(1).toInt());
 592                                 }
 593                                 else
 594                                 {
 595                                         bUnsupportedTrack = true;
 596                                         qWarning("%03d   Skipping unsupported track of type '%s'.", lines, rxTrack.cap(2).toUtf8().constData());
 597                                         currentTrack = NULL;
 598                                 }
 599                         }
 600                         else
 601                         {
 602                                 LAMEXP_DELETE(currentTrack);
 603                         }
 604                         bPreamble = false;
 605                         continue;
 606                 }
 607
 608                 /* --- INDEX --- */
 609                 if(rxIndex.indexIn(line) >= 0)
 610                 {
 611                         if(currentFile && currentTrack)
 612                         {
 613                                 qDebug("%03d     Index: <%s> <%s>", lines, rxIndex.cap(1).toUtf8().constData(), rxIndex.cap(2).toUtf8().constData());
 614                                 if(rxIndex.cap(1).toInt() == 1)
 615                                 {
 616                                         currentTrack->setStartIndex(parseTimeIndex(rxIndex.cap(2)));
 617                                 }
 618                         }
 619                         continue;
 620                 }
 621
 622                 /* --- TITLE --- */
 623                 if(rxTitle.indexIn(line) >= 0)
 624                 {
 625                         if(bPreamble)
 626                         {
 627                                 m_albumInfo.setAlbum(UNQUOTE(rxTitle.cap(1)).simplified());
 628                         }
 629                         else if(currentFile && currentTrack)
 630                         {
 631                                 qDebug("%03d     Title: <%s>", lines, rxTitle.cap(1).toUtf8().constData());
 632                                 currentTrack->metaInfo().setTitle(UNQUOTE(rxTitle.cap(1)).simplified());
 633                         }
 634                         continue;
 635                 }
 636
 637                 /* --- PERFORMER --- */
 638                 if(rxPerformer.indexIn(line) >= 0)
 639                 {
 640                         if(bPreamble)
 641                         {
 642                                 m_albumInfo.setArtist(UNQUOTE(rxPerformer.cap(1)).simplified());
 643                         }
 644                         else if(currentFile && currentTrack)
 645                         {
 646                                 qDebug("%03d     Title: <%s>", lines, rxPerformer.cap(1).toUtf8().constData());
 647                                 currentTrack->metaInfo().setArtist(UNQUOTE(rxPerformer.cap(1)).simplified());
 648                         }
 649                         continue;
 650                 }
 651
 652                 /* --- GENRE --- */
 653                 if(rxGenre.indexIn(line) >= 0)
 654                 {
 655                         if(bPreamble)
 656                         {
 657                                 QString temp = UNQUOTE(rxGenre.cap(1)).simplified();
 658                                 for(int i = 0; g_lamexp_generes[i]; i++)
 659                                 {
 660                                         if(temp.compare(g_lamexp_generes[i], Qt::CaseInsensitive) == 0)
 661                                         {
 662                                                 m_albumInfo.setGenre(QString(g_lamexp_generes[i]));
 663                                                 break;
 664                                         }
 665                                 }
 666                         }
 667                         else if(currentFile && currentTrack)
 668                         {
 669                                 qDebug("%03d     Genre: <%s>", lines, rxGenre.cap(1).toUtf8().constData());
 670                                 QString temp = UNQUOTE(rxGenre.cap(1).simplified());
 671                                 for(int i = 0; g_lamexp_generes[i]; i++)
 672                                 {
 673                                         if(temp.compare(g_lamexp_generes[i], Qt::CaseInsensitive) == 0)
 674                                         {
 675                                                 currentTrack->metaInfo().setGenre(QString(g_lamexp_generes[i]));
 676                                                 break;
 677                                         }
 678                                 }
 679                         }
 680                         continue;
 681                 }
 682
 683                 /* --- YEAR --- */
 684                 if(rxYear.indexIn(line) >= 0)
 685                 {
 686                         if(bPreamble)
 687                         {
 688                                 bool ok = false;
 689                                 unsigned int temp = rxYear.cap(1).toUInt(&ok);
 690                                 if(ok) m_albumInfo.setYear(temp);
 691                         }
 692                         else if(currentFile && currentTrack)
 693                         {
 694                                 qDebug("%03d     Year: <%s>", lines, rxPerformer.cap(1).toUtf8().constData());
 695                                 bool ok = false;
 696                                 unsigned int temp = rxYear.cap(1).toUInt(&ok);
 697                                 if(ok) currentTrack->metaInfo().setYear(temp);
 698                         }
 699                         continue;
 700                 }
 701         }
 702
 703         //Append the very last track/file that is still pending
 704         if(currentFile)
 705         {
 706                 if(currentTrack)
 707                 {
 708                         if(currentTrack->isValid())
 709                         {
 710                                 currentFile->addTrack(currentTrack);
 711                                 currentTrack = NULL;
 712                         }
 713                         else
 714                         {
 715                                 LAMEXP_DELETE(currentTrack);
 716                         }
 717                 }
 718                 if(currentFile->isValid())
 719                 {
 720                         m_files.append(currentFile);
 721                         currentFile = NULL;
 722                 }
 723                 else
 724                 {
 725                         LAMEXP_DELETE(currentFile);
 726                 }
 727         }
 728
 729         //Finally calculate duration of each track
 730         int nFiles = m_files.count();
 731         for(int i = 0; i < nFiles; i++)
 732         {
 733                 if(application)
 734                 {
 735                         application->processEvents();
 736                         lamexp_sleep(10);
 737                 }
 738
 739                 CueSheetFile *currentFile = m_files.at(i);
 740                 int nTracks = currentFile->trackCount();
 741                 if(nTracks > 1)
 742                 {
 743                         for(int j = 1; j < nTracks; j++)
 744                         {
 745                                 CueSheetTrack *currentTrack = currentFile->track(j);
 746                                 CueSheetTrack *previousTrack = currentFile->track(j-1);
 747                                 double duration = currentTrack->startIndex() - previousTrack->startIndex();
 748                                 previousTrack->setDuration(qMax(0.0, duration));
 749                         }
 750                 }
 751         }
 752
 753         //Sanity check of track numbers
 754         if(nFiles > 0)
 755         {
 756                 bool hasTracks = false;
 757                 int previousTrackNo = -1;
 758                 bool trackNo[100];
 759                 for(int i = 0; i < 100; i++)
 760                 {
 761                         trackNo[i] = false;
 762                 }
 763
 764                 for(int i = 0; i < nFiles; i++)
 765                 {
 766                         if(application)
 767                         {
 768                                 application->processEvents();
 769                                 lamexp_sleep(10);
 770                         }
 771                         CueSheetFile *currentFile = m_files.at(i);
 772                         int nTracks = currentFile->trackCount();
 773                         if(nTracks > 1)
 774                         {
 775                                 for(int j = 0; j < nTracks; j++)
 776                                 {
 777                                         int currentTrackNo = currentFile->track(j)->metaInfo().position();
 778                                         if(currentTrackNo > 99)
 779                                         {
 780                                                 qWarning("Track #%02d is invalid (maximum is 99), Cue Sheet is inconsistent!", currentTrackNo);
 781                                                 return ErrorInconsistent;
 782                                         }
 783                                         if(currentTrackNo <= previousTrackNo)
 784                                         {
 785                                                 qWarning("Non-increasing track numbers (%02d -> %02d), Cue Sheet is inconsistent!", previousTrackNo, currentTrackNo);
 786                                                 return ErrorInconsistent;
 787                                         }
 788                                         if(trackNo[currentTrackNo])
 789                                         {
 790                                                 qWarning("Track #%02d exists multiple times, Cue Sheet is inconsistent!", currentTrackNo);
 791                                                 return ErrorInconsistent;
 792                                         }
 793                                         trackNo[currentTrackNo] = true;
 794                                         previousTrackNo = currentTrackNo;
 795                                         hasTracks = true;
 796                                 }
 797                         }
 798                 }
 799
 800                 if(!hasTracks)
 801                 {
 802                         qWarning("Could not find at least one valid track in the Cue Sheet!");
 803                         return ErrorInconsistent;
 804                 }
 805
 806                 return ErrorSuccess;
 807         }
 808         else
 809         {
 810                 qWarning("Could not find at least one valid input file in the Cue Sheet!");
 811                 return bUnsupportedTrack ? ErrorUnsupported : ErrorBadFile;
 812         }
 813 }
 814
 815 double CueSheetModel::parseTimeIndex(const QString &index)
 816 {
 817         QRegExp rxTimeIndex("\\s*(\\d+)\\s*:\\s*(\\d+)\\s*:\\s*(\\d+)\\s*");
 818
 819         if(rxTimeIndex.indexIn(index) >= 0)
 820         {
 821                 int min, sec, frm;
 822                 bool minOK, secOK, frmOK;
 823
 824                 min = rxTimeIndex.cap(1).toInt(&minOK);
 825                 sec = rxTimeIndex.cap(2).toInt(&secOK);
 826                 frm = rxTimeIndex.cap(3).toInt(&frmOK);
 827
 828                 if(minOK && secOK && frmOK)
 829                 {
 830                         return static_cast<double>(60 * min) + static_cast<double>(sec) + (static_cast<double>(frm) / 75.0);
 831                 }
 832         }
 833
 834         qWarning("    Bad time index: '%s'", index.toUtf8().constData());
 835         return std::numeric_limits<double>::quiet_NaN();
 836 }
 837
 838 QString CueSheetModel::indexToString(const double index) const
 839 {
 840         if(!_finite(index) || (index < 0.0) || (index > 86400.0))
 841         {
 842                 return QString("??:??.???");
 843         }
 844
 845         QTime time = QTime().addMSecs(static_cast<int>(floor(0.5 + (index * 1000.0))));
 846
 847         if(time.minute() < 100)
 848         {
 849                 return time.toString("mm:ss.zzz");
 850         }
 851         else
 852         {
 853                 return QString("99:99.999");
 854         }
 855 }