Some code refactoring in the "startup" threads.

This commit is contained in:
LoRd_MuldeR 2019-05-09 22:18:44 +02:00
parent af87671309
commit 3c6316df82
9 changed files with 162 additions and 174 deletions

View File

@ -22,7 +22,6 @@
#include "thread_avisynth.h" #include "thread_avisynth.h"
//Qt //Qt
#include <QLibrary>
#include <QEventLoop> #include <QEventLoop>
#include <QTimer> #include <QTimer>
#include <QApplication> #include <QApplication>
@ -43,11 +42,13 @@ static const bool ENABLE_PORTABLE_AVS = true;
QMutex AvisynthCheckThread::m_avsLock; QMutex AvisynthCheckThread::m_avsLock;
QScopedPointer<QFile> AvisynthCheckThread::m_avsDllPath[2]; QScopedPointer<QFile> AvisynthCheckThread::m_avsDllPath[2];
//Helper //-------------------------------------
// Auxilary functions
//-------------------------------------
#define VALID_DIR(STR) ((!(STR).isEmpty()) && QDir((STR)).exists()) #define VALID_DIR(STR) ((!(STR).isEmpty()) && QDir((STR)).exists())
#define BOOLIFY(X) ((X) ? '1' : '0') #define BOOLIFY(X) ((X) ? '1' : '0')
//Utility function
QString AVS_CHECK_BINARY(const SysinfoModel *sysinfo, const bool& x64) QString AVS_CHECK_BINARY(const SysinfoModel *sysinfo, const bool& x64)
{ {
return QString("%1/toolset/%2/avs_check_%2.exe").arg(sysinfo->getAppPath(), (x64 ? "x64": "x86")); return QString("%1/toolset/%2/avs_check_%2.exe").arg(sysinfo->getAppPath(), (x64 ? "x64": "x86"));
@ -58,7 +59,6 @@ class Wow64RedirectionDisabler
public: public:
Wow64RedirectionDisabler(void) Wow64RedirectionDisabler(void)
{ {
m_oldValue = NULL;
m_disabled = MUtils::OS::wow64fsredir_disable(m_oldValue); m_disabled = MUtils::OS::wow64fsredir_disable(m_oldValue);
} }
~Wow64RedirectionDisabler(void) ~Wow64RedirectionDisabler(void)
@ -73,7 +73,7 @@ public:
} }
private: private:
bool m_disabled; bool m_disabled;
void* m_oldValue; uintptr_t m_oldValue;
}; };
//------------------------------------- //-------------------------------------
@ -140,8 +140,7 @@ AvisynthCheckThread::AvisynthCheckThread(const SysinfoModel *const sysinfo)
: :
m_sysinfo(sysinfo) m_sysinfo(sysinfo)
{ {
m_success = false; m_basePath.clear();
m_exception = false;
} }
AvisynthCheckThread::~AvisynthCheckThread(void) AvisynthCheckThread::~AvisynthCheckThread(void)
@ -150,48 +149,19 @@ AvisynthCheckThread::~AvisynthCheckThread(void)
void AvisynthCheckThread::run(void) void AvisynthCheckThread::run(void)
{ {
m_exception = false;
m_success &= 0;
m_basePath.clear(); m_basePath.clear();
StarupThread::run();
detectAvisynthVersion1(m_success, m_basePath, m_sysinfo, &m_exception);
} }
void AvisynthCheckThread::detectAvisynthVersion1(int &success, QString &basePath, const SysinfoModel *const sysinfo, volatile bool *exception) int AvisynthCheckThread::threadMain(void)
{ {
__try int flags = 0;
{
detectAvisynthVersion2(success, basePath, sysinfo, exception);
}
__except(1)
{
*exception = true;
qWarning("Unhandled exception error in Avisynth thread !!!");
}
}
void AvisynthCheckThread::detectAvisynthVersion2(int &success, QString &basePath, const SysinfoModel *const sysinfo, volatile bool *exception)
{
try
{
return detectAvisynthVersion3(success, basePath, sysinfo);
}
catch(...)
{
*exception = true;
qWarning("Avisynth initializdation raised an C++ exception!");
}
}
void AvisynthCheckThread::detectAvisynthVersion3(int &success, QString &basePath, const SysinfoModel *const sysinfo)
{
success &= 0;
QFile *avsPath32; QFile *avsPath32;
if(checkAvisynth(basePath, sysinfo, avsPath32, false)) if(checkAvisynth(m_basePath, m_sysinfo, avsPath32, false))
{ {
m_avsDllPath[0].reset(avsPath32); m_avsDllPath[0].reset(avsPath32);
success |= AVISYNTH_X86; flags |= AVISYNTH_X86;
qDebug("Avisynth 32-Bit edition found!"); qDebug("Avisynth 32-Bit edition found!");
} }
else else
@ -199,13 +169,13 @@ void AvisynthCheckThread::detectAvisynthVersion3(int &success, QString &basePath
qDebug("Avisynth 32-Bit edition *not* found!"); qDebug("Avisynth 32-Bit edition *not* found!");
} }
if(sysinfo->getCPUFeatures(SysinfoModel::CPUFeatures_X64)) if(m_sysinfo->getCPUFeatures(SysinfoModel::CPUFeatures_X64))
{ {
QFile *avsPath64; QFile *avsPath64;
if(checkAvisynth(basePath, sysinfo, avsPath64, true)) if(checkAvisynth(m_basePath, m_sysinfo, avsPath64, true))
{ {
m_avsDllPath[1].reset(avsPath64); m_avsDllPath[1].reset(avsPath64);
success |= AVISYNTH_X64; flags |= AVISYNTH_X64;
qDebug("Avisynth 64-Bit edition found!"); qDebug("Avisynth 64-Bit edition found!");
} }
else else
@ -217,8 +187,14 @@ void AvisynthCheckThread::detectAvisynthVersion3(int &success, QString &basePath
{ {
qWarning("Skipping 64-Bit Avisynth check on non-x64 system!"); qWarning("Skipping 64-Bit Avisynth check on non-x64 system!");
} }
return flags;
} }
//-------------------------------------
// Internal functions
//-------------------------------------
bool AvisynthCheckThread::checkAvisynth(QString &basePath, const SysinfoModel *const sysinfo, QFile *&path, const bool &x64) bool AvisynthCheckThread::checkAvisynth(QString &basePath, const SysinfoModel *const sysinfo, QFile *&path, const bool &x64)
{ {
qDebug("Avisynth %s-Bit support is being tested.", x64 ? "64" : "32"); qDebug("Avisynth %s-Bit support is being tested.", x64 ? "64" : "32");

View File

@ -39,8 +39,6 @@ protected:
AvisynthCheckThread(const SysinfoModel *const sysinfo); AvisynthCheckThread(const SysinfoModel *const sysinfo);
~AvisynthCheckThread(void); ~AvisynthCheckThread(void);
int getSuccess(void) { return m_success; }
bool getException(void) { return m_exception; }
QString getPath(void) { return m_basePath; } QString getPath(void) { return m_basePath; }
typedef enum _AvisynthFlags typedef enum _AvisynthFlags
@ -54,8 +52,6 @@ private slots:
void start(Priority priority = InheritPriority) { QThread::start(priority); } void start(Priority priority = InheritPriority) { QThread::start(priority); }
private: private:
volatile bool m_exception;
int m_success;
QString m_basePath; QString m_basePath;
const SysinfoModel *const m_sysinfo; const SysinfoModel *const m_sysinfo;
@ -65,10 +61,8 @@ private:
//Entry point //Entry point
virtual void run(void); virtual void run(void);
//Functions //Thread main
static void detectAvisynthVersion1(int &success, QString &basePath, const SysinfoModel *const sysinfo, volatile bool *exception); virtual int threadMain(void);
static void detectAvisynthVersion2(int &success, QString &basePath, const SysinfoModel *const sysinfo, volatile bool *exception);
static void detectAvisynthVersion3(int &success, QString &basePath, const SysinfoModel *const sysinfo);
//Internal functions //Internal functions
static bool checkAvisynth(QString &basePath, const SysinfoModel *const sysinfo, QFile *&path, const bool &x64); static bool checkAvisynth(QString &basePath, const SysinfoModel *const sysinfo, QFile *&path, const bool &x64);

View File

@ -48,6 +48,7 @@ QScopedPointer<QFile> BinariesCheckThread::m_binPath[MAX_BINARIES];
//Whatever //Whatever
#define NEXT(X) ((*reinterpret_cast<int*>(&(X)))++) #define NEXT(X) ((*reinterpret_cast<int*>(&(X)))++)
#define SHFL(X) ((*reinterpret_cast<int*>(&(X))) <<= 1) #define SHFL(X) ((*reinterpret_cast<int*>(&(X))) <<= 1)
#define BOOLIFY(X) (!!(X))
//External //External
QString AVS_CHECK_BINARY(const SysinfoModel *sysinfo, const bool& x64); QString AVS_CHECK_BINARY(const SysinfoModel *sysinfo, const bool& x64);
@ -91,7 +92,7 @@ bool BinariesCheckThread::check(const SysinfoModel *const sysinfo, QString *cons
return false; return false;
} }
const bool success = thread.getSuccess(); const bool success = BOOLIFY(thread.getSuccess());
if ((!success) && failedPath) if ((!success) && failedPath)
{ {
*failedPath = thread.getFailedPath(); *failedPath = thread.getFailedPath();
@ -108,7 +109,7 @@ BinariesCheckThread::BinariesCheckThread(const SysinfoModel *const sysinfo)
: :
m_sysinfo(sysinfo) m_sysinfo(sysinfo)
{ {
m_success = m_exception = false; m_failedPath.clear();
} }
BinariesCheckThread::~BinariesCheckThread(void) BinariesCheckThread::~BinariesCheckThread(void)
@ -117,41 +118,12 @@ BinariesCheckThread::~BinariesCheckThread(void)
void BinariesCheckThread::run(void) void BinariesCheckThread::run(void)
{ {
m_success = m_exception = false; m_failedPath.clear();
m_failedPath = QString(); StarupThread::run();
checkBinaries1(m_success, m_failedPath, m_sysinfo, &m_exception);
} }
void BinariesCheckThread::checkBinaries1(volatile bool &success, QString &failedPath, const SysinfoModel *const sysinfo, volatile bool *exception) int BinariesCheckThread::threadMain(void)
{ {
__try
{
checkBinaries2(success, failedPath, sysinfo, exception);
}
__except(1)
{
*exception = true;
qWarning("Unhandled exception error in binaries checker thread !!!");
}
}
void BinariesCheckThread::checkBinaries2(volatile bool &success, QString &failedPath, const SysinfoModel *const sysinfo, volatile bool *exception)
{
try
{
return checkBinaries3(success, failedPath, sysinfo);
}
catch(...)
{
*exception = true;
qWarning("Binaries checker initializdation raised an C++ exception!");
}
}
void BinariesCheckThread::checkBinaries3(volatile bool &success, QString &failedPath, const SysinfoModel *const sysinfo)
{
success = true;
//Create list of all required binary files //Create list of all required binary files
typedef QPair<QString, bool> FileEntry; typedef QPair<QString, bool> FileEntry;
QList<FileEntry> binFiles; QList<FileEntry> binFiles;
@ -165,7 +137,7 @@ void BinariesCheckThread::checkBinaries3(volatile bool &success, QString &failed
const QStringList variants = encInfo.getVariants(); const QStringList variants = encInfo.getVariants();
for (quint32 varntIdx = 0; varntIdx < quint32(variants.count()); ++varntIdx) for (quint32 varntIdx = 0; varntIdx < quint32(variants.count()); ++varntIdx)
{ {
const QStringList dependencies = encInfo.getDependencies(sysinfo, archIdx, varntIdx); const QStringList dependencies = encInfo.getDependencies(m_sysinfo, archIdx, varntIdx);
for (QStringList::ConstIterator iter = dependencies.constBegin(); iter != dependencies.constEnd(); iter++) for (QStringList::ConstIterator iter = dependencies.constBegin(); iter != dependencies.constEnd(); iter++)
{ {
if (!filesSet.contains(*iter)) if (!filesSet.contains(*iter))
@ -174,7 +146,7 @@ void BinariesCheckThread::checkBinaries3(volatile bool &success, QString &failed
binFiles << qMakePair(*iter, true); binFiles << qMakePair(*iter, true);
} }
} }
const QString binary = encInfo.getBinaryPath(sysinfo, archIdx, varntIdx); const QString binary = encInfo.getBinaryPath(m_sysinfo, archIdx, varntIdx);
if (!filesSet.contains(binary)) if (!filesSet.contains(binary))
{ {
filesSet << binary; filesSet << binary;
@ -185,14 +157,14 @@ void BinariesCheckThread::checkBinaries3(volatile bool &success, QString &failed
} }
for(int i = 0; i < 2; i++) for(int i = 0; i < 2; i++)
{ {
binFiles << qMakePair(SourceFactory::getSourceInfo(SourceFactory::SourceType_AVS).getBinaryPath(sysinfo, bool(i)), false); binFiles << qMakePair(SourceFactory::getSourceInfo(SourceFactory::SourceType_AVS).getBinaryPath(m_sysinfo, bool(i)), false);
binFiles << qMakePair(AVS_CHECK_BINARY(sysinfo, bool(i)), false); binFiles << qMakePair(AVS_CHECK_BINARY(m_sysinfo, bool(i)), false);
} }
for(size_t i = 0; UpdaterDialog::BINARIES[i].name; i++) for(size_t i = 0; UpdaterDialog::BINARIES[i].name; i++)
{ {
if(UpdaterDialog::BINARIES[i].exec) if(UpdaterDialog::BINARIES[i].exec)
{ {
binFiles << qMakePair(QString("%1/toolset/common/%2").arg(sysinfo->getAppPath(), QString::fromLatin1(UpdaterDialog::BINARIES[i].name)), false); binFiles << qMakePair(QString("%1/toolset/common/%2").arg(m_sysinfo->getAppPath(), QString::fromLatin1(UpdaterDialog::BINARIES[i].name)), false);
} }
} }
@ -209,20 +181,18 @@ void BinariesCheckThread::checkBinaries3(volatile bool &success, QString &failed
{ {
if (!MUtils::OS::is_executable_file(file->fileName())) if (!MUtils::OS::is_executable_file(file->fileName()))
{ {
failedPath = file->fileName(); m_failedPath = file->fileName();
success = false;
qWarning("Required tool does NOT look like a valid Win32/Win64 binary:\n%s\n", MUTILS_UTF8(file->fileName())); qWarning("Required tool does NOT look like a valid Win32/Win64 binary:\n%s\n", MUTILS_UTF8(file->fileName()));
return; return 0;
} }
} }
else else
{ {
if (!MUtils::OS::is_library_file(file->fileName())) if (!MUtils::OS::is_library_file(file->fileName()))
{ {
failedPath = file->fileName(); m_failedPath = file->fileName();
success = false;
qWarning("Required tool does NOT look like a valid Win32/Win64 library:\n%s\n", MUTILS_UTF8(file->fileName())); qWarning("Required tool does NOT look like a valid Win32/Win64 library:\n%s\n", MUTILS_UTF8(file->fileName()));
return; return 0;
} }
} }
if(currentFile < MAX_BINARIES) if(currentFile < MAX_BINARIES)
@ -234,10 +204,11 @@ void BinariesCheckThread::checkBinaries3(volatile bool &success, QString &failed
} }
else else
{ {
failedPath = file->fileName(); m_failedPath = file->fileName();
success = false;
qWarning("Required tool could not be found or access denied:\n%s\n", MUTILS_UTF8(file->fileName())); qWarning("Required tool could not be found or access denied:\n%s\n", MUTILS_UTF8(file->fileName()));
return; return 0;
} }
} }
return 1;
} }

View File

@ -21,14 +21,16 @@
#pragma once #pragma once
#include <QThread> #include "thread_startup.h"
//Qt
#include <QMutex> #include <QMutex>
class QLibrary; class QLibrary;
class SysinfoModel; class SysinfoModel;
class QFile; class QFile;
class BinariesCheckThread : public QThread class BinariesCheckThread : public StarupThread
{ {
Q_OBJECT Q_OBJECT
@ -39,16 +41,9 @@ protected:
BinariesCheckThread(const SysinfoModel *const sysinfo); BinariesCheckThread(const SysinfoModel *const sysinfo);
~BinariesCheckThread(void); ~BinariesCheckThread(void);
int getSuccess(void) { return m_success; }
bool getException(void) { return m_exception; }
const QString& getFailedPath(void) { return m_failedPath; } const QString& getFailedPath(void) { return m_failedPath; }
private slots:
void start(Priority priority = InheritPriority) { QThread::start(priority); }
private: private:
volatile bool m_exception, m_success;
QString m_failedPath; QString m_failedPath;
const SysinfoModel *const m_sysinfo; const SysinfoModel *const m_sysinfo;
@ -59,8 +54,6 @@ private:
//Entry point //Entry point
virtual void run(void); virtual void run(void);
//Functions //Thread main
static void checkBinaries1(volatile bool &success, QString &failedPath, const SysinfoModel *const sysinfo, volatile bool *exception); virtual int threadMain(void);
static void checkBinaries2(volatile bool &success, QString &failedPath, const SysinfoModel *const sysinfo, volatile bool *exception);
static void checkBinaries3(volatile bool &success, QString &failedPath, const SysinfoModel *const sysinfo);
}; };

View File

@ -29,6 +29,61 @@
#include <QElapsedTimer> #include <QElapsedTimer>
#include <QProcess> #include <QProcess>
//-------------------------------------
// Constructor
//-------------------------------------
StarupThread::StarupThread(void)
{
m_exception = false;
m_success = 0;
}
StarupThread::~StarupThread(void)
{
}
//-------------------------------------
// Thread entry point
//-------------------------------------
void StarupThread::run(void)
{
m_exception = false;
m_success = 0;
runChecked1(this, m_success, &m_exception);
}
void StarupThread::runChecked1(StarupThread *const thread, volatile int &success, volatile bool *exception)
{
__try
{
return runChecked2(thread, success, exception);
}
__except(1)
{
*exception = true;
qWarning("Unhandled exception error in startup thread !!!");
}
}
void StarupThread::runChecked2(StarupThread *const thread, volatile int &success, volatile bool *exception)
{
try
{
success = thread->threadMain();
}
catch(...)
{
*exception = true;
qWarning("Startup thread raised an C++ exception!");
}
}
//-------------------------------------
// Utility functions
//-------------------------------------
QStringList StarupThread::runProcess(const QString &exePath, const QStringList &arguments, const QStringList *const extraPaths) QStringList StarupThread::runProcess(const QString &exePath, const QStringList &arguments, const QStringList *const extraPaths)
{ {
QProcess process; QProcess process;
@ -64,12 +119,20 @@ QStringList StarupThread::runProcess(const QString &exePath, const QStringList &
processOutput << line; processOutput << line;
} }
} }
if (timer.hasExpired(15000)) if ((process.state() != QProcess::NotRunning) && timer.hasExpired(15000))
{
process.waitForFinished(125);
if (process.state() != QProcess::NotRunning)
{ {
qWarning("%s process encountered a deadlock -> aborting now!", MUTILS_UTF8(fileName)); qWarning("%s process encountered a deadlock -> aborting now!", MUTILS_UTF8(fileName));
break; break;
} }
} }
else
{
QThread::yieldCurrentThread(); /*yield*/
}
}
//Make sure process has terminated! //Make sure process has terminated!
process.waitForFinished(1250); process.waitForFinished(1250);

View File

@ -29,6 +29,30 @@ class StarupThread : public QThread
{ {
Q_OBJECT Q_OBJECT
public:
StarupThread(void);
~StarupThread(void);
bool getException(void) { return m_exception; }
int getSuccess(void) { return m_success; }
protected slots:
void start(Priority priority = InheritPriority) { QThread::start(priority); }
protected: protected:
volatile int m_success;
volatile bool m_exception;
//Entry point
virtual void run(void);
//Error handling
static void runChecked1(StarupThread *const thread, volatile int &success, volatile bool *exception);
static void runChecked2(StarupThread *const thread, volatile int &success, volatile bool *exception);
//Thread main
virtual int threadMain(void) = 0;
//Utility functions
static QStringList runProcess(const QString &exePath, const QStringList &args, const QStringList *const extraPaths = NULL); static QStringList runProcess(const QString &exePath, const QStringList &args, const QStringList *const extraPaths = NULL);
}; };

View File

@ -26,7 +26,6 @@
#include <MUtils/Registry.h> #include <MUtils/Registry.h>
//Qt //Qt
#include <QLibrary>
#include <QEventLoop> #include <QEventLoop>
#include <QTimer> #include <QTimer>
#include <QApplication> #include <QApplication>
@ -47,6 +46,10 @@ QMutex VapourSynthCheckThread::m_vpsLock;
QScopedPointer<QFile> VapourSynthCheckThread::m_vpsExePath[2]; QScopedPointer<QFile> VapourSynthCheckThread::m_vpsExePath[2];
QScopedPointer<QFile> VapourSynthCheckThread::m_vpsDllPath[2]; QScopedPointer<QFile> VapourSynthCheckThread::m_vpsDllPath[2];
//-------------------------------------
// Auxilary functions
//-------------------------------------
#define VALID_DIR(STR) ((!(STR).isEmpty()) && QDir((STR)).exists()) #define VALID_DIR(STR) ((!(STR).isEmpty()) && QDir((STR)).exists())
#define BOOLIFY(X) ((X) ? '1' : '0') #define BOOLIFY(X) ((X) ? '1' : '0')
#define VPS_BITNESS(X) (((X) + 1U) * 32U) #define VPS_BITNESS(X) (((X) + 1U) * 32U)
@ -122,13 +125,11 @@ bool VapourSynthCheckThread::detect(SysinfoModel *sysinfo)
} }
//------------------------------------- //-------------------------------------
// Thread class // Thread functions
//------------------------------------- //-------------------------------------
VapourSynthCheckThread::VapourSynthCheckThread(void) VapourSynthCheckThread::VapourSynthCheckThread(void)
{ {
m_success &= 0;
m_exception = false;
m_vpsPath.clear(); m_vpsPath.clear();
} }
@ -138,44 +139,12 @@ VapourSynthCheckThread::~VapourSynthCheckThread(void)
void VapourSynthCheckThread::run(void) void VapourSynthCheckThread::run(void)
{ {
m_success &= 0;
m_exception = false;
m_vpsPath.clear(); m_vpsPath.clear();
StarupThread::run();
detectVapourSynthPath1(m_success, m_vpsPath, &m_exception);
} }
void VapourSynthCheckThread::detectVapourSynthPath1(int &success, QString &path, volatile bool *exception) int VapourSynthCheckThread::threadMain(void)
{ {
__try
{
return detectVapourSynthPath2(success, path, exception);
}
__except(1)
{
*exception = true;
qWarning("Unhandled exception error in VapourSynth thread !!!");
}
}
void VapourSynthCheckThread::detectVapourSynthPath2(int &success, QString &path, volatile bool *exception)
{
try
{
return detectVapourSynthPath3(success, path);
}
catch(...)
{
*exception = true;
qWarning("VapourSynth initializdation raised an C++ exception!");
}
}
void VapourSynthCheckThread::detectVapourSynthPath3(int &success, QString &path)
{
success &= 0;
path.clear();
static const char *VPS_CORE_DIR[] = static const char *VPS_CORE_DIR[] =
{ {
"core32", "core32",
@ -209,6 +178,7 @@ void VapourSynthCheckThread::detectVapourSynthPath3(int &success, QString &path)
}; };
QString vapoursynthPath; QString vapoursynthPath;
int flags = 0;
//Look for "portable" VapourSynth version //Look for "portable" VapourSynth version
if (ENABLE_PORTABLE_VPS) if (ENABLE_PORTABLE_VPS)
@ -267,7 +237,7 @@ void VapourSynthCheckThread::detectVapourSynthPath3(int &success, QString &path)
if(vapoursynthPath.isEmpty()) if(vapoursynthPath.isEmpty())
{ {
qWarning("VapourSynth install path not found -> disable VapouSynth support!"); qWarning("VapourSynth install path not found -> disable VapouSynth support!");
return; return 0;
} }
//Validate the VapourSynth installation now! //Validate the VapourSynth installation now!
@ -279,7 +249,7 @@ void VapourSynthCheckThread::detectVapourSynthPath3(int &success, QString &path)
{ {
if (vpsExeFile && checkVapourSynth(vpsExeFile->fileName())) if (vpsExeFile && checkVapourSynth(vpsExeFile->fileName()))
{ {
success |= VPS_BIT_FLAG[i]; flags |= VPS_BIT_FLAG[i];
qDebug("VapourSynth %u-Bit edition found!", VPS_BITNESS(i)); qDebug("VapourSynth %u-Bit edition found!", VPS_BITNESS(i));
m_vpsExePath[i].reset(vpsExeFile); m_vpsExePath[i].reset(vpsExeFile);
m_vpsDllPath[i].reset(vpsDllFile); m_vpsDllPath[i].reset(vpsDllFile);
@ -296,12 +266,18 @@ void VapourSynthCheckThread::detectVapourSynthPath3(int &success, QString &path)
} }
//Return VapourSynth path //Return VapourSynth path
if(success) if(flags)
{ {
path = vapoursynthPath; m_vpsPath = vapoursynthPath;
} }
return flags;
} }
//-------------------------------------
// Internal functions
//-------------------------------------
bool VapourSynthCheckThread::isVapourSynthComplete(const QString &vsCorePath, QFile *&vpsExeFile, QFile *&vpsDllFile) bool VapourSynthCheckThread::isVapourSynthComplete(const QString &vsCorePath, QFile *&vpsExeFile, QFile *&vpsDllFile)
{ {
bool complete = false; bool complete = false;

View File

@ -37,13 +37,6 @@ public:
static bool detect(SysinfoModel *sysinfo); static bool detect(SysinfoModel *sysinfo);
protected: protected:
VapourSynthCheckThread(void);
~VapourSynthCheckThread(void);
bool getException(void) { return m_exception; }
int getSuccess(void) { return m_success; }
QString getPath(void) { return m_vpsPath; }
typedef enum _VapourSynthFlags typedef enum _VapourSynthFlags
{ {
VAPOURSYNTH_X86 = 0x1, VAPOURSYNTH_X86 = 0x1,
@ -51,12 +44,12 @@ protected:
} }
VapourSynthFlags; VapourSynthFlags;
private slots: VapourSynthCheckThread(void);
void start(Priority priority = InheritPriority) { QThread::start(priority); } ~VapourSynthCheckThread(void);
QString getPath(void) { return m_vpsPath; }
private: private:
volatile bool m_exception;
int m_success;
QString m_vpsPath; QString m_vpsPath;
static QMutex m_vpsLock; static QMutex m_vpsLock;
@ -66,10 +59,8 @@ private:
//Entry point //Entry point
virtual void run(void); virtual void run(void);
//Functions //Thread main
static void detectVapourSynthPath1(int &success, QString &path, volatile bool *exception); virtual int threadMain(void);
static void detectVapourSynthPath2(int &success, QString &path, volatile bool *exception);
static void detectVapourSynthPath3(int &success, QString &path);
//Internal functions //Internal functions
static bool isVapourSynthComplete(const QString &vsCorePath, QFile *&vpsExeFile, QFile *&vpsDllFile); static bool isVapourSynthComplete(const QString &vsCorePath, QFile *&vpsExeFile, QFile *&vpsDllFile);

View File

@ -26,7 +26,7 @@
#define VER_X264_MAJOR 2 #define VER_X264_MAJOR 2
#define VER_X264_MINOR 9 #define VER_X264_MINOR 9
#define VER_X264_PATCH 0 #define VER_X264_PATCH 0
#define VER_X264_BUILD 1154 #define VER_X264_BUILD 1156
#define VER_X264_PORTABLE_EDITION (0) #define VER_X264_PORTABLE_EDITION (0)