Muldersoft/Simple-x264-Launcher
Muldersoft/Simple-x264-Launcher
1
0
Fork 0
Code Releases 1 Activity

Some initial work to use the MUtilities library.

Browse Source
This commit is contained in:
LoRd_MuldeR 2015-02-01 16:33:31 +01:00
parent ce6d991d8d
commit 07fdd97f97
23 changed files with 925 additions and 1606 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

145
src/3rd_party/qtmain_win.cpp vendored
View File

@ -1,145 +0,0 @@
// ==========================================================================
// qtmain_win.cpp
// ==========================================================================
//
// This source file is included from Qt v4.8.4, because VS2012 won't link
// with the 'qtmain.lib' from the official Qt v4.8.4 (VS2010) release.
//
// ==========================================================================
/****************************************************************************
**
** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the Windows main function of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:BSD$
** You may use this file under the terms of the BSD license as follows:
**
** "Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are
** met:
** * Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** * Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in
** the documentation and/or other materials provided with the
** distribution.
** * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
** of its contributors may be used to endorse or promote products derived
** from this software without specific prior written permission.
**
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qt_windows.h"
#include "qbytearray.h"
#include "qstring.h"
#include "qvector.h"
/*
This file contains the code in the qtmain library for Windows.
qtmain contains the Windows startup code and is required for
linking to the Qt DLL.
When a Windows application starts, the WinMain function is
invoked. WinMain calls qWinMain in the Qt DLL/library, which
initializes Qt.
*/
QT_BEGIN_NAMESPACE
#if defined(Q_OS_WINCE)
extern void __cdecl qWinMain(HINSTANCE, HINSTANCE, LPSTR, int, int &, QVector<char *> &);
#else
extern void qWinMain(HINSTANCE, HINSTANCE, LPSTR, int, int &, QVector<char *> &);
#endif
QT_END_NAMESPACE
QT_USE_NAMESPACE
#if defined(QT_NEEDS_QMAIN)
int qMain(int, char **);
#define main qMain
#else
#ifdef Q_OS_WINCE
extern "C" int __cdecl main(int, char **);
#else
extern "C" int main(int, char **);
#endif
#endif
/*
WinMain() - Initializes Windows and calls user's startup function main().
NOTE: WinMain() won't be called if the application was linked as a "console"
application.
*/
#ifdef Q_OS_WINCE
int WINAPI WinMain(HINSTANCE instance, HINSTANCE prevInstance, LPWSTR /*wCmdParam*/, int cmdShow)
#else
extern "C"
int APIENTRY WinMain(HINSTANCE instance, HINSTANCE prevInstance, LPSTR /*cmdParamarg*/, int cmdShow)
#endif
{
QByteArray cmdParam = QString::fromWCharArray(GetCommandLine()).toLocal8Bit();
#if defined(Q_OS_WINCE)
wchar_t appName[MAX_PATH];
GetModuleFileName(0, appName, MAX_PATH);
cmdParam.prepend(QString(QLatin1String("\"%1\" ")).arg(QString::fromWCharArray(appName)).toLocal8Bit());
#endif
int argc = 0;
QVector<char *> argv(8);
qWinMain(instance, prevInstance, cmdParam.data(), cmdShow, argc, argv);
#if defined(Q_OS_WINCE)
wchar_t uniqueAppID[MAX_PATH];
GetModuleFileName(0, uniqueAppID, MAX_PATH);
QString uid = QString::fromWCharArray(uniqueAppID).toLower().replace(QLatin1String("\\"), QLatin1String("_"));
// If there exists an other instance of this application
// it will be the owner of a mutex with the unique ID.
HANDLE mutex = CreateMutex(NULL, TRUE, (LPCWSTR)uid.utf16());
if (mutex && ERROR_ALREADY_EXISTS == GetLastError()) {
CloseHandle(mutex);
// The app is already running, so we use the unique
// ID to create a unique messageNo, which is used
// as the registered class name for the windows
// created. Set the first instance's window to the
// foreground, else just terminate.
// Use bitwise 0x01 OR to reactivate window state if
// it was hidden
UINT msgNo = RegisterWindowMessage((LPCWSTR)uid.utf16());
HWND aHwnd = FindWindow((LPCWSTR)QString::number(msgNo).utf16(), 0);
if (aHwnd)
SetForegroundWindow((HWND)(((ULONG)aHwnd) | 0x01));
return 0;
}
#endif // Q_OS_WINCE
int result = main(argc, argv.data());
#if defined(Q_OS_WINCE)
CloseHandle(mutex);
#endif
return result;
}

155
src/cli.cpp
View File

@ -1,155 +0,0 @@
///////////////////////////////////////////////////////////////////////////////
// Simple x264 Launcher
// Copyright (C) 2004-2015 LoRd_MuldeR <MuldeR2@GMX.de>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
// http://www.gnu.org/licenses/gpl-2.0.txt
///////////////////////////////////////////////////////////////////////////////
#pragma once
#include "cli.h"
#include "global.h"
///////////////////////////////////////////////////////////////////////////////
// Pre-defined commands
///////////////////////////////////////////////////////////////////////////////
#define MAKE_ARG(X,Y,Z) { "--"X, (Y), (Z) }
static struct
{
const char *longName;
const int optionCount;
const int identifier;
}
s_parameters[] =
{
MAKE_ARG( "add", 1, CLI_PARAM_ADD_FILE ),
MAKE_ARG( "add-file", 1, CLI_PARAM_ADD_FILE ),
MAKE_ARG( "add-job", 3, CLI_PARAM_ADD_JOB ),
MAKE_ARG( "force-start", 0, CLI_PARAM_FORCE_START ),
MAKE_ARG( "no-force-start", 0, CLI_PARAM_NO_FORCE_START ),
MAKE_ARG( "force-enqueue", 0, CLI_PARAM_FORCE_ENQUEUE ),
MAKE_ARG( "no-force-enqueue", 0, CLI_PARAM_NO_FORCE_ENQUEUE ),
MAKE_ARG( "skip-avisynth-check", 0, CLI_PARAM_SKIP_AVS_CHECK ),
MAKE_ARG( "skip-vapoursynth-check", 0, CLI_PARAM_SKIP_VPS_CHECK ),
MAKE_ARG( "skip-version-checks", 0, CLI_PARAM_SKIP_VERSION_CHECK ),
MAKE_ARG( "no-deadlock-detection", 0, CLI_PARAM_NO_DEADLOCK ),
MAKE_ARG( "no-style", 0, CLI_PARAM_NO_GUI_STYLE ),
MAKE_ARG( "first-run", 0, CLI_PARAM_FIRST_RUN ),
MAKE_ARG( "console", 0, CLI_PARAM_OTHER ),
MAKE_ARG( "no-console", 0, CLI_PARAM_OTHER ),
MAKE_ARG( "force-cpu-no-64bit", 0, CLI_PARAM_OTHER ),
MAKE_ARG( "force-cpu-no-sse", 0, CLI_PARAM_OTHER ),
MAKE_ARG( "force-cpu-no-intel", 0, CLI_PARAM_OTHER ),
{ NULL, 0, 0 }
};
///////////////////////////////////////////////////////////////////////////////
// CLI Parser
///////////////////////////////////////////////////////////////////////////////
CLIParser::CLIParser(const QStringList &args)
:
m_args(args)
{
m_iter = m_args.constBegin();
//Skip the application name, which is expected at args[0]
if(m_iter != m_args.constEnd()) m_iter++;
}
CLIParser::~CLIParser(void)
{
/*Nothing to do*/
}
bool CLIParser::nextOption(int &identifier, QStringList *options)
{
identifier = -1;
if(options) options->clear();
int numOpts = 0;
if(m_iter != m_args.constEnd())
{
const QString current = *(m_iter++);
for(size_t i = 0; s_parameters[i].longName != NULL; i++)
{
if(X264_STRCMP(current, QString::fromLatin1(s_parameters[i].longName)))
{
numOpts = s_parameters[i].optionCount;
identifier = s_parameters[i].identifier;
break;
}
}
if(identifier < 0)
{
qWarning("Invalid command-line option \"%s\" was encountered!", current.toUtf8().constData());
m_iter = m_args.constEnd();
}
}
while((identifier >= 0) && (numOpts > 0))
{
if(m_iter != m_args.constEnd())
{
if(options)
{
*options << *m_iter;
}
m_iter++; numOpts--;
}
else
{
qWarning("Too few arguments for command \"--%s\" specified!", identifier2string(identifier));
break;
}
}
return ((identifier >= 0) && (numOpts <= 0));
}
bool CLIParser::checkFlag(const int &identifier, const QStringList &args)
{
CLIParser parser(args);
int currentId;
while(parser.nextOption(currentId, NULL))
{
if(currentId == identifier)
{
return true;
}
}
return false;
}
const char *CLIParser::identifier2string(const int &identifier)
{
const char *longName = NULL;
for(size_t i = 0; s_parameters[i].longName != NULL; i++)
{
if(s_parameters[i].identifier == identifier)
{
longName = s_parameters[i].longName;
}
}
return longName;
}

48
src/cli.h
View File

@ -27,36 +27,18 @@
// CLI parameter identifiers
///////////////////////////////////////////////////////////////////////////////
static const int CLI_PARAM_ADD_FILE = 0;
static const int CLI_PARAM_ADD_JOB = 1;
static const int CLI_PARAM_FORCE_START = 2;
static const int CLI_PARAM_NO_FORCE_START = 3;
static const int CLI_PARAM_FORCE_ENQUEUE = 4;
static const int CLI_PARAM_NO_FORCE_ENQUEUE = 5;
static const int CLI_PARAM_SKIP_AVS_CHECK = 6;
static const int CLI_PARAM_SKIP_VPS_CHECK = 7;
static const int CLI_PARAM_SKIP_VERSION_CHECK = 8;
static const int CLI_PARAM_NO_DEADLOCK = 9;
static const int CLI_PARAM_NO_GUI_STYLE = 10;
static const int CLI_PARAM_FIRST_RUN = 11;
static const int CLI_PARAM_OTHER = 42;
///////////////////////////////////////////////////////////////////////////////
// CLI Parser
///////////////////////////////////////////////////////////////////////////////
class CLIParser
{
public:
CLIParser(const QStringList &args);
~CLIParser(void);
bool nextOption(int &identifier, QStringList *options = NULL);
static bool checkFlag(const int &identifier, const QStringList &args);
static const char *identifier2string(const int &identifier);
protected:
const QStringList &m_args;
QStringList::ConstIterator m_iter;
};
static const char *const CLI_PARAM_ADD_FILE = "add-file";
static const char *const CLI_PARAM_ADD_JOB = "add-job";
static const char *const CLI_PARAM_FORCE_START = "force-start";
static const char *const CLI_PARAM_FORCE_ENQUEUE = "force-enqueue";
static const char *const CLI_PARAM_SKIP_AVS_CHECK = "skip-avisynth-check";
static const char *const CLI_PARAM_SKIP_VPS_CHECK = "skip-vapoursynth-check";
static const char *const CLI_PARAM_SKIP_VERSION_CHECK = "skip-version-checks";
static const char *const CLI_PARAM_NO_DEADLOCK = "no-deadlock-detection";
static const char *const CLI_PARAM_NO_GUI_STYLE = "no-style";
static const char *const CLI_PARAM_FIRST_RUN = "first-run";
static const char *const CLI_PARAM_CONSOLE_SHOW = "console";
static const char *const CLI_PARAM_CONSOLE_HIDE = "no-console";
static const char *const CLI_PARAM_CPU_NO_64BIT = "force-cpu-no-64bit";
static const char *const CLI_PARAM_CPU_NO_SSE = "force-cpu-no-sse";
static const char *const CLI_PARAM_CPU_NO_INTEL = "force-cpu-no-intel";

407
src/global.cpp
View File

