Remove extra qualification.

[lamexp/LameXP.git] / src / Tool_Abstract.cpp

diff --git a/src/Tool_Abstract.cpp b/src/Tool_Abstract.cpp
index ef2386b..ec5aa73 100644 (file)
--- a/src/Tool_Abstract.cpp
+++ b/src/Tool_Abstract.cpp
@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 // LameXP - Audio Encoder Front-End
-// Copyright (C) 2004-2014 LoRd_MuldeR <MuldeR2@GMX.de>
+// 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
@@ -22,48 +22,64 @@
 
 #include "Tool_Abstract.h"
 
+//Internal
 #include "Global.h"
-#include "JobObject.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 vars
+ * Static Objects
  */
-quint64 AbstractTool::s_lastLaunchTime = 0ui64;
-QMutex AbstractTool::s_mutex_startProcess;
-JobObject *AbstractTool::s_jobObject = NULL;
-unsigned int AbstractTool::s_jobObjRefCount = 0U;
+QScopedPointer<MUtils::JobObject> AbstractTool::s_jobObjectInstance;
+QScopedPointer<QElapsedTimer>     AbstractTool::s_startProcessTimer;
+
+/*
+ * Synchronization
+ */
+QMutex AbstractTool::s_startProcessMutex;
+QMutex AbstractTool::s_createObjectMutex;
+
+/*
+ * Ref Counter
+ */
+quint64 AbstractTool::s_referenceCounter = 0ui64;
 
 /*
  * Const
  */
-static const unsigned int START_DELAY = 333;                                   //in milliseconds
-static const quint64 START_DELAY_NANO = START_DELAY * 1000 * 10; //in 100-nanosecond intervals
+static const qint64 START_DELAY = 64i64;       //in milliseconds
 
 /*
  * Constructor
  */
 AbstractTool::AbstractTool(void)
+:
+       m_firstLaunch(true)
+
 {
-       QMutexLocker lock(&s_mutex_startProcess);
+       QMutexLocker lock(&s_createObjectMutex);
 
-       if(s_jobObjRefCount < 1U)
+       if(s_referenceCounter++ == 0)
        {
-               s_jobObject = new JobObject();
-               s_jobObjRefCount = 1U;
-       }
-       else
-       {
-               s_jobObjRefCount++;
+               s_jobObjectInstance.reset(new MUtils::JobObject());
+               s_startProcessTimer.reset(new QElapsedTimer());
+               if(!MUtils::OS::setup_timer_resolution())
+               {
+                       qWarning("Failed to setup system timer resolution!");
+               }
        }
-
-       m_firstLaunch = true;
 }
 
 /*
@@ -71,14 +87,15 @@ AbstractTool::AbstractTool(void)
  */
 AbstractTool::~AbstractTool(void)
 {
-       QMutexLocker lock(&s_mutex_startProcess);
+       QMutexLocker lock(&s_createObjectMutex);
 
-       if(s_jobObjRefCount >= 1U)
+       if(--s_referenceCounter == 0)
        {
-               s_jobObjRefCount--;
-               if(s_jobObjRefCount < 1U)
+               s_jobObjectInstance.reset(NULL);
+               s_startProcessTimer.reset(NULL);
+               if(!MUtils::OS::reset_timer_resolution())
                {
-                       LAMEXP_DELETE(s_jobObject);
+                       qWarning("Failed to reset system timer resolution!");
                }
        }
 }
@@ -88,30 +105,36 @@ AbstractTool::~AbstractTool(void)
  */
 bool AbstractTool::startProcess(QProcess &process, const QString &program, const QStringList &args)
 {
-       QMutexLocker lock(&s_mutex_startProcess);
-
-       if(lamexp_current_file_time() <= s_lastLaunchTime)
+       QMutexLocker lock(&s_startProcessMutex);
+       
+       if((!s_startProcessTimer.isNull()) && s_startProcessTimer->isValid())
        {
-               lamexp_sleep(START_DELAY);
+               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();
+               }
        }
 
        emit messageLogged(commandline2string(program, args) + "\n");
-       lamexp_init_process(process, QFileInfo(program).absolutePath());
+       MUtils::init_process(process, QFileInfo(program).absolutePath());
 
        process.start(program, args);
        
        if(process.waitForStarted())
        {
-               if(s_jobObject)
+               if(!s_jobObjectInstance.isNull())
                {
-                       if(!s_jobObject->addProcessToJob(&process))
+                       if(!s_jobObjectInstance->addProcessToJob(&process))
                        {
                                qWarning("Failed to assign process to job object!");
                        }
                }
 
-               lamexp_change_process_priority(&process, -1);
-               lock.unlock();
+               MUtils::OS::change_process_priority(&process, -1);
                
                if(m_firstLaunch)
                {
@@ -119,7 +142,7 @@ bool AbstractTool::startProcess(QProcess &process, const QString &program, const
                        m_firstLaunch = false;
                }
                
-               s_lastLaunchTime = lamexp_current_file_time() + START_DELAY_NANO;
+               s_startProcessTimer->start();
                return true;
        }
 
@@ -130,7 +153,7 @@ bool AbstractTool::startProcess(QProcess &process, const QString &program, const
        process.kill();
        process.waitForFinished(-1);
 
-       s_lastLaunchTime = lamexp_current_file_time() + START_DELAY_NANO;
+       s_startProcessTimer->start();
        return false;
 }