///////////////////////////////////////////////////////////////////////////////
// LameXP - Audio Encoder Front-End
-// Copyright (C) 2004-2011 LoRd_MuldeR <MuldeR2@GMX.de>
+// Copyright (C) 2004-2020 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
+// 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.
+// (at your option) any later version; always including the non-optional
+// LAMEXP GNU GENERAL PUBLIC LICENSE ADDENDUM. See "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
#include "Tool_Abstract.h"
+//Internal
#include "Global.h"
+//MUtils
+#include <MUtils/Global.h>
+#include <MUtils/OSSupport.h>
+#include <MUtils/JobObject.h>
+
+//Qt
#include <QProcess>
#include <QMutex>
#include <QMutexLocker>
-#include <QLibrary>
#include <QProcessEnvironment>
#include <QDir>
+#include <QElapsedTimer>
+
+/*
+ * Static Objects
+ */
+QScopedPointer<MUtils::JobObject> AbstractTool::s_jobObjectInstance;
+QScopedPointer<QElapsedTimer> AbstractTool::s_startProcessTimer;
/*
- * Win32 API definitions
+ * Synchronization
*/
-typedef HANDLE (WINAPI *CreateJobObjectFun)(__in_opt LPSECURITY_ATTRIBUTES lpJobAttributes, __in_opt LPCSTR lpName);
-typedef BOOL (WINAPI *SetInformationJobObjectFun)(__in HANDLE hJob, __in JOBOBJECTINFOCLASS JobObjectInformationClass, __in_bcount(cbJobObjectInformationLength) LPVOID lpJobObjectInformation, __in DWORD cbJobObjectInformationLength);
-typedef BOOL (WINAPI *AssignProcessToJobObjectFun)(__in HANDLE hJob, __in HANDLE hProcess);
+QMutex AbstractTool::s_startProcessMutex;
+QMutex AbstractTool::s_createObjectMutex;
/*
- * Static vars
+ * Ref Counter
*/
-QMutex *AbstractTool::m_mutex_startProcess = NULL;
-HANDLE AbstractTool::m_handle_jobObject = NULL;
+quint64 AbstractTool::s_referenceCounter = 0ui64;
+
+/*
+ * Const
+ */
+static const qint64 START_DELAY = 64i64; //in milliseconds
/*
* Constructor
*/
AbstractTool::AbstractTool(void)
-{
- static CreateJobObjectFun CreateJobObjectPtr = NULL;
- static SetInformationJobObjectFun SetInformationJobObjectPtr = NULL;
+:
+ m_firstLaunch(true)
- if(!m_mutex_startProcess)
- {
- m_mutex_startProcess = new QMutex();
- }
+{
+ QMutexLocker lock(&s_createObjectMutex);
- if(!m_handle_jobObject)
+ if(s_referenceCounter++ == 0)
{
- if(!CreateJobObjectPtr || !SetInformationJobObjectPtr)
+ s_jobObjectInstance.reset(new MUtils::JobObject());
+ s_startProcessTimer.reset(new QElapsedTimer());
+ if(!MUtils::OS::setup_timer_resolution())
{
- QLibrary Kernel32Lib("kernel32.dll");
- CreateJobObjectPtr = (CreateJobObjectFun) Kernel32Lib.resolve("CreateJobObjectA");
- SetInformationJobObjectPtr = (SetInformationJobObjectFun) Kernel32Lib.resolve("SetInformationJobObject");
- }
- if(CreateJobObjectPtr && SetInformationJobObjectPtr)
- {
- m_handle_jobObject = CreateJobObjectPtr(NULL, NULL);
- if(m_handle_jobObject == INVALID_HANDLE_VALUE)
- {
- m_handle_jobObject = NULL;
- }
- if(m_handle_jobObject)
- {
- JOBOBJECT_EXTENDED_LIMIT_INFORMATION jobExtendedLimitInfo;
- memset(&jobExtendedLimitInfo, 0, sizeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION));
- jobExtendedLimitInfo.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE | JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION;
- SetInformationJobObjectPtr(m_handle_jobObject, JobObjectExtendedLimitInformation, &jobExtendedLimitInfo, sizeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION));
- }
+ qWarning("Failed to setup system timer resolution!");
}
}
-
- m_firstLaunch = true;
}
/*
*/
AbstractTool::~AbstractTool(void)
{
+ QMutexLocker lock(&s_createObjectMutex);
+
+ if(--s_referenceCounter == 0)
+ {
+ s_jobObjectInstance.reset(NULL);
+ s_startProcessTimer.reset(NULL);
+ if(!MUtils::OS::reset_timer_resolution())
+ {
+ qWarning("Failed to reset system timer resolution!");
+ }
+ }
}
/*
* Initialize and launch process object
*/
-bool AbstractTool::startProcess(QProcess &process, const QString &program, const QStringList &args)
+bool AbstractTool::startProcess(QProcess &process, const QString &program, const QStringList &args, const QString &workingDir)
{
- static AssignProcessToJobObjectFun AssignProcessToJobObjectPtr = NULL;
-
- QMutexLocker lock(m_mutex_startProcess);
- emit messageLogged(commandline2string(program, args) + "\n");
-
- QProcessEnvironment env = process.processEnvironment();
- if(env.isEmpty()) env = QProcessEnvironment::systemEnvironment();
- env.insert("TEMP", QDir::toNativeSeparators(lamexp_temp_folder2()));
- env.insert("TMP", QDir::toNativeSeparators(lamexp_temp_folder2()));
- process.setProcessEnvironment(env);
+ QMutexLocker lock(&s_startProcessMutex);
- if(!AssignProcessToJobObjectPtr)
+ if((!s_startProcessTimer.isNull()) && s_startProcessTimer->isValid())
{
- QLibrary Kernel32Lib("kernel32.dll");
- AssignProcessToJobObjectPtr = (AssignProcessToJobObjectFun) Kernel32Lib.resolve("AssignProcessToJobObject");
+ qint64 elapsed = s_startProcessTimer->elapsed();
+ while(elapsed < START_DELAY)
+ {
+ lock.unlock();
+ MUtils::OS::sleep_ms((size_t)(START_DELAY - elapsed));
+ lock.relock();
+ elapsed = s_startProcessTimer->elapsed();
+ }
}
-
- process.setProcessChannelMode(QProcess::MergedChannels);
- process.setReadChannel(QProcess::StandardOutput);
+
+ emit messageLogged(commandline2string(program, args) + "\n");
+ MUtils::init_process(process, workingDir.isEmpty() ? QFileInfo(program).absolutePath() : workingDir);
+
process.start(program, args);
if(process.waitForStarted())
{
-
- if(AssignProcessToJobObjectPtr)
+ if(!s_jobObjectInstance.isNull())
{
- AssignProcessToJobObjectPtr(m_handle_jobObject, process.pid()->hProcess);
- }
- if(!SetPriorityClass(process.pid()->hProcess, BELOW_NORMAL_PRIORITY_CLASS))
- {
- SetPriorityClass(process.pid()->hProcess, IDLE_PRIORITY_CLASS);
+ if(!s_jobObjectInstance->addProcessToJob(&process))
+ {
+ qWarning("Failed to assign process to job object!");
+ }
}
-
- lock.unlock();
+
+ MUtils::OS::change_process_priority(&process, -1);
if(m_firstLaunch)
{
m_firstLaunch = false;
}
+ s_startProcessTimer->start();
return true;
}
process.kill();
process.waitForFinished(-1);
+
+ s_startProcessTimer->start();
return false;
}
/*
- * Convert program arguments to single string
- */
-QString AbstractTool::commandline2string(const QString &program, const QStringList &arguments)
+* Wait for process to terminate while processing its output
+*/
+AbstractTool::result_t AbstractTool::awaitProcess(QProcess &process, QAtomicInt &abortFlag, int *const exitCode)
{
- QString commandline = (program.contains(' ') ? QString("\"%1\"").arg(program) : program);
-
- for(int i = 0; i < arguments.count(); i++)
+ return awaitProcess(process, abortFlag, [](const QString &text) { return false; }, exitCode);
+}
+
+/*
+* Wait for process to terminate while processing its output
+*/
+AbstractTool::result_t AbstractTool::awaitProcess(QProcess &process, QAtomicInt &abortFlag, std::function<bool(const QString &text)> &&handler, int *const exitCode)
+{
+ bool bTimeout = false;
+ bool bAborted = false;
+
+ QString lastText;
+
+ while (process.state() != QProcess::NotRunning)
{
- commandline += (arguments.at(i).contains(' ') ? QString(" \"%1\"").arg(arguments.at(i)) : QString(" %1").arg(arguments.at(i)));
+ if (CHECK_FLAG(abortFlag))
+ {
+ process.kill();
+ bAborted = true;
+ emit messageLogged("\nABORTED BY USER !!!");
+ break;
+ }
+
+ process.waitForReadyRead(m_processTimeoutInterval);
+ if (!process.bytesAvailable() && process.state() == QProcess::Running)
+ {
+ process.kill();
+ qWarning("Tool process timed out <-- killing!");
+ emit messageLogged("\nPROCESS TIMEOUT !!!");
+ bTimeout = true;
+ break;
+ }
+
+ while (process.bytesAvailable() > 0)
+ {
+ QByteArray line = process.readLine();
+ if (line.size() > 0)
+ {
+ line.replace('\r', char(0x20)).replace('\b', char(0x20)).replace('\t', char(0x20));
+ const QString text = QString::fromUtf8(line.constData()).simplified();
+ if (!text.isEmpty())
+ {
+ if (!handler(text))
+ {
+ if (text.compare(lastText, Qt::CaseInsensitive) != 0)
+ {
+ emit messageLogged(lastText = text);
+ }
+ }
+ }
+ }
+ }
}
- return commandline;
+ process.waitForFinished();
+ if (process.state() != QProcess::NotRunning)
+ {
+ process.kill();
+ process.waitForFinished(-1);
+ }
+
+ if (exitCode)
+ {
+ *exitCode = process.exitCode();
+ }
+
+ emit messageLogged(QString().sprintf("\nExited with code: 0x%04X", process.exitCode()));
+ if (!(bAborted || bTimeout)) emit statusUpdated(100);
+
+ if (bAborted || bTimeout || (process.exitCode() != EXIT_SUCCESS))
+ {
+ return bAborted ? RESULT_ABORTED : (bTimeout ? RESULT_TIMEOUT : RESULT_FAILURE);
+ }
+
+ return RESULT_SUCCESS;
}
/*
- * Convert long path to short path
+ * Convert program arguments to single string
*/
-QString AbstractTool::pathToShort(const QString &longPath)
+QString AbstractTool::commandline2string(const QString &program, const QStringList &arguments)
{
- QString shortPath;
- DWORD buffSize = GetShortPathNameW(reinterpret_cast<const wchar_t*>(longPath.utf16()), NULL, NULL);
+ QString commandline = (program.contains(' ') ? QString("\"%1\"").arg(program) : program);
- if(buffSize > 0)
+ for(int i = 0; i < arguments.count(); i++)
{
- wchar_t *buffer = new wchar_t[buffSize];
- DWORD result = GetShortPathNameW(reinterpret_cast<const wchar_t*>(longPath.utf16()), buffer, buffSize);
-
- if(result > 0 && result < buffSize)
- {
- shortPath = QString::fromUtf16(reinterpret_cast<const unsigned short*>(buffer));
- }
-
- delete[] buffer;
+ commandline += (arguments.at(i).contains(' ') ? QString(" \"%1\"").arg(arguments.at(i)) : QString(" %1").arg(arguments.at(i)));
}
- return (shortPath.isEmpty() ? longPath : shortPath);
+ return commandline;
}
+
OSDN Git Service