@ -784,6 +784,7 @@ const char *x264_version_arch(void)
/*
* Get CLI arguments
*/
/*
const QStringList &x264_arguments(void)
{
QReadLocker readLock(&g_x264_argv.lock);
@ -814,6 +815,7 @@ const QStringList &x264_arguments(void)
return (*g_x264_argv.list);
}
*/
/*
* Check for portable mode
@ -927,14 +929,17 @@ bool x264_is_prerelease(void)
/*
* CPUID prototype (actual function is in ASM code)
*/
/*
extern "C"
{
void x264_cpu_cpuid(unsigned int op, unsigned int *eax, unsigned int *ebx, unsigned int *ecx, unsigned int *edx);
}
*/
/*
* Detect CPU features
*/
/*
x264_cpu_t x264_detect_cpu_features(const int argc, char **argv)
{
typedef BOOL (WINAPI *IsWow64ProcessFun)(__in HANDLE hProcess, __out PBOOL Wow64Process);
@ -1039,6 +1044,7 @@ x264_cpu_t x264_detect_cpu_features(const int argc, char **argv)
return features;
}
*/
/*
* Verify a specific Windows version
@ -1401,176 +1407,177 @@ bool x264_user_is_admin(void)
/*
* Initialize Qt framework
*/
bool x264_init_qt(int &argc, char **argv)
{
static bool qt_initialized = false;
typedef BOOL (WINAPI *SetDllDirectoryProc)(WCHAR *lpPathName);
const QStringList &arguments = x264_arguments();
//bool x264_init_qt(int &argc, char **argv)
//{
// static bool qt_initialized = false;
// typedef BOOL (WINAPI *SetDllDirectoryProc)(WCHAR *lpPathName);
// const QStringList &arguments = x264_arguments();
//
// //Don't initialized again, if done already
// if(qt_initialized)
// {
// return true;
// }
//
// //Secure DLL loading
// QLibrary kernel32("kernel32.dll");
// if(kernel32.load())
// {
// SetDllDirectoryProc pSetDllDirectory = (SetDllDirectoryProc) kernel32.resolve("SetDllDirectoryW");
// if(pSetDllDirectory != NULL) pSetDllDirectory(L"");
// }
//
// //Extract executable name from argv[] array
// QString executableName = QLatin1String("x264_launcher.exe");
// if(arguments.count() > 0)
// {
// static const char *delimiters = "\\/:?";
// executableName = arguments[0].trimmed();
// for(int i = 0; delimiters[i]; i++)
// {
// int temp = executableName.lastIndexOf(QChar(delimiters[i]));
// if(temp >= 0) executableName = executableName.mid(temp + 1);
// }
// executableName = executableName.trimmed();
// if(executableName.isEmpty())
// {
// executableName = QLatin1String("x264_launcher.exe");
// }
// }
//
// //Check Qt version
//#ifdef QT_BUILD_KEY
// qDebug("Using Qt v%s [%s], %s, %s", qVersion(), QLibraryInfo::buildDate().toString(Qt::ISODate).toLatin1().constData(), (qSharedBuild() ? "DLL" : "Static"), QLibraryInfo::buildKey().toLatin1().constData());
// qDebug("Compiled with Qt v%s [%s], %s\n", QT_VERSION_STR, QT_PACKAGEDATE_STR, QT_BUILD_KEY);
// if(_stricmp(qVersion(), QT_VERSION_STR))
// {
// qFatal("%s", QApplication::tr("Executable '%1' requires Qt v%2, but found Qt v%3.").arg(executableName, QString::fromLatin1(QT_VERSION_STR), QString::fromLatin1(qVersion())).toLatin1().constData());
// return false;
// }
// if(QLibraryInfo::buildKey().compare(QString::fromLatin1(QT_BUILD_KEY), Qt::CaseInsensitive))
// {
// qFatal("%s", QApplication::tr("Executable '%1' was built for Qt '%2', but found Qt '%3'.").arg(executableName, QString::fromLatin1(QT_BUILD_KEY), QLibraryInfo::buildKey()).toLatin1().constData());
// return false;
// }
//#else
// qDebug("Using Qt v%s [%s], %s", qVersion(), QLibraryInfo::buildDate().toString(Qt::ISODate).toLatin1().constData(), (qSharedBuild() ? "DLL" : "Static"));
// qDebug("Compiled with Qt v%s [%s]\n", QT_VERSION_STR, QT_PACKAGEDATE_STR);
//#endif
//
// //Check the Windows version
// const x264_os_version_t &osVersionNo = x264_get_os_version();
// if(osVersionNo < x264_winver_winxp)
// {
// qFatal("%s", QApplication::tr("Executable '%1' requires Windows XP or later.").arg(executableName).toLatin1().constData());
// }
//
// //Check whether we are running on a supported Windows version
// bool runningOnSupportedOSVersion = false;
// for(size_t i = 0; x264_winver_lut[i].version != x264_winver_error; i++)
// {
// if(osVersionNo == x264_winver_lut[i].version)
// {
// runningOnSupportedOSVersion = true;
// qDebug("Running on %s (NT v%u.%u).\n", x264_winver_lut[i].friendlyName, osVersionNo.versionMajor, osVersionNo.versionMinor);
// break;
// }
// }
// if(!runningOnSupportedOSVersion)
// {
// const QString message = QString().sprintf("Running on an unknown WindowsNT-based system (v%u.%u).", osVersionNo.versionMajor, osVersionNo.versionMinor);
// qWarning("%s\n", QUTF8(message));
// MessageBoxW(NULL, QWCHAR(message), L"LameXP", MB_OK | MB_TOPMOST | MB_ICONWARNING);
// }
//
// //Check for compat mode
// if(osVersionNo.overrideFlag && (osVersionNo <= x264_winver_wn100))
// {
// qWarning("Windows compatibility mode detected!");
// if(!arguments.contains("--ignore-compat-mode", Qt::CaseInsensitive))
// {
// qFatal("%s", QApplication::tr("Executable '%1' doesn't support Windows compatibility mode.").arg(executableName).toLatin1().constData());
// return false;
// }
// }
//
// //Check for Wine
// if(x264_detect_wine())
// {
// qWarning("It appears we are running under Wine, unexpected things might happen!\n");
// }
//
// //Set text Codec for locale
// QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8"));
//
// //Create Qt application instance
// QApplication *application = new QApplication(argc, argv);
//
// //Load plugins from application directory
// QCoreApplication::setLibraryPaths(QStringList() << QApplication::applicationDirPath());
// qDebug("Library Path:\n%s\n", QUTF8(QApplication::libraryPaths().first()));
//
// //Create Qt application instance and setup version info
// application->setApplicationName("Simple x264 Launcher");
// application->setApplicationVersion(QString().sprintf("%d.%02d", x264_version_major(), x264_version_minor()));
// application->setOrganizationName("LoRd_MuldeR");
// application->setOrganizationDomain("mulder.at.gg");
// application->setWindowIcon(QIcon(":/icons/movie.ico"));
// application->setEventFilter(x264_event_filter);
//
// //Check for supported image formats
// QList<QByteArray> supportedFormats = QImageReader::supportedImageFormats();
// for(int i = 0; g_x264_imageformats[i]; i++)
// {
// if(!supportedFormats.contains(g_x264_imageformats[i]))
// {
// qFatal("Qt initialization error: QImageIOHandler for '%s' missing!", g_x264_imageformats[i]);
// return false;
// }
// }
//
// //Add default translations
// /*
// QWriteLocker writeLockTranslations(&g_x264_translation.lock);
// if(!g_x264_translation.files) g_x264_translation.files = new QMap<QString, QString>();
// if(!g_x264_translation.names) g_x264_translation.names = new QMap<QString, QString>();
// g_x264_translation.files->insert(X264_DEFAULT_LANGID, "");
// g_x264_translation.names->insert(X264_DEFAULT_LANGID, "English");
// writeLockTranslations.unlock();
// */
//
// //Check for process elevation
// if(x264_process_is_elevated() && (!x264_detect_wine()))
// {
// QMessageBox messageBox(QMessageBox::Warning, "Simple x264 Launcher", "<nobr>Simple x264 Launcher was started with 'elevated' rights, altough it does not need these rights.<br>Running an applications with unnecessary rights is a potential security risk!</nobr>", QMessageBox::NoButton, NULL, Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint | Qt::WindowStaysOnTopHint);
// messageBox.addButton("Quit Program (Recommended)", QMessageBox::NoRole);
// messageBox.addButton("Ignore", QMessageBox::NoRole);
// if(messageBox.exec() == 0)
// {
// return false;
// }
// }
//
// //Update console icon, if a console is attached
//#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
// if(g_x264_console_attached && (!x264_detect_wine()))
// {
// typedef DWORD (__stdcall *SetConsoleIconFun)(HICON);
// QLibrary kernel32("kernel32.dll");
// if(kernel32.load())
// {
// SetConsoleIconFun SetConsoleIconPtr = (SetConsoleIconFun) kernel32.resolve("SetConsoleIcon");
// QPixmap pixmap = QIcon(":/icons/movie.ico").pixmap(16, 16);
// if((SetConsoleIconPtr != NULL) && (!pixmap.isNull())) SetConsoleIconPtr(pixmap.toWinHICON());
// kernel32.unload();
// }
// }
//#endif
//
// //Done
// qt_initialized = true;
// return true;
//}
//Don't initialized again, if done already
if(qt_initialized)
{
return true;
}
//Secure DLL loading
QLibrary kernel32("kernel32.dll");
if(kernel32.load())
{
SetDllDirectoryProc pSetDllDirectory = (SetDllDirectoryProc) kernel32.resolve("SetDllDirectoryW");
if(pSetDllDirectory != NULL) pSetDllDirectory(L"");
}
//Extract executable name from argv[] array
QString executableName = QLatin1String("x264_launcher.exe");
if(arguments.count() > 0)
{
static const char *delimiters = "\\/:?";
executableName = arguments[0].trimmed();
for(int i = 0; delimiters[i]; i++)
{
int temp = executableName.lastIndexOf(QChar(delimiters[i]));
if(temp >= 0) executableName = executableName.mid(temp + 1);
}
executableName = executableName.trimmed();
if(executableName.isEmpty())
{
executableName = QLatin1String("x264_launcher.exe");
}
}
//Check Qt version
#ifdef QT_BUILD_KEY
qDebug("Using Qt v%s [%s], %s, %s", qVersion(), QLibraryInfo::buildDate().toString(Qt::ISODate).toLatin1().constData(), (qSharedBuild() ? "DLL" : "Static"), QLibraryInfo::buildKey().toLatin1().constData());
qDebug("Compiled with Qt v%s [%s], %s\n", QT_VERSION_STR, QT_PACKAGEDATE_STR, QT_BUILD_KEY);
if(_stricmp(qVersion(), QT_VERSION_STR))
{
qFatal("%s", QApplication::tr("Executable '%1' requires Qt v%2, but found Qt v%3.").arg(executableName, QString::fromLatin1(QT_VERSION_STR), QString::fromLatin1(qVersion())).toLatin1().constData());
return false;
}
if(QLibraryInfo::buildKey().compare(QString::fromLatin1(QT_BUILD_KEY), Qt::CaseInsensitive))
{
qFatal("%s", QApplication::tr("Executable '%1' was built for Qt '%2', but found Qt '%3'.").arg(executableName, QString::fromLatin1(QT_BUILD_KEY), QLibraryInfo::buildKey()).toLatin1().constData());
return false;
}
#else
qDebug("Using Qt v%s [%s], %s", qVersion(), QLibraryInfo::buildDate().toString(Qt::ISODate).toLatin1().constData(), (qSharedBuild() ? "DLL" : "Static"));
qDebug("Compiled with Qt v%s [%s]\n", QT_VERSION_STR, QT_PACKAGEDATE_STR);
#endif
//Check the Windows version
const x264_os_version_t &osVersionNo = x264_get_os_version();
if(osVersionNo < x264_winver_winxp)
{
qFatal("%s", QApplication::tr("Executable '%1' requires Windows XP or later.").arg(executableName).toLatin1().constData());
}
//Check whether we are running on a supported Windows version
bool runningOnSupportedOSVersion = false;
for(size_t i = 0; x264_winver_lut[i].version != x264_winver_error; i++)
{
if(osVersionNo == x264_winver_lut[i].version)
{
runningOnSupportedOSVersion = true;
qDebug("Running on %s (NT v%u.%u).\n", x264_winver_lut[i].friendlyName, osVersionNo.versionMajor, osVersionNo.versionMinor);
break;
}
}
if(!runningOnSupportedOSVersion)
{
const QString message = QString().sprintf("Running on an unknown WindowsNT-based system (v%u.%u).", osVersionNo.versionMajor, osVersionNo.versionMinor);
qWarning("%s\n", QUTF8(message));
MessageBoxW(NULL, QWCHAR(message), L"LameXP", MB_OK | MB_TOPMOST | MB_ICONWARNING);
}
//Check for compat mode
if(osVersionNo.overrideFlag && (osVersionNo <= x264_winver_wn100))
{
qWarning("Windows compatibility mode detected!");
if(!arguments.contains("--ignore-compat-mode", Qt::CaseInsensitive))
{
qFatal("%s", QApplication::tr("Executable '%1' doesn't support Windows compatibility mode.").arg(executableName).toLatin1().constData());
return false;
}
}
//Check for Wine
if(x264_detect_wine())
{
qWarning("It appears we are running under Wine, unexpected things might happen!\n");
}
//Set text Codec for locale
QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8"));
//Create Qt application instance
QApplication *application = new QApplication(argc, argv);
//Load plugins from application directory
QCoreApplication::setLibraryPaths(QStringList() << QApplication::applicationDirPath());
qDebug("Library Path:\n%s\n", QUTF8(QApplication::libraryPaths().first()));
//Create Qt application instance and setup version info
application->setApplicationName("Simple x264 Launcher");
application->setApplicationVersion(QString().sprintf("%d.%02d", x264_version_major(), x264_version_minor()));
application->setOrganizationName("LoRd_MuldeR");
application->setOrganizationDomain("mulder.at.gg");
application->setWindowIcon(QIcon(":/icons/movie.ico"));
application->setEventFilter(x264_event_filter);
//Check for supported image formats
QList<QByteArray> supportedFormats = QImageReader::supportedImageFormats();
for(int i = 0; g_x264_imageformats[i]; i++)
{
if(!supportedFormats.contains(g_x264_imageformats[i]))
{
qFatal("Qt initialization error: QImageIOHandler for '%s' missing!", g_x264_imageformats[i]);
return false;
}
}
//Add default translations
/*
QWriteLocker writeLockTranslations(&g_x264_translation.lock);
if(!g_x264_translation.files) g_x264_translation.files = new QMap<QString, QString>();
if(!g_x264_translation.names) g_x264_translation.names = new QMap<QString, QString>();
g_x264_translation.files->insert(X264_DEFAULT_LANGID, "");
g_x264_translation.names->insert(X264_DEFAULT_LANGID, "English");
writeLockTranslations.unlock();
*/
//Check for process elevation
if(x264_process_is_elevated() && (!x264_detect_wine()))
{
QMessageBox messageBox(QMessageBox::Warning, "Simple x264 Launcher", "<nobr>Simple x264 Launcher was started with 'elevated' rights, altough it does not need these rights.<br>Running an applications with unnecessary rights is a potential security risk!</nobr>", QMessageBox::NoButton, NULL, Qt::Dialog | Qt::MSWindowsFixedSizeDialogHint | Qt::WindowStaysOnTopHint);
messageBox.addButton("Quit Program (Recommended)", QMessageBox::NoRole);
messageBox.addButton("Ignore", QMessageBox::NoRole);
if(messageBox.exec() == 0)
{
return false;
}
}
//Update console icon, if a console is attached
#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
if(g_x264_console_attached && (!x264_detect_wine()))
{
typedef DWORD (__stdcall *SetConsoleIconFun)(HICON);
QLibrary kernel32("kernel32.dll");
if(kernel32.load())
{
SetConsoleIconFun SetConsoleIconPtr = (SetConsoleIconFun) kernel32.resolve("SetConsoleIcon");
QPixmap pixmap = QIcon(":/icons/movie.ico").pixmap(16, 16);
if((SetConsoleIconPtr != NULL) && (!pixmap.isNull())) SetConsoleIconPtr(pixmap.toWinHICON());
kernel32.unload();
}
}
#endif
//Done
qt_initialized = true;
return true;
}
/*
* Suspend or resume process
@ -2307,55 +2314,6 @@ void x264_dbg_output_string(const char* format, ...)
#endif //X264_DEBUG
}
/*
* Entry point checks
*/
static DWORD x264_entry_check(void);
static DWORD g_x264_entry_check_result = x264_entry_check();
static DWORD g_x264_entry_check_flag = 0x789E09B2;
static DWORD x264_entry_check(void)
{
volatile DWORD retVal = 0xA199B5AF;
if(g_x264_entry_check_flag != 0x8761F64D)
{
x264_fatal_exit(L"Application initialization has failed, take care!");
}
return retVal;
}
/*
* Application entry point (runs before static initializers)
*/
extern "C"
{
int WinMainCRTStartup(void);
int x264_entry_point(void)
{
if((!X264_DEBUG) && x264_check_for_debugger())
{
x264_fatal_exit(L"Not a debug build. Please unload debugger and try again!");
}
if(g_x264_entry_check_flag != 0x789E09B2)
{
x264_fatal_exit(L"Application initialization has failed, take care!");
}
//Zero *before* constructors are called
X264_ZERO_MEMORY(g_x264_argv);
X264_ZERO_MEMORY(g_x264_os_version);
X264_ZERO_MEMORY(g_x264_portable);
X264_ZERO_MEMORY(g_x264_known_folder);
X264_ZERO_MEMORY(g_x264_temp_folder);
//Make sure we will pass the check
g_x264_entry_check_flag = ~g_x264_entry_check_flag;
//Now initialize the C Runtime library!
return WinMainCRTStartup();
}
}
/*
* Initialize debug thread
*/
@ -2376,6 +2334,19 @@ size_t x264_dbg_private_bytes(void)
#endif //X264_DEBUG
}
/*
* Initialization function
*/
void x264_initialization(void)
{
//Zero *before* constructors are called
X264_ZERO_MEMORY(g_x264_argv);
X264_ZERO_MEMORY(g_x264_os_version);
X264_ZERO_MEMORY(g_x264_portable);
X264_ZERO_MEMORY(g_x264_known_folder);
X264_ZERO_MEMORY(g_x264_temp_folder);
}
/*
* Finalization function
*/

