src/thread_vapoursynth.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Simple x264 Launcher
   3 // Copyright (C) 2004-2016 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_vapoursynth.h"
  23
  24 //Mutils
  25 #include <MUtils/OSSupport.h>
  26 #include <MUtils/Registry.h>
  27
  28 //Qt
  29 #include <QLibrary>
  30 #include <QEventLoop>
  31 #include <QTimer>
  32 #include <QMutexLocker>
  33 #include <QApplication>
  34 #include <QDir>
  35 #include <QProcess>
  36
  37 //Internal
  38 #include "global.h"
  39 #include "model_sysinfo.h"
  40
  41 //CRT
  42 #include <cassert>
  43
  44 //Static
  45 QMutex VapourSynthCheckThread::m_vpsLock;
  46 QScopedPointer<QFile> VapourSynthCheckThread::m_vpsExePath[2];
  47 QScopedPointer<QFile> VapourSynthCheckThread::m_vpsDllPath[2];
  48
  49 #define VALID_DIR(STR) ((!(STR).isEmpty()) && QDir((STR)).exists())
  50 #define BOOLIFY(X) ((X) ? '1' : '0')
  51
  52 static inline QString &cleanDir(QString &path)
  53 {
  54         if(!path.isEmpty())
  55         {
  56                 path = QDir::fromNativeSeparators(path);
  57                 while(path.endsWith('/'))
  58                 {
  59                         path.chop(1);
  60                 }
  61         }
  62         return path;
  63 }
  64
  65 //-------------------------------------
  66 // External API
  67 //-------------------------------------
  68
  69 bool VapourSynthCheckThread::detect(SysinfoModel *sysinfo)
  70 {
  71         sysinfo->clearVapourSynth();
  72         sysinfo->clearVPSPath();
  73
  74         QMutexLocker lock(&m_vpsLock);
  75
  76         QEventLoop loop;
  77         VapourSynthCheckThread thread;
  78
  79         QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
  80
  81         connect(&thread, SIGNAL(finished()), &loop, SLOT(quit()));
  82         connect(&thread, SIGNAL(terminated()), &loop, SLOT(quit()));
  83
  84         thread.start();
  85         QTimer::singleShot(15000, &loop, SLOT(quit()));
  86
  87         qDebug("VapourSynth thread has been created, please wait...");
  88         loop.exec(QEventLoop::ExcludeUserInputEvents);
  89         qDebug("VapourSynth thread finished.");
  90
  91         QApplication::restoreOverrideCursor();
  92
  93         if(!thread.wait(1000))
  94         {
  95                 qWarning("VapourSynth thread encountered timeout -> probably deadlock!");
  96                 thread.terminate();
  97                 thread.wait();
  98                 return false;
  99         }
 100
 101         if(thread.getException())
 102         {
 103                 qWarning("VapourSynth thread encountered an exception !!!");
 104                 return false;
 105         }
 106
 107         if(thread.getSuccess())
 108         {
 109                 sysinfo->setVapourSynth(SysinfoModel::VapourSynth_X86, thread.getSuccess() & VAPOURSYNTH_X86);
 110                 sysinfo->setVapourSynth(SysinfoModel::VapourSynth_X64, thread.getSuccess() & VAPOURSYNTH_X64);
 111                 sysinfo->setVPSPath(thread.getPath());
 112                 qDebug("VapourSynth support is officially enabled now! [x86=%c, x64=%c]", BOOLIFY(sysinfo->getVapourSynth(SysinfoModel::VapourSynth_X86)), BOOLIFY(sysinfo->getVapourSynth(SysinfoModel::VapourSynth_X64)));
 113         }
 114         else
 115         {
 116                 qWarning("VapourSynth could not be found -> VapourSynth support disabled!");
 117         }
 118
 119         return true;
 120 }
 121
 122 //-------------------------------------
 123 // Thread class
 124 //-------------------------------------
 125
 126 VapourSynthCheckThread::VapourSynthCheckThread(void)
 127 {
 128         m_success &= 0;
 129         m_exception = false;
 130         m_vpsPath.clear();
 131 }
 132
 133 VapourSynthCheckThread::~VapourSynthCheckThread(void)
 134 {
 135 }
 136
 137 void VapourSynthCheckThread::run(void)
 138 {
 139         m_success &= 0;
 140         m_exception = false;
 141         m_vpsPath.clear();
 142
 143         detectVapourSynthPath1(m_success, m_vpsPath, &m_exception);
 144 }
 145
 146 void VapourSynthCheckThread::detectVapourSynthPath1(int &success, QString &path, volatile bool *exception)
 147 {
 148         __try
 149         {
 150                 return detectVapourSynthPath2(success, path, exception);
 151         }
 152         __except(1)
 153         {
 154                 *exception = true;
 155                 qWarning("Unhandled exception error in VapourSynth thread !!!");
 156         }
 157 }
 158
 159 void VapourSynthCheckThread::detectVapourSynthPath2(int &success, QString &path, volatile bool *exception)
 160 {
 161         try
 162         {
 163                 return detectVapourSynthPath3(success, path);
 164         }
 165         catch(...)
 166         {
 167                 *exception = true;
 168                 qWarning("VapourSynth initializdation raised an C++ exception!");
 169         }
 170 }
 171
 172 void VapourSynthCheckThread::detectVapourSynthPath3(int &success, QString &path)
 173 {
 174         success &= 0;
 175         path.clear();
 176
 177         static const char *VPS_REG_KEYS[] =
 178         {
 179                 "SOFTWARE\\VapourSynth",
 180                 "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\VapourSynth_is1",
 181                 NULL
 182         };
 183         static const char *VPS_REG_NAME[] =
 184         {
 185                 "Path",
 186                 "InstallLocation",
 187                 "Inno Setup: App Path",
 188                 NULL
 189         };
 190         static const MUtils::Registry::reg_scope_t REG_SCOPE[3] =
 191         {
 192                 MUtils::Registry::scope_default,
 193                 MUtils::Registry::scope_wow_x32,
 194                 MUtils::Registry::scope_wow_x64
 195         };
 196
 197         //Read VapourSynth path from registry
 198         QString vapoursynthPath;
 199         for(size_t i = 0; VPS_REG_KEYS[i]; i++)
 200         {
 201                 for(size_t j = 0; VPS_REG_NAME[j]; j++)
 202                 {
 203                         for (size_t k = 0; k < 3; k++)
 204                         {
 205                                 QString temp;
 206                                 if (MUtils::Registry::reg_value_read(MUtils::Registry::root_machine, QString::fromLatin1(VPS_REG_KEYS[i]), QString::fromLatin1(VPS_REG_NAME[j]), temp, REG_SCOPE[k]))
 207                                 {
 208                                         temp = cleanDir(temp);
 209                                         if (VALID_DIR(temp))
 210                                         {
 211                                                 vapoursynthPath = temp;
 212                                                 break;
 213                                         }
 214                                 }
 215                         }
 216                         if (!vapoursynthPath.isEmpty())
 217                         {
 218                                 break;
 219                         }
 220                 }
 221                 if (!vapoursynthPath.isEmpty())
 222                 {
 223                         break;
 224                 }
 225         }
 226
 227         //Make sure VapourSynth does exist
 228         if(!VALID_DIR(vapoursynthPath))
 229         {
 230                 qWarning("VapourSynth install path not found -> disable VapouSynth support!");
 231                 return;
 232         }
 233
 234         qDebug("VapourSynth Dir: %s", vapoursynthPath.toUtf8().constData());
 235
 236         //Look for 32-Bit edition of VapourSynth first
 237         QFile *vpsExeFile32, *vpsDllFile32;
 238         if(isVapourSynthComplete(QString("%1/core32").arg(vapoursynthPath), vpsExeFile32, vpsDllFile32))
 239         {
 240                 if(vpsExeFile32 && checkVapourSynth(vpsExeFile32->fileName()))
 241                 {
 242                         success |= VAPOURSYNTH_X86;
 243                         qDebug("VapourSynth 32-Bit edition found!");
 244                         m_vpsExePath[0].reset(vpsExeFile32);
 245                         m_vpsDllPath[0].reset(vpsDllFile32);
 246                 }
 247                 else
 248                 {
 249                         qWarning("VapourSynth 32-Bit edition was found, but version check has failed!");
 250                 }
 251         }
 252         else
 253         {
 254                 qDebug("VapourSynth 32-Bit edition *not* found!");
 255         }
 256
 257         //Look for 64-Bit edition of VapourSynth next
 258         QFile *vpsExeFile64, *vpsDllFile64;
 259         if(isVapourSynthComplete(QString("%1/core64").arg(vapoursynthPath), vpsExeFile64, vpsDllFile64))
 260         {
 261                 if(vpsExeFile64 && checkVapourSynth(vpsExeFile64->fileName()))
 262                 {
 263                         success |= VAPOURSYNTH_X64;
 264                         qDebug("VapourSynth 64-Bit edition found!");
 265                         m_vpsExePath[1].reset(vpsExeFile64);
 266                         m_vpsDllPath[1].reset(vpsDllFile64);
 267                 }
 268                 else
 269                 {
 270                         qWarning("VapourSynth 64-Bit edition was found, but version check has failed!");
 271                 }
 272         }
 273         else
 274         {
 275                 qDebug("VapourSynth 64-Bit edition *not* found!");
 276         }
 277
 278         //Return VapourSynth path
 279         if(success)
 280         {
 281                 path = vapoursynthPath;
 282         }
 283 }
 284
 285 bool VapourSynthCheckThread::isVapourSynthComplete(const QString &vsCorePath, QFile *&vpsExeFile, QFile *&vpsDllFile)
 286 {
 287         bool complete = false;
 288         vpsExeFile = vpsDllFile = NULL;
 289
 290         QFileInfo vpsExeInfo(QString("%1/vspipe.exe"     ).arg(vsCorePath));
 291         QFileInfo vpsDllInfo(QString("%1/vapoursynth.dll").arg(vsCorePath));
 292
 293         qDebug("VapourSynth EXE: %s", vpsExeInfo.absoluteFilePath().toUtf8().constData());
 294         qDebug("VapourSynth DLL: %s", vpsDllInfo.absoluteFilePath().toUtf8().constData());
 295
 296         if(vpsExeInfo.exists() && vpsDllInfo.exists())
 297         {
 298                 vpsExeFile = new QFile(vpsExeInfo.canonicalFilePath());
 299                 vpsDllFile = new QFile(vpsDllInfo.canonicalFilePath());
 300                 if(vpsExeFile->open(QIODevice::ReadOnly) && vpsDllFile->open(QIODevice::ReadOnly))
 301                 {
 302                         complete = MUtils::OS::is_executable_file(vpsExeFile->fileName());
 303                 }
 304         }
 305
 306         if(!complete)
 307         {
 308                 MUTILS_DELETE(vpsExeFile);
 309                 MUTILS_DELETE(vpsDllFile);
 310         }
 311
 312         return complete;
 313 }
 314
 315 bool VapourSynthCheckThread::checkVapourSynth(const QString &vspipePath)
 316 {
 317         QProcess process;
 318         QStringList output;
 319
 320         //Setup process object
 321         process.setWorkingDirectory(QDir::tempPath());
 322         process.setProcessChannelMode(QProcess::MergedChannels);
 323         process.setReadChannel(QProcess::StandardOutput);
 324
 325         //Try to start VSPIPE.EXE
 326         process.start(vspipePath, QStringList() << "--version");
 327         if(!process.waitForStarted())
 328         {
 329                 qWarning("Failed to launch VSPIPE.EXE -> %s", process.errorString().toUtf8().constData());
 330                 return false;
 331         }
 332
 333         //Wait for process to finish
 334         while(process.state() != QProcess::NotRunning)
 335         {
 336                 if(process.waitForReadyRead(12000))
 337                 {
 338                         while(process.canReadLine())
 339                         {
 340                                 output << QString::fromUtf8(process.readLine()).simplified();
 341                         }
 342                         continue;
 343                 }
 344                 if(process.state() != QProcess::NotRunning)
 345                 {
 346                         qWarning("VSPIPE.EXE process encountered a deadlock -> aborting now!");
 347                         break;
 348                 }
 349         }
 350
 351         //Make sure VSPIPE.EXE has terminated!
 352         process.waitForFinished(2500);
 353         if(process.state() != QProcess::NotRunning)
 354         {
 355                 qWarning("VSPIPE.EXE process still running, going to kill it!");
 356                 process.kill();
 357                 process.waitForFinished(-1);
 358         }
 359
 360         //Read pending lines
 361         while(process.canReadLine())
 362         {
 363                 output << QString::fromUtf8(process.readLine()).simplified();
 364         }
 365
 366         //Check exit code
 367         if(process.exitCode() != 0)
 368         {
 369                 qWarning("VSPIPE.EXE failed with code 0x%08X -> disable Vapousynth support!", process.exitCode());
 370                 return false;
 371         }
 372
 373         //Init regular expressions
 374         QRegExp vpsLogo("VapourSynth\\s+Video\\s+Processing\\s+Library");
 375
 376         //Check for version info
 377         bool vapoursynthLogo = false;
 378         for(QStringList::ConstIterator iter = output.constBegin(); iter != output.constEnd(); iter++)
 379         {
 380                 if(vpsLogo.lastIndexIn(*iter) >= 0)
 381                 {
 382                         vapoursynthLogo = true;
 383                         break;
 384                 }
 385         }
 386
 387         //Minimum required version found?
 388         if(vapoursynthLogo)
 389         {
 390                 qDebug("VapourSynth version was detected successfully.");
 391                 return true;
 392         }
 393
 394         //Failed to determine version
 395         qWarning("Failed to determine VapourSynth version!");
 396         return false;
 397 }