src/Thread_Initialization.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_Initialization.h"
  23
  24 #include "LockedFile.h"
  25 #include "Tools.h"
  26
  27 #include <QFileInfo>
  28 #include <QCoreApplication>
  29 #include <QProcess>
  30 #include <QMap>
  31 #include <QDir>
  32 #include <QLibrary>
  33 #include <QResource>
  34 #include <QTime>
  35 #include <QTextStream>
  36
  37 /* helper macros */
  38 #define PRINT_CPU_TYPE(X) case X: qDebug("Selected CPU is: " #X)
  39 static const double g_allowedExtractDelay = 10.0;
  40
  41 ////////////////////////////////////////////////////////////
  42 // Constructor
  43 ////////////////////////////////////////////////////////////
  44
  45 InitializationThread::InitializationThread(const lamexp_cpu_t *cpuFeatures)
  46 {
  47         m_bSuccess = false;
  48         memset(&m_cpuFeatures, 0, sizeof(lamexp_cpu_t));
  49         m_slowIndicator = false;
  50
  51         if(cpuFeatures)
  52         {
  53                 memcpy(&m_cpuFeatures, cpuFeatures, sizeof(lamexp_cpu_t));
  54         }
  55 }
  56
  57 ////////////////////////////////////////////////////////////
  58 // Thread Main
  59 ////////////////////////////////////////////////////////////
  60
  61 void InitializationThread::run()
  62 {
  63         m_bSuccess = false;
  64         bool bCustom = false;
  65         delay();
  66
  67         //CPU type selection
  68         unsigned int cpuSupport = 0;
  69         if(m_cpuFeatures.sse && m_cpuFeatures.sse2 && m_cpuFeatures.intel)
  70         {
  71                 cpuSupport = m_cpuFeatures.x64 ? CPU_TYPE_X64_SSE : CPU_TYPE_X86_SSE;
  72         }
  73         else
  74         {
  75                 cpuSupport = m_cpuFeatures.x64 ? CPU_TYPE_X64_GEN : CPU_TYPE_X86_GEN;
  76         }
  77
  78         //Hack to disable x64 on the Windows 8 Developer Preview
  79         if(cpuSupport & CPU_TYPE_X64_ALL)
  80         {
  81                 DWORD osVerNo = lamexp_get_os_version();
  82                 if((HIWORD(osVerNo) == 6) && (LOWORD(osVerNo) == 2))
  83                 {
  84                         qWarning("Windows 8 (x64) developer preview detected. Going to disable all x64 support!\n");
  85                         cpuSupport = (cpuSupport == CPU_TYPE_X64_SSE) ? CPU_TYPE_X86_SSE : CPU_TYPE_X86_GEN;
  86                 }
  87         }
  88
  89         //Print selected CPU type
  90         switch(cpuSupport)
  91         {
  92                 PRINT_CPU_TYPE(CPU_TYPE_X86_GEN); break;
  93                 PRINT_CPU_TYPE(CPU_TYPE_X86_SSE); break;
  94                 PRINT_CPU_TYPE(CPU_TYPE_X64_GEN); break;
  95                 PRINT_CPU_TYPE(CPU_TYPE_X64_SSE); break;
  96                 default: throw "CPU support undefined!";
  97         }
  98
  99         //Allocate maps
 100         QMap<QString, QString> mapChecksum;
 101         QMap<QString, unsigned int> mapVersion;
 102         QMap<QString, unsigned int> mapCpuType;
 103
 104         //Init properties
 105         for(int i = 0; i < INT_MAX; i++)
 106         {
 107                 if(!g_lamexp_tools[i].pcName && !g_lamexp_tools[i].pcHash && !g_lamexp_tools[i].uiVersion)
 108                 {
 109                         break;
 110                 }
 111                 else if(g_lamexp_tools[i].pcName && g_lamexp_tools[i].pcHash && g_lamexp_tools[i].uiVersion)
 112                 {
 113                         const QString currentTool = QString::fromLatin1(g_lamexp_tools[i].pcName);
 114                         mapChecksum.insert(currentTool, QString::fromLatin1(g_lamexp_tools[i].pcHash));
 115                         mapCpuType.insert(currentTool, g_lamexp_tools[i].uiCpuType);
 116                         mapVersion.insert(currentTool, g_lamexp_tools[i].uiVersion);
 117                 }
 118                 else
 119                 {
 120                         qFatal("Inconsistent checksum data detected. Take care!");
 121                 }
 122         }
 123
 124         QDir toolsDir(":/tools/");
 125         QList<QFileInfo> toolsList = toolsDir.entryInfoList(QStringList("*.*"), QDir::Files, QDir::Name);
 126         QDir appDir = QDir(QCoreApplication::applicationDirPath()).canonicalPath();
 127
 128         QTime timer;
 129         timer.start();
 130
 131         //Extract all files
 132         while(!toolsList.isEmpty())
 133         {
 134                 try
 135                 {
 136                         QFileInfo currentTool = toolsList.takeFirst();
 137                         QString toolName = currentTool.fileName().toLower();
 138                         QString toolShortName = QString("%1.%2").arg(currentTool.baseName().toLower(), currentTool.suffix().toLower());
 139
 140                         QByteArray toolHash = mapChecksum.take(toolName).toLatin1();
 141                         unsigned int toolCpuType = mapCpuType.take(toolName);
 142                         unsigned int toolVersion = mapVersion.take(toolName);
 143
 144                         if(toolHash.size() != 72)
 145                         {
 146                                 throw "The required checksum is missing, take care!";
 147                         }
 148
 149                         if(toolCpuType & cpuSupport)
 150                         {
 151                                 QFileInfo customTool(QString("%1/tools/%2/%3").arg(appDir.canonicalPath(), QString::number(lamexp_version_build()), toolShortName));
 152                                 if(customTool.exists() && customTool.isFile())
 153                                 {
 154                                         bCustom = true;
 155                                         qDebug("Setting up file: %s <- %s", toolShortName.toLatin1().constData(), appDir.relativeFilePath(customTool.canonicalFilePath()).toLatin1().constData());
 156                                         LockedFile *lockedFile = new LockedFile(customTool.canonicalFilePath());
 157                                         lamexp_register_tool(toolShortName, lockedFile, UINT_MAX);
 158                                 }
 159                                 else
 160                                 {
 161                                         qDebug("Extracting file: %s -> %s", toolName.toLatin1().constData(),  toolShortName.toLatin1().constData());
 162                                         LockedFile *lockedFile = new LockedFile(QString(":/tools/%1").arg(toolName), QString("%1/tool_%2").arg(lamexp_temp_folder2(), toolShortName), toolHash);
 163                                         lamexp_register_tool(toolShortName, lockedFile, toolVersion);
 164                                 }
 165                         }
 166                 }
 167                 catch(char *errorMsg)
 168                 {
 169                         qFatal("At least one of the required tools could not be initialized:\n%s", errorMsg);
 170                         return;
 171                 }
 172         }
 173
 174         //Make sure all files were extracted
 175         if(!mapChecksum.isEmpty())
 176         {
 177                 qFatal("At least one required tool could not be found:\n%s", toolsDir.filePath(mapChecksum.keys().first()).toLatin1().constData());
 178                 return;
 179         }
 180
 181         qDebug("All extracted.\n");
 182
 183         //Clean-up
 184         mapChecksum.clear();
 185         mapVersion.clear();
 186         mapCpuType.clear();
 187
 188         //Using any custom tools?
 189         if(bCustom)
 190         {
 191                 qWarning("Warning: Using custom tools, you might encounter unexpected problems!\n");
 192         }
 193
 194         //Check delay
 195         double delayExtract = static_cast<double>(timer.elapsed()) / 1000.0;
 196         if(delayExtract > g_allowedExtractDelay)
 197         {
 198                 m_slowIndicator = true;
 199                 qWarning("Extracting tools took %.3f seconds -> probably slow realtime virus scanner.", delayExtract);
 200                 qWarning("Please report performance problems to your anti-virus developer !!!\n");
 201         }
 202
 203         //Register all translations
 204         initTranslations();
 205
 206         //Look for AAC encoders
 207         initNeroAac();
 208         initFhgAac();
 209         initQAac();
 210
 211         delay();
 212         m_bSuccess = true;
 213 }
 214
 215 ////////////////////////////////////////////////////////////
 216 // PUBLIC FUNCTIONS
 217 ////////////////////////////////////////////////////////////
 218
 219 void InitializationThread::delay(void)
 220 {
 221         const char *temp = "|/-\\";
 222         printf("Thread is doing something important... ?\b", temp[4]);
 223
 224         for(int i = 0; i < 20; i++)
 225         {
 226                 printf("%c\b", temp[i%4]);
 227                 msleep(25);
 228         }
 229
 230         printf("Done\n\n");
 231 }
 232
 233 void InitializationThread::initTranslations(void)
 234 {
 235         //Search for language files
 236         QStringList qmFiles = QDir(":/localization").entryList(QStringList() << "LameXP_??.qm", QDir::Files, QDir::Name);
 237
 238         //Make sure we found at least one translation
 239         if(qmFiles.count() < 1)
 240         {
 241                 qFatal("Could not find any translation files!");
 242                 return;
 243         }
 244
 245         //Add all available translations
 246         while(!qmFiles.isEmpty())
 247         {
 248                 QString langId, langName;
 249                 QString qmFile = qmFiles.takeFirst();
 250                 unsigned int systemId = 0;
 251
 252                 QRegExp langIdExp("LameXP_(\\w\\w)\\.qm", Qt::CaseInsensitive);
 253                 if(langIdExp.indexIn(qmFile) >= 0)
 254                 {
 255                         langId = langIdExp.cap(1).toLower();
 256                         QResource langRes = QResource(QString(":/localization/%1.txt").arg(qmFile));
 257                         if(langRes.isValid() && langRes.size() > 0)
 258                         {
 259                                 QByteArray data = QByteArray::fromRawData(reinterpret_cast<const char*>(langRes.data()), langRes.size());
 260                                 QTextStream stream(&data, QIODevice::ReadOnly);
 261                                 stream.setAutoDetectUnicode(false); stream.setCodec("UTF-8");
 262                                 while(!stream.atEnd())
 263                                 {
 264                                         QStringList langInfo = stream.readLine().simplified().split(",", QString::SkipEmptyParts);
 265                                         if(langInfo.count() == 2)
 266                                         {
 267                                                 systemId = langInfo.at(0).trimmed().toUInt();
 268                                                 langName = langInfo.at(1).trimmed();
 269                                                 break;
 270                                         }
 271                                 }
 272                         }
 273                 }
 274
 275                 if(!(langId.isEmpty() || langName.isEmpty() || systemId == 0))
 276                 {
 277                         if(lamexp_translation_register(langId, qmFile, langName, systemId))
 278                         {
 279                                 qDebug("Registering translation: %s = %s (%u)", qmFile.toUtf8().constData(), langName.toUtf8().constData(), systemId);
 280                         }
 281                         else
 282                         {
 283                                 qWarning("Failed to register: %s", qmFile.toLatin1().constData());
 284                         }
 285                 }
 286         }
 287
 288         qDebug("All registered.\n");
 289 }
 290
 291 void InitializationThread::initNeroAac(void)
 292 {
 293         const QString appPath = QDir(QCoreApplication::applicationDirPath()).canonicalPath();
 294
 295         QFileInfo neroFileInfo[3];
 296         neroFileInfo[0] = QFileInfo(QString("%1/neroAacEnc.exe").arg(appPath));
 297         neroFileInfo[1] = QFileInfo(QString("%1/neroAacDec.exe").arg(appPath));
 298         neroFileInfo[2] = QFileInfo(QString("%1/neroAacTag.exe").arg(appPath));
 299
 300         bool neroFilesFound = true;
 301         for(int i = 0; i < 3; i++)      { if(!neroFileInfo[i].exists()) neroFilesFound = false; }
 302
 303         //Lock the Nero binaries
 304         if(!neroFilesFound)
 305         {
 306                 qDebug("Nero encoder binaries not found -> AAC encoding support will be disabled!\n");
 307                 return;
 308         }
 309
 310         qDebug("Found Nero AAC encoder binary:\n%s\n", neroFileInfo[0].canonicalFilePath().toUtf8().constData());
 311
 312         LockedFile *neroBin[3];
 313         for(int i = 0; i < 3; i++) neroBin[i] = NULL;
 314
 315         try
 316         {
 317                 for(int i = 0; i < 3; i++)
 318                 {
 319                         neroBin[i] = new LockedFile(neroFileInfo[i].canonicalFilePath());
 320                 }
 321         }
 322         catch(...)
 323         {
 324                 for(int i = 0; i < 3; i++) LAMEXP_DELETE(neroBin[i]);
 325                 qWarning("Failed to get excluive lock to Nero encoder binary -> AAC encoding support will be disabled!");
 326                 return;
 327         }
 328
 329         QProcess process;
 330         process.setProcessChannelMode(QProcess::MergedChannels);
 331         process.setReadChannel(QProcess::StandardOutput);
 332         process.start(neroFileInfo[0].canonicalFilePath(), QStringList() << "-help");
 333
 334         if(!process.waitForStarted())
 335         {
 336                 qWarning("Nero process failed to create!");
 337                 qWarning("Error message: \"%s\"\n", process.errorString().toLatin1().constData());
 338                 process.kill();
 339                 process.waitForFinished(-1);
 340                 for(int i = 0; i < 3; i++) LAMEXP_DELETE(neroBin[i]);
 341                 return;
 342         }
 343
 344         unsigned int neroVersion = 0;
 345
 346         while(process.state() != QProcess::NotRunning)
 347         {
 348                 if(!process.waitForReadyRead())
 349                 {
 350                         if(process.state() == QProcess::Running)
 351                         {
 352                                 qWarning("Nero process time out -> killing!");
 353                                 process.kill();
 354                                 process.waitForFinished(-1);
 355                                 for(int i = 0; i < 3; i++) LAMEXP_DELETE(neroBin[i]);
 356                                 return;
 357                         }
 358                 }
 359
 360                 while(process.canReadLine())
 361                 {
 362                         QString line = QString::fromUtf8(process.readLine().constData()).simplified();
 363                         QStringList tokens = line.split(" ", QString::SkipEmptyParts, Qt::CaseInsensitive);
 364                         int index1 = tokens.indexOf("Package");
 365                         int index2 = tokens.indexOf("version:");
 366                         if(index1 >= 0 && index2 >= 0 && index1 + 1 == index2 && index2 < tokens.count() - 1)
 367                         {
 368                                 QStringList versionTokens = tokens.at(index2 + 1).split(".", QString::SkipEmptyParts, Qt::CaseInsensitive);
 369                                 if(versionTokens.count() == 4)
 370                                 {
 371                                         neroVersion = 0;
 372                                         neroVersion += qMin(9, qMax(0, versionTokens.at(3).toInt()));
 373                                         neroVersion += qMin(9, qMax(0, versionTokens.at(2).toInt())) * 10;
 374                                         neroVersion += qMin(9, qMax(0, versionTokens.at(1).toInt())) * 100;
 375                                         neroVersion += qMin(9, qMax(0, versionTokens.at(0).toInt())) * 1000;
 376                                 }
 377                         }
 378                 }
 379         }
 380
 381         if(!(neroVersion > 0))
 382         {
 383                 qWarning("Nero AAC version could not be determined -> AAC encoding support will be disabled!");
 384                 for(int i = 0; i < 3; i++) LAMEXP_DELETE(neroBin[i]);
 385                 return;
 386         }
 387
 388         for(int i = 0; i < 3; i++)
 389         {
 390                 lamexp_register_tool(neroFileInfo[i].fileName(), neroBin[i], neroVersion);
 391         }
 392 }
 393
 394 void InitializationThread::initFhgAac(void)
 395 {
 396         const QString appPath = QDir(QCoreApplication::applicationDirPath()).canonicalPath();
 397
 398         QFileInfo fhgFileInfo[4];
 399         fhgFileInfo[0] = QFileInfo(QString("%1/fhgaacenc.exe").arg(appPath));
 400         fhgFileInfo[1] = QFileInfo(QString("%1/enc_fhgaac.dll").arg(appPath));
 401         fhgFileInfo[2] = QFileInfo(QString("%1/nsutil.dll").arg(appPath));
 402         fhgFileInfo[3] = QFileInfo(QString("%1/libmp4v2.dll").arg(appPath));
 403
 404         bool fhgFilesFound = true;
 405         for(int i = 0; i < 4; i++)      { if(!fhgFileInfo[i].exists()) fhgFilesFound = false; }
 406
 407         //Lock the FhgAacEnc binaries
 408         if(!fhgFilesFound)
 409         {
 410                 qDebug("FhgAacEnc binaries not found -> FhgAacEnc support will be disabled!\n");
 411                 return;
 412         }
 413
 414         qDebug("Found FhgAacEnc cli_exe:\n%s\n", fhgFileInfo[0].canonicalFilePath().toUtf8().constData());
 415         qDebug("Found FhgAacEnc enc_dll:\n%s\n", fhgFileInfo[1].canonicalFilePath().toUtf8().constData());
 416
 417         LockedFile *fhgBin[4];
 418         for(int i = 0; i < 4; i++) fhgBin[i] = NULL;
 419
 420         try
 421         {
 422                 for(int i = 0; i < 4; i++)
 423                 {
 424                         fhgBin[i] = new LockedFile(fhgFileInfo[i].canonicalFilePath());
 425                 }
 426         }
 427         catch(...)
 428         {
 429                 for(int i = 0; i < 4; i++) LAMEXP_DELETE(fhgBin[i]);
 430                 qWarning("Failed to get excluive lock to FhgAacEnc binary -> FhgAacEnc support will be disabled!");
 431                 return;
 432         }
 433
 434         QProcess process;
 435         process.setProcessChannelMode(QProcess::MergedChannels);
 436         process.setReadChannel(QProcess::StandardOutput);
 437         process.start(fhgFileInfo[0].canonicalFilePath(), QStringList() << "--version");
 438
 439         if(!process.waitForStarted())
 440         {
 441                 qWarning("FhgAacEnc process failed to create!");
 442                 qWarning("Error message: \"%s\"\n", process.errorString().toLatin1().constData());
 443                 process.kill();
 444                 process.waitForFinished(-1);
 445                 for(int i = 0; i < 4; i++) LAMEXP_DELETE(fhgBin[i]);
 446                 return;
 447         }
 448
 449         QRegExp fhgAacEncSig("fhgaacenc version (\\d+) by tmkk", Qt::CaseInsensitive);
 450         unsigned int fhgVersion = 0;
 451
 452         while(process.state() != QProcess::NotRunning)
 453         {
 454                 process.waitForReadyRead();
 455                 if(!process.bytesAvailable() && process.state() == QProcess::Running)
 456                 {
 457                         qWarning("FhgAacEnc process time out -> killing!");
 458                         process.kill();
 459                         process.waitForFinished(-1);
 460                         for(int i = 0; i < 4; i++) LAMEXP_DELETE(fhgBin[i]);
 461                         return;
 462                 }
 463                 while(process.bytesAvailable() > 0)
 464                 {
 465                         QString line = QString::fromUtf8(process.readLine().constData()).simplified();
 466                         if(fhgAacEncSig.lastIndexIn(line) >= 0)
 467                         {
 468                                 bool ok = false;
 469                                 unsigned int temp = fhgAacEncSig.cap(1).toUInt(&ok);
 470                                 if(ok) fhgVersion = temp;
 471                         }
 472                 }
 473         }
 474
 475         if(!(fhgVersion > 0))
 476         {
 477                 qWarning("FhgAacEnc version couldn't be determined -> FhgAacEnc support will be disabled!");
 478                 for(int i = 0; i < 4; i++) LAMEXP_DELETE(fhgBin[i]);
 479                 return;
 480         }
 481         else if(fhgVersion < lamexp_toolver_fhgaacenc())
 482         {
 483                 qWarning("FhgAacEnc version is too much outdated -> FhgAacEnc support will be disabled!");
 484                 for(int i = 0; i < 4; i++) LAMEXP_DELETE(fhgBin[i]);
 485                 return;
 486         }
 487
 488         for(int i = 0; i < 4; i++)
 489         {
 490                 lamexp_register_tool(fhgFileInfo[i].fileName(), fhgBin[i], fhgVersion);
 491         }
 492 }
 493
 494 void InitializationThread::initQAac(void)
 495 {
 496         const QString appPath = QDir(QCoreApplication::applicationDirPath()).canonicalPath();
 497
 498         QFileInfo qaacFileInfo[2];
 499         qaacFileInfo[0] = QFileInfo(QString("%1/qaac.exe").arg(appPath));
 500         qaacFileInfo[1] = QFileInfo(QString("%1/libsoxrate.dll").arg(appPath));
 501
 502         bool qaacFilesFound = true;
 503         for(int i = 0; i < 2; i++)      { if(!qaacFileInfo[i].exists()) qaacFilesFound = false; }
 504
 505         //Lock the QAAC binaries
 506         if(!qaacFilesFound)
 507         {
 508                 qDebug("QAAC binaries not found -> QAAC support will be disabled!\n");
 509                 return;
 510         }
 511
 512         qDebug("Found QAAC encoder:\n%s\n", qaacFileInfo[0].canonicalFilePath().toUtf8().constData());
 513
 514         LockedFile *qaacBin[2];
 515         for(int i = 0; i < 2; i++) qaacBin[i] = NULL;
 516
 517         try
 518         {
 519                 for(int i = 0; i < 2; i++)
 520                 {
 521                         qaacBin[i] = new LockedFile(qaacFileInfo[i].canonicalFilePath());
 522                 }
 523         }
 524         catch(...)
 525         {
 526                 for(int i = 0; i < 2; i++) LAMEXP_DELETE(qaacBin[i]);
 527                 qWarning("Failed to get excluive lock to QAAC binary -> QAAC support will be disabled!");
 528                 return;
 529         }
 530
 531         QProcess process;
 532         process.setProcessChannelMode(QProcess::MergedChannels);
 533         process.setReadChannel(QProcess::StandardOutput);
 534         process.start(qaacFileInfo[0].canonicalFilePath(), QStringList() << "--check");
 535
 536         if(!process.waitForStarted())
 537         {
 538                 qWarning("QAAC process failed to create!");
 539                 qWarning("Error message: \"%s\"\n", process.errorString().toLatin1().constData());
 540                 process.kill();
 541                 process.waitForFinished(-1);
 542                 for(int i = 0; i < 2; i++) LAMEXP_DELETE(qaacBin[i]);
 543                 return;
 544         }
 545
 546         QRegExp qaacEncSig("qaac (\\d)\\.(\\d)(\\d)", Qt::CaseInsensitive);
 547         QRegExp coreEncSig("CoreAudioToolbox (\\d)\\.(\\d)\\.(\\d)\\.(\\d)", Qt::CaseInsensitive);
 548         unsigned int qaacVersion = 0;
 549         unsigned int coreVersion = 0;
 550
 551         while(process.state() != QProcess::NotRunning)
 552         {
 553                 process.waitForReadyRead();
 554                 if(!process.bytesAvailable() && process.state() == QProcess::Running)
 555                 {
 556                         qWarning("QAAC process time out -> killing!");
 557                         process.kill();
 558                         process.waitForFinished(-1);
 559                 for(int i = 0; i < 2; i++) LAMEXP_DELETE(qaacBin[i]);
 560                         return;
 561                 }
 562                 while(process.bytesAvailable() > 0)
 563                 {
 564                         QString line = QString::fromUtf8(process.readLine().constData()).simplified();
 565                         if(qaacEncSig.lastIndexIn(line) >= 0)
 566                         {
 567                                 unsigned int tmp[3] = {0, 0, 0};
 568                                 bool ok[3] = {false, false, false};
 569                                 tmp[0] = qaacEncSig.cap(1).toUInt(&ok[0]);
 570                                 tmp[1] = qaacEncSig.cap(2).toUInt(&ok[1]);
 571                                 tmp[2] = qaacEncSig.cap(3).toUInt(&ok[2]);
 572                                 if(ok[0] && ok[1] && ok[2])
 573                                 {
 574                                         qaacVersion = (qBound(0U, tmp[0], 9U) * 100) + (qBound(0U, tmp[1], 9U) * 10) + qBound(0U, tmp[2], 9U);
 575                                 }
 576                         }
 577                         if(coreEncSig.lastIndexIn(line) >= 0)
 578                         {
 579                                 unsigned int tmp[4] = {0, 0, 0, 0};
 580                                 bool ok[4] = {false, false, false, false};
 581                                 tmp[0] = coreEncSig.cap(1).toUInt(&ok[0]);
 582                                 tmp[1] = coreEncSig.cap(2).toUInt(&ok[1]);
 583                                 tmp[2] = coreEncSig.cap(3).toUInt(&ok[2]);
 584                                 tmp[3] = coreEncSig.cap(4).toUInt(&ok[3]);
 585                                 if(ok[0] && ok[1] && ok[2] && ok[3])
 586                                 {
 587                                         coreVersion = (qBound(0U, tmp[0], 9U) * 1000) + (qBound(0U, tmp[1], 9U) * 100) + (qBound(0U, tmp[2], 9U) * 10) + qBound(0U, tmp[3], 9U);
 588                                 }
 589                         }
 590                 }
 591         }
 592
 593         //qDebug("qaac %d, CoreAudioToolbox %d", qaacVersion, coreVersion);
 594
 595         if(!(qaacVersion > 0))
 596         {
 597                 qWarning("QAAC version couldn't be determined -> QAAC support will be disabled!");
 598                 for(int i = 0; i < 2; i++) LAMEXP_DELETE(qaacBin[i]);
 599                 return;
 600         }
 601         else if(qaacVersion < lamexp_toolver_qaacenc())
 602         {
 603                 qWarning("QAAC version is too much outdated (%s) -> QAAC support will be disabled!", lamexp_version2string("v?.??", qaacVersion, "N/A").toLatin1().constData());
 604                 for(int i = 0; i < 2; i++) LAMEXP_DELETE(qaacBin[i]);
 605                 return;
 606         }
 607
 608         if(!(coreVersion > 0))
 609         {
 610                 qWarning("CoreAudioToolbox version couldn't be determined -> QAAC support will be disabled!");
 611                 for(int i = 0; i < 2; i++) LAMEXP_DELETE(qaacBin[i]);
 612                 return;
 613         }
 614         else if(coreVersion < lamexp_toolver_coreaudio())
 615         {
 616                 qWarning("CoreAudioToolbox version is too much outdated (%s) -> QAAC support will be disabled!", lamexp_version2string("v?.?.?.?", coreVersion, "N/A").toLatin1().constData());
 617                 for(int i = 0; i < 2; i++) LAMEXP_DELETE(qaacBin[i]);
 618                 return;
 619         }
 620
 621         lamexp_register_tool(qaacFileInfo[0].fileName(), qaacBin[0], qaacVersion);
 622         lamexp_register_tool(qaacFileInfo[1].fileName(), qaacBin[1], qaacVersion);
 623 }
 624
 625 void InitializationThread::selfTest(void)
 626 {
 627         const unsigned int cpu[4] = {CPU_TYPE_X86_GEN, CPU_TYPE_X86_SSE, CPU_TYPE_X64_GEN, CPU_TYPE_X64_SSE};
 628
 629         for(size_t k = 0; k < 4; k++)
 630         {
 631                 qDebug("[TEST]");
 632                 switch(cpu[k])
 633                 {
 634                         PRINT_CPU_TYPE(CPU_TYPE_X86_GEN); break;
 635                         PRINT_CPU_TYPE(CPU_TYPE_X86_SSE); break;
 636                         PRINT_CPU_TYPE(CPU_TYPE_X64_GEN); break;
 637                         PRINT_CPU_TYPE(CPU_TYPE_X64_SSE); break;
 638                         default: throw "CPU support undefined!";
 639                 }
 640                 int n = 0;
 641                 for(int i = 0; i < INT_MAX; i++)
 642                 {
 643                         if(!g_lamexp_tools[i].pcName && !g_lamexp_tools[i].pcHash && !g_lamexp_tools[i].uiVersion)
 644                         {
 645                                 break;
 646                         }
 647                         if(g_lamexp_tools[i].uiCpuType & cpu[k])
 648                         {
 649                                 qDebug("%02i -> %s", ++n, g_lamexp_tools[i].pcName);
 650                         }
 651                 }
 652                 if(n != 24)
 653                 {
 654                         qFatal("Tool count mismatch !!!");
 655                 }
 656                 qDebug("Done.\n");
 657         }
 658 }
 659
 660 ////////////////////////////////////////////////////////////
 661 // EVENTS
 662 ////////////////////////////////////////////////////////////
 663
 664 /*NONE*/