8
src/global.h
View File

@ -41,6 +41,7 @@ enum QtMsgType;
///////////////////////////////////////////////////////////////////////////////
//Types definitions
/*
typedef struct
{
int family;
@ -59,6 +60,7 @@ typedef struct
bool intel;
}
x264_cpu_t;
*/
//OS version number
typedef struct _x264_os_version_t
@ -131,7 +133,7 @@ private:
// GLOBAL FUNCTIONS
///////////////////////////////////////////////////////////////////////////////
const QStringList &x264_arguments(void);
//const QStringList &x264_arguments(void);
bool x264_beep(int beepType);
void x264_blink_window(QWidget *poWindow, unsigned int count, unsigned int delay);
bool x264_bring_process_to_front(const unsigned long pid);
@ -143,13 +145,13 @@ QDate x264_current_date_safe(void);
const QString &x264_data_path(void);
void x264_dbg_output_string(const char* format, ...);
size_t x264_dbg_private_bytes(void);
x264_cpu_t x264_detect_cpu_features(const int argc, char **argv);
//x264_cpu_t x264_detect_cpu_features(const int argc, char **argv);
bool x264_enable_close_button(const QWidget *win, const bool bEnable);
void x264_fatal_exit(const wchar_t* exitMessage, const char* errorBoxMessage = NULL);
void x264_finalization(void);
void x264_init_console(const int argc, char **argv);
void x264_init_process(QProcess &process, const QString &wokringDir, const bool bReplaceTempDir = true);
bool x264_init_qt(int &argc, char **argv);
//bool x264_init_qt(int &argc, char **argv);
bool x264_is_executable(const QString &path);
bool x264_is_prerelease(void);
const QString &x264_known_folder(x264_known_folder_t folder_id);

499
src/ipc.cpp
View File

@ -1,499 +0,0 @@
///////////////////////////////////////////////////////////////////////////////
// Simple x264 Launcher
// Copyright (C) 2004-2015 LoRd_MuldeR <MuldeR2@GMX.de>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
// http://www.gnu.org/licenses/gpl-2.0.txt
///////////////////////////////////////////////////////////////////////////////
#include "ipc.h"
#include "global.h"
#include <QSharedMemory>
#include <QSystemSemaphore>
#include <QMutexLocker>
#include <QStringList>
///////////////////////////////////////////////////////////////////////////////
// Constants
///////////////////////////////////////////////////////////////////////////////
static const size_t MAX_STR_LEN = 1024;
static const size_t MAX_ARG_CNT = 3;
static const size_t MAX_ENTRIES = 16;
static const char *s_key_smemory = "{C10A332B-31F2-4A12-B521-420C7CCFFF1D}";
static const char *s_key_sema_wr = "{E20F7E3B-084F-45CF-8448-EBAF25D21BDD}";
static const char *s_key_sema_rd = "{8B816115-E846-4E2A-9E6B-4DAD400DB93D}";
static const wchar_t *EMPTY_STRING = L"";
static unsigned long TIMEOUT_MS = 12000;
typedef struct
{
size_t versTag;
size_t posRd;
size_t posWr;
size_t counter;
struct
{
int command;
wchar_t args[MAX_ARG_CNT][MAX_STR_LEN];
unsigned int flags;
}
data[MAX_ENTRIES];
}
x264_ipc_t;
static size_t versionTag(void)
{
return ((x264_version_major() & 0xFF) << 24) | ((x264_version_minor() & 0xFF) << 16) | (x264_version_build() & 0xFFFF);
}
#define IS_FIRST_INSTANCE(X) ((X) > 0)
///////////////////////////////////////////////////////////////////////////////
// IPC Base Class
///////////////////////////////////////////////////////////////////////////////
class IPCCore : public QObject
{
friend class IPC;
friend class IPCReceiveThread;
friend class IPCSendThread;
public:
bool initialize(bool &firstInstance);
inline bool isInitialized(void)
{
return (m_initialized >= 0);
}
protected:
IPCCore(void);
~IPCCore(void);
bool popCommand(int &command, QStringList &args, unsigned int &flags);
bool pushCommand(const int &command, const QStringList *args, const unsigned int &flags = 0);
volatile int m_initialized;
QSharedMemory *m_sharedMemory;
QSystemSemaphore *m_semaphoreRd;
QSystemSemaphore *m_semaphoreWr;
};
///////////////////////////////////////////////////////////////////////////////
// Send Thread
///////////////////////////////////////////////////////////////////////////////
IPCSendThread::IPCSendThread(IPCCore *ipc, const int &command, const QStringList &args, const unsigned int &flags)
:
m_ipc(ipc), m_command(command), m_args(&args), m_flags(flags)
{
m_result = false;
}
IPCSendThread::~IPCSendThread(void)
{
/*nothing to do here*/
}
void IPCSendThread::run(void)
{
try
{
m_result = m_ipc->pushCommand(m_command, m_args, m_flags);
}
catch(...)
{
m_result = false;
}
}
///////////////////////////////////////////////////////////////////////////////
// Receive Thread
///////////////////////////////////////////////////////////////////////////////
IPCReceiveThread::IPCReceiveThread(IPCCore *ipc)
:
m_ipc(ipc)
{
m_stopped = false;
}
IPCReceiveThread::~IPCReceiveThread(void)
{
/*nothing to do here*/
}
void IPCReceiveThread::run(void)
{
try
{
receiveLoop();
}
catch(...)
{
qWarning("Exception in IPC receive thread!");
}
}
void IPCReceiveThread::receiveLoop(void)
{
while(!m_stopped)
{
int command;
unsigned int flags;
QStringList args;
if(m_ipc->popCommand(command, args, flags))
{
if(!m_stopped)
{
if((command >= 0) && (command < IPC_OPCODE_MAX))
{
emit receivedCommand(command, args, flags);
}
else
{
qWarning("IPC: Received the unknown opcode %d", command);
}
}
}
else
{
m_stopped = true;
qWarning("IPC: Receive operation has failed -> stopping thread!");
}
}
}
///////////////////////////////////////////////////////////////////////////////
// IPC Core Class
///////////////////////////////////////////////////////////////////////////////
IPCCore::IPCCore(void)
{
m_initialized = -1;
m_sharedMemory = NULL;
m_semaphoreWr = NULL;
m_semaphoreRd = NULL;
}
IPCCore::~IPCCore(void)
{
X264_DELETE(m_sharedMemory);
X264_DELETE(m_semaphoreWr);
X264_DELETE(m_semaphoreRd);
}
bool IPCCore::initialize(bool &firstInstance)
{
firstInstance = false;
if(m_initialized >= 0)
{
firstInstance = IS_FIRST_INSTANCE(m_initialized);
return true;
}
m_semaphoreWr = new QSystemSemaphore(s_key_sema_wr, MAX_ENTRIES);
m_semaphoreRd = new QSystemSemaphore(s_key_sema_rd, 0);
if((m_semaphoreWr->error() != QSystemSemaphore::NoError) || (m_semaphoreRd->error() != QSystemSemaphore::NoError))
{
qWarning("IPC: Failed to created system semaphores!");
return false;
}
m_sharedMemory = new QSharedMemory(s_key_smemory, this);
if(m_sharedMemory->create(sizeof(x264_ipc_t)))
{
x264_ipc_t *memory = (x264_ipc_t*) m_sharedMemory->data();
memset(memory, 0, sizeof(x264_ipc_t)); memory->versTag = versionTag();
m_initialized = 1;
firstInstance = IS_FIRST_INSTANCE(m_initialized);
return true;
}
if(m_sharedMemory->error() == QSharedMemory::AlreadyExists)
{
qDebug("Not the first instance -> attaching to existing shared memory");
if(m_sharedMemory->attach())
{
x264_ipc_t *memory = (x264_ipc_t*) m_sharedMemory->data();
if(memory->versTag != versionTag())
{
qWarning("IPC: Version tag mismatch (0x%08x vs. 0x%08x) detected!", memory->versTag, versionTag());
return false;
}
m_initialized = 0;
firstInstance = IS_FIRST_INSTANCE(m_initialized);
return true;
}
}
qWarning("IPC: Failed to attach to the shared memory!");
return false;
}
bool IPCCore::pushCommand(const int &command, const QStringList *args, const unsigned int &flags)
{
if(m_initialized < 0)
{
THROW("IPC not initialized!");
}
if(!m_semaphoreWr->acquire())
{
qWarning("IPC: Failed to acquire semaphore!");
return false;
}
if(!m_sharedMemory->lock())
{
qWarning("IPC: Failed to lock shared memory!");
return false;
}
bool success = true;
try
{
x264_ipc_t *memory = (x264_ipc_t*) m_sharedMemory->data();
if(memory->counter < MAX_ENTRIES)
{
memory->data[memory->posWr].command = command;
for(int i = 0; i < MAX_ARG_CNT; i++)
{
const wchar_t *current = (args && (i < args->count())) ? ((const wchar_t*)((*args)[i].utf16())) : EMPTY_STRING;
wcsncpy_s(memory->data[memory->posWr].args[i], MAX_STR_LEN, current, _TRUNCATE);
}
memory->data[memory->posWr].flags = flags;
memory->posWr = (memory->posWr + 1) % MAX_ENTRIES;
memory->counter++;
}
else
{
qWarning("IPC: Shared memory is full -> cannot push string!");
success = false;
}
}
catch(...)
{
/*ignore any exception*/
}
m_sharedMemory->unlock();
if(success)
{
m_semaphoreRd->release();
}
return success;
}
bool IPCCore::popCommand(int &command, QStringList &args, unsigned int &flags)
{
command = -1;
flags = 0;
args.clear();
if(m_initialized < 0)
{
THROW("IPC not initialized!");
}
if(!m_semaphoreRd->acquire())
{
qWarning("IPC: Failed to acquire semaphore!");
return false;
}
if(!m_sharedMemory->lock())
{
qWarning("IPC: Failed to lock shared memory!");
return false;
}
bool success = true;
try
{
x264_ipc_t *memory = (x264_ipc_t*) m_sharedMemory->data();
if(memory->counter > 0)
{
command = memory->data[memory->posRd].command;
for(size_t i = 0; i < MAX_ARG_CNT; i++)
{
memory->data[memory->posRd].args[i][MAX_STR_LEN-1] = L'\0';
const QString str = QString::fromUtf16((const ushort*)memory->data[memory->posRd].args[i]);
if(!str.isEmpty()) args << str; else break;
}
flags = memory->data[memory->posRd].flags;
memory->posRd = (memory->posRd + 1) % MAX_ENTRIES;
memory->counter--;
}
else
{
qWarning("IPC: Shared memory is empty -> cannot pop string!");
success = false;
}
}
catch(...)
{
/*ignore any exception*/
}
m_sharedMemory->unlock();
if(success)
{
m_semaphoreWr->release();
}
return success;
}
///////////////////////////////////////////////////////////////////////////////
// IPC Handler Class
///////////////////////////////////////////////////////////////////////////////
IPC::IPC(void)
:
m_mutex(QMutex::Recursive)
{
m_ipcCore = new IPCCore();
m_recvThread = NULL;
}
IPC::~IPC(void)
{
if(m_recvThread && m_recvThread->isRunning())
{
qWarning("Receive thread still running -> terminating!");
m_recvThread->terminate();
m_recvThread->wait();
}
X264_DELETE(m_recvThread);
X264_DELETE(m_ipcCore);
}
bool IPC::initialize(bool &firstInstance)
{
QMutexLocker lock(&m_mutex);
return m_ipcCore->initialize(firstInstance);
}
bool IPC::sendAsync(const int &command, const QStringList &args, const unsigned int &flags)
{
QMutexLocker lock(&m_mutex);
if(!m_ipcCore->isInitialized())
{
qWarning("Error: IPC not initialized yet!");
return false;
}
IPCSendThread sendThread(m_ipcCore, command, args, flags);
sendThread.start();
if(!sendThread.wait(TIMEOUT_MS))
{
qWarning("IPC send operation encountered timeout!");
sendThread.terminate();
sendThread.wait();
return false;
}
return sendThread.result();
}
bool IPC::startListening(void)
{
QMutexLocker lock(&m_mutex);
if(!m_ipcCore->isInitialized())
{
qWarning("Error: IPC not initialized yet!");
return false;
}
if(!m_recvThread)
{
m_recvThread = new IPCReceiveThread(m_ipcCore);
connect(m_recvThread, SIGNAL(receivedCommand(int,QStringList,quint32)), this, SIGNAL(receivedCommand(int,QStringList,quint32)), Qt::QueuedConnection);
}
if(!m_recvThread->isRunning())
{
m_recvThread->start();
}
else
{
qWarning("Receive thread was already running!");
}
return true;
}
bool IPC::stopListening(void)
{
QMutexLocker lock(&m_mutex);
if(!m_ipcCore->isInitialized())
{
qWarning("Error: IPC not initialized yet!");
return false;
}
if(m_recvThread && m_recvThread->isRunning())
{
m_recvThread->stop();
sendAsync(IPC_OPCODE_MAX, QStringList()); //push dummy command to unblock thread!
if(!m_recvThread->wait(TIMEOUT_MS))
{
qWarning("Receive thread seems deadlocked -> terminating!");
m_recvThread->terminate();
m_recvThread->wait();
}
}
else
{
qWarning("Receive thread was not running!");
}
return true;
}
bool IPC::isInitialized(void)
{
QMutexLocker lock(&m_mutex);
return m_ipcCore->isInitialized();
}
bool IPC::isListening(void)
{
QMutexLocker lock(&m_mutex);
return (isInitialized() && m_recvThread && m_recvThread->isRunning());
}

87
src/ipc.h
View File

@ -33,86 +33,11 @@ class IPCReceiveThread;
class IPCSendThread;
//IPC Commands
static const int IPC_OPCODE_PING = 0;
static const int IPC_OPCODE_ADD_FILE = 1;
static const int IPC_OPCODE_ADD_JOB = 2;
static const int IPC_OPCODE_MAX = 3;
static const quint32 IPC_OPCODE_PING = 0;
static const quint32 IPC_OPCODE_ADD_FILE = 1;
static const quint32 IPC_OPCODE_ADD_JOB = 2;
static const quint32 IPC_OPCODE_MAX = 3;
//IPC Flags
static const unsigned int IPC_FLAG_FORCE_START = 0x00000001;
static const unsigned int IPC_FLAG_FORCE_ENQUEUE = 0x00000002;
///////////////////////////////////////////////////////////////////////////////
// IPC Handler Class
///////////////////////////////////////////////////////////////////////////////
class IPC : public QObject
{
Q_OBJECT
public:
IPC(void);
~IPC(void);
bool initialize(bool &firstInstance);
bool sendAsync(const int &command, const QStringList &args, const unsigned int &flags = 0);
bool isInitialized(void);
bool isListening(void);
public slots:
bool startListening(void);
bool stopListening(void);
signals:
void receivedCommand(const int &command, const QStringList &args, const quint32 &flags);
protected:
IPCCore *m_ipcCore;
IPCReceiveThread *m_recvThread;
QMutex m_mutex;
};
///////////////////////////////////////////////////////////////////////////////
// Utility Classes
///////////////////////////////////////////////////////////////////////////////
class IPCSendThread : public QThread
{
Q_OBJECT
friend class IPC;
protected:
IPCSendThread(IPCCore *ipc, const int &command, const QStringList &args, const unsigned int &flags);
IPCSendThread::~IPCSendThread(void);
inline bool result(void) { return m_result; }
virtual void run(void);
private:
volatile bool m_result;
IPCCore *const m_ipc;
const int m_command;
const unsigned int m_flags;
const QStringList *m_args;
};
class IPCReceiveThread : public QThread
{
Q_OBJECT
friend class IPC;
protected:
IPCReceiveThread(IPCCore *ipc);
~IPCReceiveThread(void);
inline void stop(void) { m_stopped = true; }
virtual void run(void);
signals:
void receivedCommand(const int &command, const QStringList &args, const quint32 &flags);
private:
void receiveLoop(void);
volatile bool m_stopped;
IPCCore *const m_ipc;
};
static const quint32 IPC_FLAG_FORCE_START = 0x00000001;
static const quint32 IPC_FLAG_FORCE_ENQUEUE = 0x00000002;

268
src/main.cpp
View File

@ -19,11 +19,20 @@
// http://www.gnu.org/licenses/gpl-2.0.txt
///////////////////////////////////////////////////////////////////////////////
//Internal
#include "global.h"
#include "win_main.h"
#include "cli.h"
#include "ipc.h"
#include "taskbar7.h"
#include "thread_ipc_send.h"
//MUtils
#include <MUtils/Startup.h>
#include <MUtils/OSSupport.h>
#include <MUtils/CPUFeatures.h>
#include <MUtils/IPCChannel.h>
#include <MUtils/Version.h>
//Qt includes
#include <QApplication>
@ -35,28 +44,25 @@
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
//Forward declaration
void handleMultipleInstances(const QStringList &args, IPC *ipc);
///////////////////////////////////////////////////////////////////////////////
// Main function
// Helper functions
///////////////////////////////////////////////////////////////////////////////
static int x264_main(int argc, char* argv[])
static void x264_print_logo(void)
{
//Init console
x264_init_console(argc, argv);
//Print version info
qDebug("Simple x264 Launcher v%u.%02u.%u - use 64-Bit x264 with 32-Bit Avisynth", x264_version_major(), x264_version_minor(), x264_version_build());
qDebug("Copyright (c) 2004-%04d LoRd_MuldeR <mulder2@gmx.de>. Some rights reserved.", qMax(x264_version_date().year(),QDate::currentDate().year()));
qDebug("Built on %s at %s with %s for Win-%s.\n", x264_version_date().toString(Qt::ISODate).toLatin1().constData(), x264_version_time(), x264_version_compiler(), x264_version_arch());
qDebug("Copyright (c) 2004-%04d LoRd_MuldeR <mulder2@gmx.de>. Some rights reserved.", qMax(MUtils::Version::app_build_date().year(), MUtils::OS::current_date().year()));
qDebug("Built on %s at %s with %s for Win-%s.\n", MUTILS_UTF8(MUtils::Version::app_build_date().toString(Qt::ISODate)), MUTILS_UTF8(MUtils::Version::app_build_time().toString(Qt::ISODate)), MUtils::Version::compiler_version(), MUtils::Version::compiler_arch());
//print license info
qDebug("This program is free software: you can redistribute it and/or modify");
qDebug("it under the terms of the GNU General Public License <http://www.gnu.org/>.");
qDebug("Note that this program is distributed with ABSOLUTELY NO WARRANTY.\n");
//Print library version
qDebug("This application is powerd by MUtils library v%u.%02u (%s, %s).\n", MUtils::Version::lib_version_major(), MUtils::Version::lib_version_minor(), MUTILS_UTF8(MUtils::Version::lib_build_date().toString(Qt::ISODate)), MUTILS_UTF8(MUtils::Version::lib_build_time().toString(Qt::ISODate)));
//Print warning, if this is a "debug" build
if(X264_DEBUG)
{
@ -64,40 +70,96 @@ static int x264_main(int argc, char* argv[])
qWarning("DEBUG BUILD: DO NOT RELEASE THIS BINARY TO THE PUBLIC !!!");
qWarning("---------------------------------------------------------\n");
}
}
//Detect CPU capabilities
const x264_cpu_t cpuFeatures = x264_detect_cpu_features(argc, argv);
qDebug(" CPU vendor id : %s (Intel: %s)", cpuFeatures.vendor, X264_BOOL(cpuFeatures.intel));
qDebug("CPU brand string : %s", cpuFeatures.brand);
qDebug(" CPU signature : Family: %d, Model: %d, Stepping: %d", cpuFeatures.family, cpuFeatures.model, cpuFeatures.stepping);
qDebug("CPU capabilities : MMX=%s, MMXEXT=%s, SSE=%s, SSE2=%s, SSE3=%s, SSSE3=%s, X64=%s", X264_BOOL(cpuFeatures.mmx), X264_BOOL(cpuFeatures.mmx2), X264_BOOL(cpuFeatures.sse), X264_BOOL(cpuFeatures.sse2), X264_BOOL(cpuFeatures.sse3), X264_BOOL(cpuFeatures.ssse3), X264_BOOL(cpuFeatures.x64));
qDebug(" Number of CPU's : %d\n", cpuFeatures.count);
static int x264_initialize_ipc(MUtils::IPCChannel *const ipcChannel)
{
int iResult = 0;
//Get CLI arguments
const QStringList &arguments = x264_arguments();
//Initialize the IPC handler class
bool firstInstance = false;
IPC *ipc = new IPC();
if(ipc->initialize(firstInstance))
if((iResult = ipcChannel->initialize()) != MUtils::IPCChannel::RET_SUCCESS_MASTER)
{
if(!firstInstance)
if(iResult == MUtils::IPCChannel::RET_SUCCESS_SLAVE)
{
qDebug("This is *not* the fist instance -> sending all CLI commands to first instance!");
handleMultipleInstances(arguments, ipc);
X264_DELETE(ipc);
return 0;
qDebug("Simple x264 Launcher is already running, connecting to running instance...");
QScopedPointer<IPCThread_Send> messageProducerThread(new IPCThread_Send(ipcChannel));
messageProducerThread->start();
if(!messageProducerThread->wait(30000))
{
qWarning("MessageProducer thread has encountered timeout -> going to kill!");
messageProducerThread->terminate();
messageProducerThread->wait();
MUtils::OS::system_message_err(L"Simple x264 Launcher", L"Simple x264 Launcher is already running, but the running instance doesn't respond!");
return -1;
}
return 0;
}
else
{
qWarning("IPC initialization has failed!");
qFatal("The IPC initialization has failed!");
return -1;
}
}
//Initialize Qt
if(!x264_init_qt(argc, argv))
return 1;
}
///////////////////////////////////////////////////////////////////////////////
// Main function
///////////////////////////////////////////////////////////////////////////////
static int simple_x264_main(int &argc, char **argv)
{
int iResult = -1;
//Print logo
x264_print_logo();
//Get CLI arguments
const MUtils::OS::ArgumentMap &arguments = MUtils::OS::arguments();
//Enumerate CLI arguments
if(!arguments.isEmpty())
{
return -1;
qDebug("Command-Line Arguments:");
foreach(const QString &key, arguments.uniqueKeys())
{
foreach(const QString &val, arguments.values(key))
{
if(!val.isEmpty())
{
qDebug("--%s = \"%s\"", MUTILS_UTF8(key), MUTILS_UTF8(val));
continue;
}
qDebug("--%s", MUTILS_UTF8(key));
}
}
qDebug(" ");
}
//Detect CPU capabilities
const MUtils::CPUFetaures::cpu_info_t cpuFeatures = MUtils::CPUFetaures::detect();
qDebug(" CPU vendor id : %s (Intel=%s)", cpuFeatures.vendor, MUTILS_BOOL2STR(cpuFeatures.intel));
qDebug("CPU brand string : %s", cpuFeatures.brand);
qDebug(" CPU signature : Family=%d Model=%d Stepping=%d", cpuFeatures.family, cpuFeatures.model, cpuFeatures.stepping);
qDebug("CPU capabilities : MMX=%s SSE=%s SSE2=%s SSE3=%s SSSE3=%s SSE4=%s SSE4.2=%s x64=%s", MUTILS_BOOL2STR(cpuFeatures.features & MUtils::CPUFetaures::FLAG_MMX), MUTILS_BOOL2STR(cpuFeatures.features & MUtils::CPUFetaures::FLAG_SSE), MUTILS_BOOL2STR(cpuFeatures.features & MUtils::CPUFetaures::FLAG_SSE2), MUTILS_BOOL2STR(cpuFeatures.features & MUtils::CPUFetaures::FLAG_SSE3), MUTILS_BOOL2STR(cpuFeatures.features & MUtils::CPUFetaures::FLAG_SSSE3), MUTILS_BOOL2STR(cpuFeatures.features & MUtils::CPUFetaures::FLAG_SSE4), MUTILS_BOOL2STR(cpuFeatures.features & MUtils::CPUFetaures::FLAG_SSE42), MUTILS_BOOL2STR(cpuFeatures.x64));
qDebug(" Number of CPU's : %d\n", cpuFeatures.count);
//Initialize Qt
QScopedPointer<QApplication> application(MUtils::Startup::create_qt(argc, argv, QLatin1String("LameXP - Audio Encoder Front-End")));
if(application.isNull())
{
return EXIT_FAILURE;
}
//Initialize application
application->setWindowIcon(QIcon(":/icons/movie.ico"));
application->setApplicationVersion(QString().sprintf("%d.%02d.%04d", x264_version_major(), x264_version_minor(), x264_version_build()));
//Initialize the IPC handler class
QScopedPointer<MUtils::IPCChannel> ipcChannel(new MUtils::IPCChannel("simple-x264-launcher", x264_version_build(), "instance"));
if((iResult = x264_initialize_ipc(ipcChannel.data())) < 1)
{
return (iResult == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
//Running in portable mode?
@ -110,14 +172,14 @@ static int x264_main(int argc, char* argv[])
WinSevenTaskbar::init();
//Set style
if(!CLIParser::checkFlag(CLI_PARAM_NO_GUI_STYLE, arguments))
if(!arguments.contains(CLI_PARAM_NO_GUI_STYLE))
{
qApp->setStyle(new QPlastiqueStyle());
}
//Create Main Window
MainWindow *mainWin = new MainWindow(&cpuFeatures, ipc);
mainWin->show();
QScopedPointer<MainWindow> mainWindow(new MainWindow(cpuFeatures));
mainWindow->show();
//Run application
int ret = qApp->exec();
@ -125,145 +187,15 @@ static int x264_main(int argc, char* argv[])
//Taskbar uninit
WinSevenTaskbar::init();
//Clean up
X264_DELETE(mainWin);
X264_DELETE(ipc);
//Exit program
return ret;
}
///////////////////////////////////////////////////////////////////////////////
// Multi-instance handler
///////////////////////////////////////////////////////////////////////////////
void handleMultipleInstances(const QStringList &args, IPC *ipc)
{
bool commandSent = false;
unsigned int flags = 0;
//Initialize command-line parser
CLIParser parser(args);
int identifier;
QStringList options;
//Process all command-line arguments
while(parser.nextOption(identifier, &options))
{
switch(identifier)
{
case CLI_PARAM_ADD_FILE:
ipc->sendAsync(IPC_OPCODE_ADD_FILE, options, flags);
commandSent = true;
break;
case CLI_PARAM_ADD_JOB:
ipc->sendAsync(IPC_OPCODE_ADD_JOB, options, flags);
commandSent = true;
break;
case CLI_PARAM_FORCE_START:
flags = ((flags | IPC_FLAG_FORCE_START) & (~IPC_FLAG_FORCE_ENQUEUE));
break;
case CLI_PARAM_NO_FORCE_START:
flags = (flags & (~IPC_FLAG_FORCE_START));
break;
case CLI_PARAM_FORCE_ENQUEUE:
flags = ((flags | IPC_FLAG_FORCE_ENQUEUE) & (~IPC_FLAG_FORCE_START));
break;
case CLI_PARAM_NO_FORCE_ENQUEUE:
flags = (flags & (~IPC_FLAG_FORCE_ENQUEUE));
break;
}
}
//If no argument has been sent yet, send a ping!
if(!commandSent)
{
ipc->sendAsync(IPC_OPCODE_PING, QStringList());
}
}
///////////////////////////////////////////////////////////////////////////////
// Applicaton entry point
///////////////////////////////////////////////////////////////////////////////
LONG WINAPI x264_exception_handler(__in struct _EXCEPTION_POINTERS *ExceptionInfo);
void x264_invalid_param_handler(const wchar_t*, const wchar_t*, const wchar_t*, unsigned int, uintptr_t);
#define PRINT_ERROR(MESSAGE, ...) do \
{ \
fflush(stdout); \
fflush(stderr); \
fprintf(stderr, (MESSAGE), __VA_ARGS__); \
fflush(stderr); \
} \
while(0)
static int _main(int argc, char* argv[])
{
if(X264_DEBUG)
{
int iResult = -1;
qInstallMsgHandler(x264_message_handler);
X264_MEMORY_CHECK(x264_main, iResult, argc, argv);
x264_finalization();
return iResult;
}
else
{
int iResult = -1;
try
{
qInstallMsgHandler(x264_message_handler);
iResult = x264_main(argc, argv);
x264_finalization();
}
catch(const X264Exception &e)
{
PRINT_ERROR("\nGURU MEDITATION !!!\n\nException error message: %s\n", e.what());
x264_fatal_exit(L"An internal error was detected, application will exit!", e.what());
}
catch(const std::exception &e)
{
PRINT_ERROR("\nGURU MEDITATION !!!\n\nException error message: %s\n", e.what());
x264_fatal_exit(L"Unhandeled C++ exception error, application will exit!", e.what());
}
catch(char *error)
{
PRINT_ERROR("\nGURU MEDITATION !!!\n\nException error message: %s\n", error);
x264_fatal_exit(L"Unhandeled C++ exception error, application will exit!");
}
catch(int error)
{
PRINT_ERROR("\nGURU MEDITATION !!!\n\nException error code: 0x%X\n", error);
x264_fatal_exit(L"Unhandeled C++ exception error, application will exit!");
}
catch(...)
{
PRINT_ERROR("\nGURU MEDITATION !!!\n\nUnknown C++ exception!\n");
x264_fatal_exit(L"Unhandeled C++ exception error, application will exit!");
}
return iResult;
}
}
int main(int argc, char* argv[])
{
if(X264_DEBUG)
{
return _main(argc, argv);
}
else
{
__try
{
SetUnhandledExceptionFilter(x264_exception_handler);
_set_invalid_parameter_handler(x264_invalid_param_handler);
return _main(argc, argv);
}
__except(1)
{
fflush(stdout);
fflush(stderr);
fprintf(stderr, "\nGURU MEDITATION !!!\n\nUnhandeled structured exception error! [code: 0x%X]\n", GetExceptionCode());
x264_fatal_exit(L"Unhandeled structured exception error, application will exit!");
}
}
return MUtils::Startup::startup(argc, argv, simple_x264_main, "Simple x264 Launcher", true /*lamexp_version_demo()*/);
}

123
src/thread_ipc_send.cpp Normal file
View File

@ -0,0 +1,123 @@
///////////////////////////////////////////////////////////////////////////////
// Simple x264 Launcher
// Copyright (C) 2004-2015 LoRd_MuldeR <MuldeR2@GMX.de>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version, but always including the *additional*
// restrictions defined in the "License.txt" file.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
// http://www.gnu.org/licenses/gpl-2.0.txt
///////////////////////////////////////////////////////////////////////////////
#include "thread_ipc_send.h"
//Internal
#include "Global.h"
#include "cli.h"
#include "ipc.h"
//MUtils
#include <MUtils/Global.h>
#include <MUtils/IPCChannel.h>
#include <MUtils/OSSupport.h>
//Qt
#include <QStringList>
#include <QApplication>
#include <QFileInfo>
#include <QDir>
//CRT
#include <limits.h>
////////////////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////////////////
IPCThread_Send::IPCThread_Send(MUtils::IPCChannel *const ipcChannel)
:
m_ipcChannel(ipcChannel)
{
}
IPCThread_Send::~IPCThread_Send(void)
{
}
void IPCThread_Send::run()
{
setTerminationEnabled(true);
bool bSentFiles = false;
const MUtils::OS::ArgumentMap &args = MUtils::OS::arguments();
quint32 flags = 0;
bool commandSent = false;
//Handle flags
if(args.contains(CLI_PARAM_FORCE_START))
{
flags = ((flags | IPC_FLAG_FORCE_START) & (~IPC_FLAG_FORCE_ENQUEUE));
}
if(args.contains(CLI_PARAM_FORCE_ENQUEUE))
{
flags = ((flags | IPC_FLAG_FORCE_ENQUEUE) & (~IPC_FLAG_FORCE_START));
}
//Process all command-line arguments
if(args.contains(CLI_PARAM_ADD_FILE))
{
foreach(const QString &fileName, args.values(CLI_PARAM_ADD_FILE))
{
if(!m_ipcChannel->send(IPC_OPCODE_ADD_FILE, flags, QStringList() << fileName))
{
qWarning("Failed to send IPC message!");
}
commandSent = true;
}
}
if(args.contains(CLI_PARAM_ADD_JOB))
{
foreach(const QString &options, args.values(CLI_PARAM_ADD_JOB))
{
const QStringList optionValues = options.split('|', QString::SkipEmptyParts);
if(optionValues.count() == 3)
{
if(!m_ipcChannel->send(IPC_OPCODE_ADD_JOB, flags, optionValues))
{
qWarning("Failed to send IPC message!");
}
}
else
{
qWarning("Invalid number of arguments for parameter \"--%s\" detected!", CLI_PARAM_ADD_JOB);
}
commandSent = true;
}
}
//If no argument has been sent yet, send a ping!
if(!commandSent)
{
if(!m_ipcChannel->send(IPC_OPCODE_PING, 0, QStringList()))
{
qWarning("Failed to send IPC message!");
}
}
}
////////////////////////////////////////////////////////////
// EVENTS
////////////////////////////////////////////////////////////
/*NONE*/

44
src/thread_ipc_send.h Normal file
View File

@ -0,0 +1,44 @@
///////////////////////////////////////////////////////////////////////////////
// Simple x264 Launcher
// Copyright (C) 2004-2015 LoRd_MuldeR <MuldeR2@GMX.de>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version, but always including the *additional*
// restrictions defined in the "License.txt" file.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
// http://www.gnu.org/licenses/gpl-2.0.txt
///////////////////////////////////////////////////////////////////////////////
#pragma once
#include <QThread>
namespace MUtils
{
class IPCChannel;
}
class IPCThread_Send: public QThread
{
Q_OBJECT
public:
IPCThread_Send(MUtils::IPCChannel *const ipcChannel);
~IPCThread_Send(void);
void run();
protected:
MUtils::IPCChannel *const m_ipcChannel;
};

2
src/version.h
View File

@ -26,7 +26,7 @@
#define VER_X264_MAJOR 2
#define VER_X264_MINOR 4
#define VER_X264_PATCH 6
#define VER_X264_BUILD 902
#define VER_X264_BUILD 907
#define VER_X264_PORTABLE_EDITION (0)

2
src/win_about.cpp
View File

@ -20,7 +20,7 @@
///////////////////////////////////////////////////////////////////////////////
#include "win_about.h"
#include "uic_win_about.h"
#include "UIC_win_about.h"
#include "global.h"

2
src/win_addJob.cpp
View File

@ -20,7 +20,7 @@
///////////////////////////////////////////////////////////////////////////////
#include "win_addJob.h"
#include "uic_win_addJob.h"
#include "UIC_win_addJob.h"
#include "global.h"
#include "model_options.h"

2
src/win_editor.cpp
View File

@ -20,7 +20,7 @@
///////////////////////////////////////////////////////////////////////////////
#include "win_editor.h"
#include "uic_win_editor.h"
#include "UIC_win_editor.h"
#include "global.h"

2
src/win_help.cpp
View File

@ -20,7 +20,7 @@
///////////////////////////////////////////////////////////////////////////////
#include "win_help.h"
#include "uic_win_help.h"
#include "UIC_win_help.h"
#include "global.h"
#include "model_options.h"

114
src/win_main.cpp
View File

@ -20,8 +20,9 @@
///////////////////////////////////////////////////////////////////////////////
#include "win_main.h"
#include "uic_win_main.h"
#include "UIC_win_main.h"
//Internal
#include "global.h"
#include "cli.h"
#include "ipc.h"
@ -43,6 +44,11 @@
#include "binaries.h"
#include "resource.h"
//MUtils
#include <MUtils/OSSupport.h>
#include <MUtils/CPUFeatures.h>
//Qt
#include <QDate>
#include <QTimer>
#include <QCloseEvent>
@ -87,9 +93,9 @@ static const int vsynth_rev = 24;
/*
* Constructor
*/
MainWindow::MainWindow(const x264_cpu_t *const cpuFeatures, IPC *ipc)
MainWindow::MainWindow(const MUtils::CPUFetaures::cpu_info_t &cpuFeatures)
:
m_ipc(ipc),
m_ipc(NULL),
m_sysinfo(NULL),
m_options(NULL),
m_jobList(NULL),
@ -112,9 +118,9 @@ MainWindow::MainWindow(const x264_cpu_t *const cpuFeatures, IPC *ipc)
//Create and initialize the sysinfo object
m_sysinfo = new SysinfoModel();
m_sysinfo->setAppPath(QApplication::applicationDirPath());
m_sysinfo->setMMXSupport(cpuFeatures->mmx && cpuFeatures->mmx2);
m_sysinfo->setSSESupport(cpuFeatures->sse && cpuFeatures->mmx2); //SSE implies MMX2
m_sysinfo->setX64Support(cpuFeatures->x64 && cpuFeatures->sse2); //X64 implies SSE2
m_sysinfo->setMMXSupport(cpuFeatures.features && MUtils::CPUFetaures::FLAG_MMX);
m_sysinfo->setSSESupport(cpuFeatures.features && MUtils::CPUFetaures::FLAG_SSE); //SSE implies MMX2
m_sysinfo->setX64Support(cpuFeatures.x64 && (cpuFeatures.features && MUtils::CPUFetaures::FLAG_SSE2)); //X64 implies SSE2
//Load preferences
m_preferences = new PreferencesModel();
@ -275,10 +281,11 @@ MainWindow::~MainWindow(void)
X264_DELETE(temp);
}
if(m_ipc->isListening())
{
m_ipc->stopListening();
}
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! FIXME !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//if(m_ipc->isListening())
//{
// m_ipc->stopListening();
//}
X264_DELETE(m_preferences);
X264_DELETE(m_recentlyUsed);
@ -757,18 +764,18 @@ void MainWindow::init(void)
}
updateLabelPos();
const QStringList arguments = x264_arguments();
const MUtils::OS::ArgumentMap &arguments = MUtils::OS::arguments();
//---------------------------------------
// Create the IPC listener thread
//---------------------------------------
if(m_ipc->isInitialized())
{
connect(m_ipc, SIGNAL(receivedCommand(int,QStringList,quint32)), this, SLOT(handleCommand(int,QStringList,quint32)), Qt::QueuedConnection);
m_ipc->startListening();
}
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! FIXME !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//if(m_ipc->isInitialized())
//{
// connect(m_ipc, SIGNAL(receivedCommand(int,QStringList,quint32)), this, SLOT(handleCommand(int,QStringList,quint32)), Qt::QueuedConnection);
// m_ipc->startListening();
//}
//---------------------------------------
// Check required binaries
@ -869,14 +876,14 @@ void MainWindow::init(void)
}
//Skip version check (not recommended!)
if(CLIParser::checkFlag(CLI_PARAM_SKIP_VERSION_CHECK, arguments))
if(arguments.contains(CLI_PARAM_SKIP_VERSION_CHECK))
{
qWarning("Version checks are disabled now, you have been warned!\n");
m_preferences->setSkipVersionTest(true);
}
//Don't abort encoding process on timeout (not recommended!)
if(CLIParser::checkFlag(CLI_PARAM_NO_DEADLOCK, arguments))
if(arguments.contains(CLI_PARAM_NO_DEADLOCK))
{
qWarning("Deadlock detection disabled, you have been warned!\n");
m_preferences->setAbortOnTimeout(false);
@ -886,7 +893,7 @@ void MainWindow::init(void)
// Check Avisynth support
//---------------------------------------
if(!CLIParser::checkFlag(CLI_PARAM_SKIP_AVS_CHECK, arguments))
if(!arguments.contains(CLI_PARAM_SKIP_AVS_CHECK))
{
qDebug("[Check for Avisynth support]");
volatile double avisynthVersion = 0.0;
@ -926,7 +933,7 @@ void MainWindow::init(void)
// Check VapurSynth support
//---------------------------------------
if(!CLIParser::checkFlag(CLI_PARAM_SKIP_VPS_CHECK, arguments))
if(!arguments.contains(CLI_PARAM_SKIP_VPS_CHECK))
{
qDebug("[Check for VapourSynth support]");
QString vapoursynthPath;
@ -1008,7 +1015,7 @@ void MainWindow::init(void)
else if(!parseCommandLineArgs())
{
//Update reminder
if(CLIParser::checkFlag(CLI_PARAM_FIRST_RUN, arguments))
if(arguments.contains(CLI_PARAM_FIRST_RUN))
{
qWarning("First run -> resetting update check now!");
m_recentlyUsed->setLastUpdateCheck(0);
@ -1605,41 +1612,46 @@ void MainWindow::updateTaskbar(JobStatus status, const QIcon &icon)
*/
bool MainWindow::parseCommandLineArgs(void)
{
bool bCommandAccepted = false;
unsigned int flags = 0;
const MUtils::OS::ArgumentMap &args = MUtils::OS::arguments();
//Initialize command-line parser
CLIParser parser(x264_arguments());
int identifier;
QStringList options;
quint32 flags = 0;
bool commandSent = false;
//Handle flags
if(args.contains(CLI_PARAM_FORCE_START))
{
flags = ((flags | IPC_FLAG_FORCE_START) & (~IPC_FLAG_FORCE_ENQUEUE));
}
if(args.contains(CLI_PARAM_FORCE_ENQUEUE))
{
flags = ((flags | IPC_FLAG_FORCE_ENQUEUE) & (~IPC_FLAG_FORCE_START));
}
//Process all command-line arguments
while(parser.nextOption(identifier, &options))
if(args.contains(CLI_PARAM_ADD_FILE))
{
switch(identifier)
foreach(const QString &fileName, args.values(CLI_PARAM_ADD_FILE))
{
case CLI_PARAM_ADD_FILE:
handleCommand(IPC_OPCODE_ADD_FILE, options, flags);
bCommandAccepted = true;
break;
case CLI_PARAM_ADD_JOB:
handleCommand(IPC_OPCODE_ADD_JOB, options, flags);
bCommandAccepted = true;
break;
case CLI_PARAM_FORCE_START:
flags = ((flags | IPC_FLAG_FORCE_START) & (~IPC_FLAG_FORCE_ENQUEUE));
break;
case CLI_PARAM_NO_FORCE_START:
flags = (flags & (~IPC_FLAG_FORCE_START));
break;
case CLI_PARAM_FORCE_ENQUEUE:
flags = ((flags | IPC_FLAG_FORCE_ENQUEUE) & (~IPC_FLAG_FORCE_START));
break;
case CLI_PARAM_NO_FORCE_ENQUEUE:
flags = (flags & (~IPC_FLAG_FORCE_ENQUEUE));
break;
handleCommand(IPC_OPCODE_ADD_FILE, QStringList() << fileName, flags);
}
commandSent = true;
}
if(args.contains(CLI_PARAM_ADD_JOB))
{
foreach(const QString &options, args.values(CLI_PARAM_ADD_JOB))
{
const QStringList optionValues = options.split('|', QString::SkipEmptyParts);
if(optionValues.count() == 3)
{
handleCommand(IPC_OPCODE_ADD_JOB, optionValues, flags);
}
else
{
qWarning("Invalid number of arguments for parameter \"--%s\" detected!", CLI_PARAM_ADD_JOB);
}
}
commandSent = true;
}
return bCommandAccepted;
return commandSent;
}

14
src/win_main.h
View File

@ -21,7 +21,10 @@
#pragma once
//Internal
#include "global.h"
//Qt
#include <QMainWindow>
class IPC;
@ -43,12 +46,21 @@ namespace Ui
class MainWindow;
}
namespace MUtils
{
namespace CPUFetaures
{
struct _stuctName;
typedef struct _cpu_info_t cpu_info_t;
}
}
class MainWindow: public QMainWindow
{
Q_OBJECT
public:
MainWindow(const x264_cpu_t *const cpuFeatures, IPC *ipc);
MainWindow(const MUtils::CPUFetaures::cpu_info_t &cpuFeatures);
~MainWindow(void);
protected:

2
src/win_preferences.cpp
View File

@ -20,7 +20,7 @@
///////////////////////////////////////////////////////////////////////////////
#include "win_preferences.h"
#include "uic_win_preferences.h"
#include "UIC_win_preferences.h"
#include "global.h"
#include "model_preferences.h"

2
src/win_updater.cpp
View File

@ -20,7 +20,7 @@
///////////////////////////////////////////////////////////////////////////////
#include "win_updater.h"
#include "uic_win_updater.h"
#include "UIC_win_updater.h"
#include "global.h"
#include "model_sysinfo.h"

73
src/zero.cpp Normal file
View File

@ -0,0 +1,73 @@
///////////////////////////////////////////////////////////////////////////////
// Simple x264 Launcher
// Copyright (C) 2004-2015 LoRd_MuldeR <MuldeR2@GMX.de>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
// http://www.gnu.org/licenses/gpl-2.0.txt
///////////////////////////////////////////////////////////////////////////////
//MUtils
#include <MUtils/OSSupport.h>
//Qt
#include <QtGlobal>
///////////////////////////////////////////////////////////////////////////////
// GLOBAL FUNCTIONS
///////////////////////////////////////////////////////////////////////////////
static size_t x264_entry_check(void);
static size_t g_x264_entry_check_result = x264_entry_check();
static size_t g_x264_entry_check_flag = 0x789E09B2;
/*
* Entry point checks
*/
static size_t x264_entry_check(void)
{
volatile size_t retVal = 0xA199B5AF;
if(g_x264_entry_check_flag != 0x8761F64D)
{
MUtils::OS::fatal_exit(L"Application initialization has failed, take care!");
}
return retVal;
}
/*
* Function declarations
*/
void x264_initialization(void);
extern "C" int mainCRTStartup(void);
/*
* Application entry point (runs before static initializers)
*/
extern "C" int x264_entry_point(void)
{
if(g_x264_entry_check_flag != 0x789E09B2)
{
MUtils::OS::fatal_exit(L"Application initialization has failed, take care!");
}
//Make sure we will pass the check
g_x264_entry_check_flag = ~g_x264_entry_check_flag;
//Call global initialization function
x264_initialization();
//Now initialize the C Runtime library!
return mainCRTStartup();
}

15
x264_launcher_MSVC2013.sln
View File

@ -1,20 +1,33 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2013
VisualStudioVersion = 12.0.21005.1
VisualStudioVersion = 12.0.31101.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "x264_launcher", "x264_launcher_MSVC2013.vcxproj", "{563D953B-CBC3-4C75-AFC2-5BD87531C332}"
ProjectSection(ProjectDependencies) = postProject
{55405FE1-149F-434C-9D72-4B64348D2A08} = {55405FE1-149F-434C-9D72-4B64348D2A08}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MUtilities", "..\MUtilities\MUtilities_VS2013.vcxproj", "{55405FE1-149F-434C-9D72-4B64348D2A08}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
Release_Static|Win32 = Release_Static|Win32
Release|Win32 = Release|Win32
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{563D953B-CBC3-4C75-AFC2-5BD87531C332}.Debug|Win32.ActiveCfg = Debug|Win32
{563D953B-CBC3-4C75-AFC2-5BD87531C332}.Debug|Win32.Build.0 = Debug|Win32
{563D953B-CBC3-4C75-AFC2-5BD87531C332}.Release_Static|Win32.ActiveCfg = Release|Win32
{563D953B-CBC3-4C75-AFC2-5BD87531C332}.Release|Win32.ActiveCfg = Release|Win32
{563D953B-CBC3-4C75-AFC2-5BD87531C332}.Release|Win32.Build.0 = Release|Win32
{55405FE1-149F-434C-9D72-4B64348D2A08}.Debug|Win32.ActiveCfg = Debug|Win32
{55405FE1-149F-434C-9D72-4B64348D2A08}.Debug|Win32.Build.0 = Debug|Win32
{55405FE1-149F-434C-9D72-4B64348D2A08}.Release_Static|Win32.ActiveCfg = Release_Static|Win32
{55405FE1-149F-434C-9D72-4B64348D2A08}.Release_Static|Win32.Build.0 = Release_Static|Win32
{55405FE1-149F-434C-9D72-4B64348D2A08}.Release|Win32.ActiveCfg = Release|Win32
{55405FE1-149F-434C-9D72-4B64348D2A08}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

363
x264_launcher_MSVC2013.vcxproj
View File

@ -41,13 +41,13 @@
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<OutDir>$(SolutionDir)bin\$(Configuration)\</OutDir>
<IntDir>$(SolutionDir)obj\$(Configuration)\</IntDir>
<OutDir>$(SolutionDir)\bin\$(Platform)\$(Configuration)\</OutDir>
<IntDir>$(SolutionDir)\obj\$(Platform)\$(Configuration)\$(ProjectName)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
<OutDir>$(SolutionDir)bin\$(Configuration)\</OutDir>
<IntDir>$(SolutionDir)obj\$(Configuration)\</IntDir>
<OutDir>$(SolutionDir)\bin\$(Platform)\$(Configuration)\</OutDir>
<IntDir>$(SolutionDir)\obj\$(Platform)\$(Configuration)\$(ProjectName)\</IntDir>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
@ -56,11 +56,11 @@
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>WIN32;_DEBUG;QT_DEBUG;QT_DLL;QT_GUI_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>$(QTDIR)\include;$(QTDIR)\include\QtCore;$(QTDIR)\include\QtGui;$(QTDIR)\include\QtTest;$(SolutionDir)tmp\uic;$(SolutionDir)etc\vld\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>$(SolutionDir)\..\MUtilities\include;$(SolutionDir)\tmp\$(ProjectName);$(SolutionDir)\etc\vld\include;$(QTDIR)\include;$(QTDIR)\include\QtCore;$(QTDIR)\include\QtGui;$(QTDIR)\include\QtTest;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<EnableEnhancedInstructionSet>NoExtensions</EnableEnhancedInstructionSet>
<TreatWChar_tAsBuiltInType>false</TreatWChar_tAsBuiltInType>
<OmitFramePointers>false</OmitFramePointers>
<InlineFunctionExpansion>Disabled</InlineFunctionExpansion>
<OpenMPSupport>true</OpenMPSupport>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
@ -70,7 +70,7 @@
<EntryPointSymbol>x264_entry_point</EntryPointSymbol>
</Link>
<PostBuildEvent>
<Command>del /S /Q "$(TargetDir)\*.dll"
<Command>del /S /Q "$(TargetDir)\Qt*.dll"
rmdir /S /Q "$(TargetDir)\toolset"
rmdir /S /Q "$(TargetDir)\imageformats"
@ -116,7 +116,7 @@ copy /Y "$(SolutionDir)etc\vld\lib\$(Platform)\$(Configuration)\*.manifest" "$(T
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>WIN32;NDEBUG;QT_NO_DEBUG;QT_DLL;QT_GUI_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>$(QTDIR)\include;$(QTDIR)\include\QtCore;$(QTDIR)\include\QtGui;$(QTDIR)\include\QtTest;$(SolutionDir)tmp\uic;$(SolutionDir)etc\vld\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>$(SolutionDir)\..\MUtilities\include;$(SolutionDir)\tmp\$(ProjectName);$(SolutionDir)\etc\vld\include;$(QTDIR)\include;$(QTDIR)\include\QtCore;$(QTDIR)\include\QtGui;$(QTDIR)\include\QtTest;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
<FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
<WholeProgramOptimization>true</WholeProgramOptimization>
@ -128,7 +128,7 @@ copy /Y "$(SolutionDir)etc\vld\lib\$(Platform)\$(Configuration)\*.manifest" "$(T
<MinimalRebuild>false</MinimalRebuild>
<OmitFramePointers>true</OmitFramePointers>
<BufferSecurityCheck>false</BufferSecurityCheck>
<TreatWChar_tAsBuiltInType>false</TreatWChar_tAsBuiltInType>
<OpenMPSupport>true</OpenMPSupport>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
@ -156,7 +156,7 @@ copy /Y "$(SolutionDir)etc\vld\lib\$(Platform)\$(Configuration)\*.manifest" "$(T
</Message>
</PreLinkEvent>
<PostBuildEvent>
<Command>del /S /Q "$(TargetDir)\*.dll"
<Command>del /S /Q "$(TargetDir)\Qt*.dll"
rmdir /S /Q "$(TargetDir)\toolset"
rmdir /S /Q "$(TargetDir)\imageformats"
mkdir "$(TargetDir)\toolset\x86"
@ -183,136 +183,151 @@ copy /Y "$(QTDIR)\plugins\imageformats\qgif4.dll" "$(TargetDir)\imageformats"
<ItemGroup>
<CustomBuild Include="gui\win_addJob.ui">
<FileType>Document</FileType>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\uic\uic_%(Filename).h" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\uic\uic_%(Filename).h" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">UIC "$(SolutionDir)tmp\uic\uic_%(Filename).h"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">UIC "$(SolutionDir)tmp\uic\uic_%(Filename).h"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\uic\uic_%(Filename).h;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\uic\uic_%(Filename).h;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">UIC "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">UIC "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h;%(Outputs)</Outputs>
</CustomBuild>
<CustomBuild Include="gui\win_help.ui">
<FileType>Document</FileType>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\uic\uic_%(Filename).h" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\uic\uic_%(Filename).h" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">UIC "$(SolutionDir)tmp\uic\uic_%(Filename).h"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">UIC "$(SolutionDir)tmp\uic\uic_%(Filename).h"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\uic\uic_%(Filename).h;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\uic\uic_%(Filename).h;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">UIC "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">UIC "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h;%(Outputs)</Outputs>
</CustomBuild>
<CustomBuild Include="gui\win_preferences.ui">
<FileType>Document</FileType>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\uic\uic_%(Filename).h" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\uic\uic_%(Filename).h" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">UIC "$(SolutionDir)tmp\uic\uic_%(Filename).h"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">UIC "$(SolutionDir)tmp\uic\uic_%(Filename).h"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\uic\uic_%(Filename).h;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\uic\uic_%(Filename).h;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">UIC "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">UIC "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h;%(Outputs)</Outputs>
</CustomBuild>
<CustomBuild Include="gui\win_main.ui">
<FileType>Document</FileType>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\uic\uic_%(Filename).h" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\uic\uic_%(Filename).h" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">UIC "$(SolutionDir)tmp\uic\uic_%(Filename).h"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">UIC "$(SolutionDir)tmp\uic\uic_%(Filename).h"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\uic\uic_%(Filename).h;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\uic\uic_%(Filename).h;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">UIC "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">UIC "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h;%(Outputs)</Outputs>
</CustomBuild>
<CustomBuild Include="gui\win_editor.ui">
<FileType>Document</FileType>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\uic\uic_%(Filename).h" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\uic\uic_%(Filename).h" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">UIC "$(SolutionDir)tmp\uic\uic_%(Filename).h"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">UIC "$(SolutionDir)tmp\uic\uic_%(Filename).h"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\uic\uic_%(Filename).h;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\uic\uic_%(Filename).h;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">UIC "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">UIC "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h;%(Outputs)</Outputs>
</CustomBuild>
<CustomBuild Include="gui\win_updater.ui">
<FileType>Document</FileType>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\uic\uic_%(Filename).h" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\uic\uic_%(Filename).h" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">UIC "$(SolutionDir)tmp\uic\uic_%(Filename).h"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">UIC "$(SolutionDir)tmp\uic\uic_%(Filename).h"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\uic\uic_%(Filename).h;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\uic\uic_%(Filename).h;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">UIC "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">UIC "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h;%(Outputs)</Outputs>
</CustomBuild>
<CustomBuild Include="gui\win_about.ui">
<FileType>Document</FileType>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\uic\uic_%(Filename).h" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\uic\uic_%(Filename).h" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">UIC "$(SolutionDir)tmp\uic\uic_%(Filename).h"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">UIC "$(SolutionDir)tmp\uic\uic_%(Filename).h"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\uic\uic_%(Filename).h;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\uic\uic_%(Filename).h;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\uic.exe" -o "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">UIC "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">UIC "$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\UIC_%(Filename).h;%(Outputs)</Outputs>
</CustomBuild>
<None Include="ReadMe.txt" />
<CustomBuild Include="res\resources.qrc">
<FileType>Document</FileType>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\rcc.exe" -o "$(SolutionDir)tmp\qrc\qrc_%(Filename).cpp" -name "%(Filename)" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">RCC "$(SolutionDir)tmp\qrc\qrc_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\qrc\qrc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\rcc.exe" -o "$(SolutionDir)tmp\qrc\qrc_%(Filename).cpp" -name "%(Filename)" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">RCC "$(SolutionDir)tmp\qrc\qrc_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\qrc\qrc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\rcc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\QRC_%(Filename).cpp" -name "%(Filename)" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">RCC "$(SolutionDir)tmp\$(ProjectName)\QRC_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\QRC_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\rcc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\QRC_%(Filename).cpp" -name "%(Filename)" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">RCC "$(SolutionDir)tmp\$(ProjectName)\QRC_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\QRC_%(Filename).cpp;%(Outputs)</Outputs>
<SubType>Designer</SubType>
</CustomBuild>
<None Include="res\icons\movie.ico" />
</ItemGroup>
<ItemGroup>
<CustomBuild Include="src\thread_ipc_send.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
</CustomBuild>
<ClInclude Include="tmp\x264_launcher\UIC_win_about.h" />
<ClInclude Include="tmp\x264_launcher\UIC_win_addJob.h" />
<ClInclude Include="tmp\x264_launcher\UIC_win_editor.h" />
<ClInclude Include="tmp\x264_launcher\UIC_win_help.h" />
<ClInclude Include="tmp\x264_launcher\UIC_win_main.h" />
<ClInclude Include="tmp\x264_launcher\UIC_win_preferences.h" />
<ClInclude Include="tmp\x264_launcher\UIC_win_updater.h" />
<CustomBuild Include="src\win_about.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
</CustomBuild>
<CustomBuild Include="src\win_updater.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
</CustomBuild>
<CustomBuild Include="src\win_editor.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
</CustomBuild>
<CustomBuild Include="src\win_preferences.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
</CustomBuild>
<CustomBuild Include="src\win_help.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
</CustomBuild>
<CustomBuild Include="src\win_addJob.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
</CustomBuild>
<CustomBuild Include="src\thread_encode.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
</CustomBuild>
<ClInclude Include="resource.h" />
<ClInclude Include="src\3rd_party\avisynth_c.h" />
@ -326,37 +341,29 @@ copy /Y "$(QTDIR)\plugins\imageformats\qgif4.dll" "$(TargetDir)\imageformats"
<ClInclude Include="src\encoder_x265.h" />
<ClInclude Include="src\global.h" />
<CustomBuild Include="src\model_jobList.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
</CustomBuild>
<CustomBuild Include="src\model_logFile.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
</CustomBuild>
<CustomBuild Include="src\ipc.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
</CustomBuild>
<ClInclude Include="src\job_object.h" />
<CustomBuild Include="src\input_filter.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
</CustomBuild>
<ClInclude Include="src\mediainfo.h" />
<ClInclude Include="src\model_options.h" />
@ -370,58 +377,55 @@ copy /Y "$(QTDIR)\plugins\imageformats\qgif4.dll" "$(TargetDir)\imageformats"
<ClInclude Include="src\targetver.h" />
<ClInclude Include="src\taskbar7.h" />
<CustomBuild Include="src\thread_avisynth.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
</CustomBuild>
<CustomBuild Include="src\thread_vapoursynth.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
</CustomBuild>
<CustomBuild Include="src\thread_updater.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
</CustomBuild>
<CustomBuild Include="src\tool_abstract.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
</CustomBuild>
<ClInclude Include="src\version.h" />
<CustomBuild Include="src\win_main.h">
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\moc\moc_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\moc\moc_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\moc\moc_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">"$(QTDIR)\bin\moc.exe" -o "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp" "%(FullPath)"</Command>
<Message Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">MOC "$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp"</Message>
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)tmp\$(ProjectName)\MOC_%(Filename).cpp;%(Outputs)</Outputs>
</CustomBuild>
</ItemGroup>
<ItemGroup>
<ClCompile Include="src\3rd_party\blake2.c" />
<ClCompile Include="src\3rd_party\qtmain_win.cpp" />
<ClCompile Include="src\binaries.cpp" />
<ClCompile Include="src\checksum.cpp" />
<ClCompile Include="src\cli.cpp" />
<ClCompile Include="src\encoder_abstract.cpp" />
<ClCompile Include="src\encoder_factory.cpp" />
<ClCompile Include="src\encoder_x264.cpp" />
<ClCompile Include="src\encoder_x265.cpp" />
<ClCompile Include="src\ipc.cpp" />
<ClCompile Include="src\job_object.cpp" />
<ClCompile Include="src\input_filter.cpp" />
<ClCompile Include="src\mediainfo.cpp" />
@ -438,6 +442,7 @@ copy /Y "$(QTDIR)\plugins\imageformats\qgif4.dll" "$(TargetDir)\imageformats"
<ClCompile Include="src\thread_encode.cpp" />
<ClCompile Include="src\global.cpp" />
<ClCompile Include="src\main.cpp" />
<ClCompile Include="src\thread_ipc_send.cpp" />
<ClCompile Include="src\thread_updater.cpp" />
<ClCompile Include="src\thread_vapoursynth.cpp" />
<ClCompile Include="src\tool_abstract.cpp" />
@ -448,23 +453,24 @@ copy /Y "$(QTDIR)\plugins\imageformats\qgif4.dll" "$(TargetDir)\imageformats"
<ClCompile Include="src\win_main.cpp" />
<ClCompile Include="src\win_preferences.cpp" />
<ClCompile Include="src\win_updater.cpp" />
<ClCompile Include="tmp\moc\moc_input_filter.cpp" />
<ClCompile Include="tmp\moc\moc_ipc.cpp" />
<ClCompile Include="tmp\moc\moc_model_jobList.cpp" />
<ClCompile Include="tmp\moc\moc_model_logFile.cpp" />
<ClCompile Include="tmp\moc\moc_thread_avisynth.cpp" />
<ClCompile Include="tmp\moc\moc_thread_encode.cpp" />
<ClCompile Include="tmp\moc\moc_thread_updater.cpp" />
<ClCompile Include="tmp\moc\moc_thread_vapoursynth.cpp" />
<ClCompile Include="tmp\moc\moc_tool_abstract.cpp" />
<ClCompile Include="tmp\moc\moc_win_about.cpp" />
<ClCompile Include="tmp\moc\moc_win_addJob.cpp" />
<ClCompile Include="tmp\moc\moc_win_editor.cpp" />
<ClCompile Include="tmp\moc\moc_win_help.cpp" />
<ClCompile Include="tmp\moc\moc_win_main.cpp" />
<ClCompile Include="tmp\moc\moc_win_preferences.cpp" />
<ClCompile Include="tmp\moc\moc_win_updater.cpp" />
<ClCompile Include="tmp\qrc\qrc_resources.cpp" />
<ClCompile Include="src\zero.cpp" />
<ClCompile Include="tmp\x264_launcher\MOC_input_filter.cpp" />
<ClCompile Include="tmp\x264_launcher\MOC_model_jobList.cpp" />
<ClCompile Include="tmp\x264_launcher\MOC_model_logFile.cpp" />
<ClCompile Include="tmp\x264_launcher\MOC_thread_avisynth.cpp" />
<ClCompile Include="tmp\x264_launcher\MOC_thread_encode.cpp" />
<ClCompile Include="tmp\x264_launcher\MOC_thread_ipc_send.cpp" />
<ClCompile Include="tmp\x264_launcher\MOC_thread_updater.cpp" />
<ClCompile Include="tmp\x264_launcher\MOC_thread_vapoursynth.cpp" />
<ClCompile Include="tmp\x264_launcher\MOC_tool_abstract.cpp" />
<ClCompile Include="tmp\x264_launcher\MOC_win_about.cpp" />
<ClCompile Include="tmp\x264_launcher\MOC_win_addJob.cpp" />
<ClCompile Include="tmp\x264_launcher\MOC_win_editor.cpp" />
<ClCompile Include="tmp\x264_launcher\MOC_win_help.cpp" />
<ClCompile Include="tmp\x264_launcher\MOC_win_main.cpp" />
<ClCompile Include="tmp\x264_launcher\MOC_win_preferences.cpp" />
<ClCompile Include="tmp\x264_launcher\MOC_win_updater.cpp" />
<ClCompile Include="tmp\x264_launcher\QRC_resources.cpp" />
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="x264_launcher.rc" />
@ -475,6 +481,11 @@ copy /Y "$(QTDIR)\plugins\imageformats\qgif4.dll" "$(TargetDir)\imageformats"
<ItemGroup>
<Manifest Include="etc\manifest\compat.manifest" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\MUtilities\MUtilities_VS2013.vcxproj">
<Project>{55405fe1-149f-434c-9d72-4b64348d2a08}</Project>
</ProjectReference>
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>

140
x264_launcher_MSVC2013.vcxproj.filters
View File

@ -108,6 +108,30 @@
<ClInclude Include="src\mediainfo.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="tmp\x264_launcher\UIC_win_about.h">
<Filter>Generated Files</Filter>
</ClInclude>
<ClInclude Include="tmp\x264_launcher\UIC_win_addJob.h">
<Filter>Generated Files</Filter>
</ClInclude>
<ClInclude Include="tmp\x264_launcher\UIC_win_editor.h">
<Filter>Generated Files</Filter>
</ClInclude>
<ClInclude Include="tmp\x264_launcher\UIC_win_help.h">
<Filter>Generated Files</Filter>
</ClInclude>
<ClInclude Include="tmp\x264_launcher\UIC_win_main.h">
<Filter>Generated Files</Filter>
</ClInclude>
<ClInclude Include="tmp\x264_launcher\UIC_win_preferences.h">
<Filter>Generated Files</Filter>
</ClInclude>
<ClInclude Include="tmp\x264_launcher\UIC_win_updater.h">
<Filter>Generated Files</Filter>
</ClInclude>
<ClInclude Include="src\thread_ipc_send.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="src\main.cpp">
@ -119,66 +143,36 @@
<ClCompile Include="src\win_main.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="tmp\moc\moc_win_main.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="tmp\qrc\qrc_resources.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="src\thread_encode.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="tmp\moc\moc_thread_encode.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="src\model_jobList.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="tmp\moc\moc_model_jobList.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="src\model_logFile.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="tmp\moc\moc_model_logFile.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="src\win_addJob.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="tmp\moc\moc_win_addJob.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="src\model_options.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\win_help.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="tmp\moc\moc_win_help.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="src\win_preferences.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="tmp\moc\moc_win_preferences.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="src\taskbar7.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\win_editor.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="tmp\moc\moc_win_editor.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="src\thread_avisynth.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="tmp\moc\moc_thread_avisynth.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="src\model_preferences.cpp">
<Filter>Source Files</Filter>
</ClCompile>
@ -188,21 +182,12 @@
<ClCompile Include="src\thread_vapoursynth.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="tmp\moc\moc_thread_vapoursynth.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="src\job_object.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\win_updater.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="tmp\moc\moc_win_updater.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="src\3rd_party\qtmain_win.cpp">
<Filter>Source Files\3rd Party</Filter>
</ClCompile>
<ClCompile Include="src\checksum.cpp">
<Filter>Source Files</Filter>
</ClCompile>
@ -212,18 +197,6 @@
<ClCompile Include="src\thread_updater.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="tmp\moc\moc_thread_updater.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="src\ipc.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="tmp\moc\moc_ipc.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="src\cli.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\binaries.cpp">
<Filter>Source Files</Filter>
</ClCompile>
@ -248,15 +221,9 @@
<ClCompile Include="src\source_vapoursynth.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="tmp\moc\moc_tool_abstract.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="src\win_about.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="tmp\moc\moc_win_about.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="src\encoder_factory.cpp">
<Filter>Source Files</Filter>
</ClCompile>
@ -266,7 +233,61 @@
<ClCompile Include="src\input_filter.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="tmp\moc\moc_input_filter.cpp">
<ClCompile Include="tmp\x264_launcher\MOC_input_filter.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="tmp\x264_launcher\MOC_model_logFile.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="tmp\x264_launcher\MOC_thread_avisynth.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="tmp\x264_launcher\MOC_thread_encode.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="tmp\x264_launcher\MOC_thread_updater.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="tmp\x264_launcher\MOC_thread_vapoursynth.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="tmp\x264_launcher\MOC_tool_abstract.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="tmp\x264_launcher\MOC_win_about.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="tmp\x264_launcher\MOC_win_addJob.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="tmp\x264_launcher\MOC_win_editor.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="tmp\x264_launcher\MOC_win_help.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="tmp\x264_launcher\MOC_win_main.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="tmp\x264_launcher\MOC_win_preferences.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="tmp\x264_launcher\MOC_win_updater.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="tmp\x264_launcher\QRC_resources.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="src\zero.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\thread_ipc_send.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="tmp\x264_launcher\MOC_thread_ipc_send.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
<ClCompile Include="tmp\x264_launcher\MOC_model_jobList.cpp">
<Filter>Generated Files</Filter>
</ClCompile>
</ItemGroup>
@ -328,9 +349,6 @@
<CustomBuild Include="src\thread_updater.h">
<Filter>Header Files</Filter>
</CustomBuild>
<CustomBuild Include="src\ipc.h">
<Filter>Header Files</Filter>
</CustomBuild>
<CustomBuild Include="src\tool_abstract.h">
<Filter>Header Files</Filter>
</CustomBuild>