diff --git a/modules/system/CMakeLists.txt b/modules/system/CMakeLists.txt
index 4c487fb5ac7ac85a3d0591ac03365291a00d53e5..16e5fb3464f0eb1f08871f8fefce2b5354374ac1 100755
--- a/modules/system/CMakeLists.txt
+++ b/modules/system/CMakeLists.txt
@@ -47,8 +47,14 @@ ENDIF(UNIX)
INCLUDE("FindOpenViBECommon")
-INCLUDE("FindThirdPartyBoost")
-INCLUDE("FindThirdPartyBoost_Chrono")
+IF(WIN32 AND CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS "19.0")
+ INCLUDE("FindThirdPartyBoost")
+ OV_LINK_BOOST_LIB("system" ${OV_WIN32_BOOST_VERSION})
+ OV_LINK_BOOST_LIB("thread" ${OV_WIN32_BOOST_VERSION})
+ INCLUDE("FindThirdPartyBoost_Chrono")
+ENDIF(WIN32)
+
+
# ---------------------------------
# Finds standard library winmm
diff --git a/modules/system/include/system/ovCTime.h b/modules/system/include/system/ovCTime.h
index 86b587ba524751dee45bed492317bb2e5fba03c9..be4c4b4215dfadf0c49d1d4da9328b42b9c3e6ea 100644
--- a/modules/system/include/system/ovCTime.h
+++ b/modules/system/include/system/ovCTime.h
@@ -20,26 +20,26 @@ namespace System
* \param ui32MilliSeconds : sleep duration in ms
* \return Always true
*/
- static bool sleep(const System::uint32 ui32MilliSeconds);
+ static bool sleep(const uint32_t ui32MilliSeconds);
/**
* \brief Make the calling thread sleep
* \param ui64Seconds : sleep duration in fixed point 32:32 seconds
* \return Always true
*/
- static bool zsleep(const System::uint64 ui64Seconds);
+ static bool zsleep(const uint64_t ui64Seconds);
/**
* \brief Retrieve time in ms
* \return Elpased time in ms since the first call to this function or zgetTime
*/
- static System::uint32 getTime(void);
+ static uint32_t getTime(void);
/**
* \brief Retrieve time in fixed point 32:32 seconds
* \return Elpased time since the first call to the function or getTime
*/
- static System::uint64 zgetTime(void);
+ static uint64_t zgetTime(void);
/**
* \brief Check if the internal clock used by the framework is steady
@@ -57,7 +57,7 @@ namespace System
* \note This is a theoretical check that queries the internal
* clock implementation for available services
*/
- static bool checkResolution(const System::uint32 ui32MilliSeconds);
+ static bool checkResolution(const uint32_t ui32MilliSeconds);
private:
diff --git a/modules/system/src/ovCTime.cpp b/modules/system/src/ovCTime.cpp
index 9c74ff867fbef7a7acde13b91c6d401ae0ca58ff..001a3a13c7a061b037d2d753f57db098d843c199 100644
--- a/modules/system/src/ovCTime.cpp
+++ b/modules/system/src/ovCTime.cpp
@@ -12,59 +12,56 @@
// time handling strategy selection
// \note With officialy supported compilers and required boost version
// it should never fallback in a OV_USE_SYSTEM case
-#if (defined(_MSC_VER) && _MSC_VER <= 1800)
-
-#ifdef TARGET_HAS_Boost_Chrono
+#if (defined(_MSC_VER) && _MSC_VER <= 1800 && defined(TARGET_HAS_Boost_Chrono))
#include <boost/chrono/config.hpp>
#ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
-#include <chrono>
-#include <thread>
-using namespace std;
+#include <boost/chrono.hpp>
+#include <boost/thread.hpp>
+namespace timelib = boost;
+#else
+#error "Please use OpenViBE recommended version of Boost"
#endif // BOOST_CHRONO_HAS_CLOCK_STEADY
-#endif // TARGET_HAS_Boost_Chrono
-
-#else // defined(_MSC_VER) && _MSC_VER <= 1800
+#else // defined(_MSC_VER) && _MSC_VER <= 1800 && defined(TARGET_HAS_Boost_Chrono)
#include <chrono>
#include <thread>
-using namespace std;
+namespace timelib = std;
-#endif // defined(_MSC_VER) && _MSC_VER <= 1800
+#endif // defined(_MSC_VER) && _MSC_VER <= 1800 && defined(TARGET_HAS_Boost_Chrono)
-using internal_clock = chrono::steady_clock;
+using internal_clock = timelib::chrono::steady_clock;
+// using internal_clock = chrono::high_resolution_clock;
-bool System::Time::sleep(const uint32 ui32MilliSeconds)
+bool System::Time::sleep(const uint32_t ui32MilliSeconds)
{
- this_thread::sleep_for(chrono::milliseconds(ui32MilliSeconds));
-
+ timelib::this_thread::sleep_for(timelib::chrono::milliseconds(ui32MilliSeconds));
return true;
}
-bool System::Time::zsleep(const uint64 ui64Seconds)
+bool System::Time::zsleep(const uint64_t ui64Seconds)
{
- const uint32 l_ui32Seconds = static_cast<uint32>(ui64Seconds >> 32);
+ const uint32_t l_ui32Seconds = static_cast<uint32_t>(ui64Seconds >> 32);
// zero the seconds with 0xFFFFFFFF, multiply to get the rest as fixed point microsec, then grab them (now in the 32 msbs)
- const uint64 l_ui64MicroSeconds = ((ui64Seconds & 0xFFFFFFFFLL) * 1000000LL) >> 32;
-
- chrono::microseconds l_oDuration = chrono::seconds(l_ui32Seconds) + chrono::microseconds(l_ui64MicroSeconds);
+ const uint64_t l_ui64MicroSeconds = ((ui64Seconds & 0xFFFFFFFFLL) * 1000000LL) >> 32;
- this_thread::sleep_for(l_oDuration);
+ const timelib::chrono::microseconds l_oDuration = timelib::chrono::seconds(l_ui32Seconds) + timelib::chrono::microseconds(l_ui64MicroSeconds);
+ timelib::this_thread::sleep_for(l_oDuration);
return true;
}
-System::uint32 System::Time::getTime(void)
+uint32_t System::Time::getTime(void)
{
// turn the 32:32 fixed point seconds to milliseconds
- return static_cast<uint32>((zgetTime() * 1000) >> 32);
+ return static_cast<uint32_t>((zgetTime() * 1000) >> 32);
}
-System::uint64 System::Time::zgetTime(void)
+uint64_t System::Time::zgetTime(void)
{
static bool l_bInitialized = false;
static internal_clock::time_point l_oTimeStart;
@@ -79,10 +76,9 @@ System::uint64 System::Time::zgetTime(void)
const internal_clock::duration l_oElapsed = l_oTimeNow - l_oTimeStart;
- const chrono::microseconds l_oElapsedMs = chrono::duration_cast<chrono::microseconds>(l_oElapsed);
+ const timelib::chrono::microseconds l_oElapsedMs = timelib::chrono::duration_cast<timelib::chrono::microseconds>(l_oElapsed);
const uint64_t l_ui64MicrosPerSecond = 1000ULL * 1000ULL;
-
const uint64_t l_ui64Seconds = static_cast<uint64_t>(l_oElapsedMs.count() / l_ui64MicrosPerSecond);
const uint64_t l_ui64Fraction = static_cast<uint64_t>(l_oElapsedMs.count() % l_ui64MicrosPerSecond);
@@ -97,11 +93,10 @@ bool System::Time::isClockSteady()
return internal_clock::is_steady;
}
-bool System::Time::checkResolution(const System::uint32 ui32MilliSeconds)
+bool System::Time::checkResolution(const uint32_t ui32MilliSeconds)
{
assert(ui32MilliSeconds != 0);
auto l_ui32Resolution = static_cast<System::float64>(internal_clock::period::num) / internal_clock::period::den;
-
- return (static_cast<System::uint32>(std::ceil(l_ui32Resolution * 1000)) <= ui32MilliSeconds);
+ return (static_cast<uint32_t>(std::ceil(l_ui32Resolution * 1000)) <= ui32MilliSeconds);
}
diff --git a/plugins/processing/signal-processing/src/box-algorithms/basic/ovpCBoxAlgorithmSignalDecimation.cpp b/plugins/processing/signal-processing/src/box-algorithms/basic/ovpCBoxAlgorithmSignalDecimation.cpp
index ec26f93833324706da3999b7e52e78484c19d0fe..2617871f628adb038734eba8e72b71c3cdfbceb2 100644
--- a/plugins/processing/signal-processing/src/box-algorithms/basic/ovpCBoxAlgorithmSignalDecimation.cpp
+++ b/plugins/processing/signal-processing/src/box-algorithms/basic/ovpCBoxAlgorithmSignalDecimation.cpp
@@ -11,13 +11,12 @@ using namespace OpenViBE::Plugins;
using namespace OpenViBEPlugins;
using namespace OpenViBEPlugins::SignalProcessing;
-boolean CBoxAlgorithmSignalDecimation::initialize(void)
+bool CBoxAlgorithmSignalDecimation::initialize(void)
{
m_pStreamDecoder=NULL;
m_pStreamEncoder=NULL;
m_i64DecimationFactor=FSettingValueAutoCast(*this->getBoxAlgorithmContext(), 0);
-
OV_ERROR_UNLESS_KRF(
m_i64DecimationFactor > 1,
"Invalid decimation factor [" << m_i64DecimationFactor << "] (expected value > 1)",
@@ -41,16 +40,19 @@ boolean CBoxAlgorithmSignalDecimation::initialize(void)
m_ui32ChannelCount=0;
m_ui32InputSampleIndex=0;
m_ui32InputSampleCountPerSentBlock=0;
+ m_ui64OutputSamplingFrequency = 0;
m_ui32OutputSampleIndex=0;
m_ui32OutputSampleCountPerSentBlock=0;
m_ui64TotalSampleCount=0;
+ m_ui64StartTimeBase = 0;
m_ui64LastStartTime=0;
+ m_ui64LastEndTime = 0;
return true;
}
-boolean CBoxAlgorithmSignalDecimation::uninitialize(void)
+bool CBoxAlgorithmSignalDecimation::uninitialize(void)
{
op_pMemoryBuffer.uninitialize();
ip_pMatrix.uninitialize();
@@ -77,25 +79,24 @@ boolean CBoxAlgorithmSignalDecimation::uninitialize(void)
return true;
}
-boolean CBoxAlgorithmSignalDecimation::processInput(uint32 ui32InputIndex)
+bool CBoxAlgorithmSignalDecimation::processInput(uint32_t ui32InputIndex)
{
getBoxAlgorithmContext()->markAlgorithmAsReadyToProcess();
return true;
}
-boolean CBoxAlgorithmSignalDecimation::process(void)
+bool CBoxAlgorithmSignalDecimation::process(void)
{
// IBox& l_rStaticBoxContext=this->getStaticBoxContext();
IBoxIO& l_rDynamicBoxContext=this->getDynamicBoxContext();
- uint32 i, j, k;
- for(i=0; i<l_rDynamicBoxContext.getInputChunkCount(0); i++)
+ for(uint32_t i = 0; i < l_rDynamicBoxContext.getInputChunkCount(0); i++)
{
ip_pMemoryBuffer=l_rDynamicBoxContext.getInputChunk(0, i);
op_pMemoryBuffer=l_rDynamicBoxContext.getOutputChunk(0);
- uint64 l_ui64StartTime=l_rDynamicBoxContext.getInputChunkStartTime(0, i);
- uint64 l_ui64EndTime=l_rDynamicBoxContext.getInputChunkEndTime(0, i);
+ uint64_t l_ui64StartTime=l_rDynamicBoxContext.getInputChunkStartTime(0, i);
+ uint64_t l_ui64EndTime=l_rDynamicBoxContext.getInputChunkEndTime(0, i);
if(l_ui64StartTime!=m_ui64LastEndTime)
{
@@ -122,7 +123,7 @@ boolean CBoxAlgorithmSignalDecimation::process(void)
);
m_ui32OutputSampleIndex=0;
- m_ui32OutputSampleCountPerSentBlock=(uint32)(m_ui32InputSampleCountPerSentBlock/m_i64DecimationFactor);
+ m_ui32OutputSampleCountPerSentBlock = static_cast<uint32_t>(m_ui32InputSampleCountPerSentBlock/m_i64DecimationFactor);
m_ui32OutputSampleCountPerSentBlock=(m_ui32OutputSampleCountPerSentBlock?m_ui32OutputSampleCountPerSentBlock:1);
m_ui64OutputSamplingFrequency=op_ui64SamplingRate/m_i64DecimationFactor;
@@ -148,11 +149,11 @@ boolean CBoxAlgorithmSignalDecimation::process(void)
float64* l_pInputBuffer=op_pMatrix->getBuffer();
float64* l_pOutputBuffer=ip_pMatrix->getBuffer()+m_ui32OutputSampleIndex;
- for(j=0; j<m_ui32InputSampleCountPerSentBlock; j++)
+ for(uint32_t j = 0; j < m_ui32InputSampleCountPerSentBlock; j++)
{
float64* l_pInputBufferTmp=l_pInputBuffer;
float64* l_pOutputBufferTmp=l_pOutputBuffer;
- for(k=0; k<m_ui32ChannelCount; k++)
+ for(uint32_t k = 0; k < m_ui32ChannelCount; k++)
{
*l_pOutputBufferTmp+=*l_pInputBufferTmp;
l_pOutputBufferTmp+=m_ui32OutputSampleCountPerSentBlock;
@@ -164,7 +165,7 @@ boolean CBoxAlgorithmSignalDecimation::process(void)
{
m_ui32InputSampleIndex=0;
float64* l_pOutputBufferTmp=l_pOutputBuffer;
- for(k=0; k<m_ui32ChannelCount; k++)
+ for(uint32_t k = 0; k < m_ui32ChannelCount; k++)
{
*l_pOutputBufferTmp/=m_i64DecimationFactor;
l_pOutputBufferTmp+=m_ui32OutputSampleCountPerSentBlock;
@@ -178,8 +179,8 @@ boolean CBoxAlgorithmSignalDecimation::process(void)
l_pOutputBuffer=ip_pMatrix->getBuffer();
m_ui32OutputSampleIndex=0;
m_pStreamEncoder->process(OVP_GD_Algorithm_SignalStreamEncoder_InputTriggerId_EncodeBuffer);
- uint64 l_ui64SampleStartTime = m_ui64StartTimeBase + ITimeArithmetics::sampleCountToTime(m_ui64OutputSamplingFrequency, m_ui64TotalSampleCount);
- uint64 l_ui64SampleEndTime = m_ui64StartTimeBase + ITimeArithmetics::sampleCountToTime(m_ui64OutputSamplingFrequency, m_ui64TotalSampleCount + m_ui32OutputSampleCountPerSentBlock);
+ uint64_t l_ui64SampleStartTime = m_ui64StartTimeBase + ITimeArithmetics::sampleCountToTime(m_ui64OutputSamplingFrequency, m_ui64TotalSampleCount);
+ uint64_t l_ui64SampleEndTime = m_ui64StartTimeBase + ITimeArithmetics::sampleCountToTime(m_ui64OutputSamplingFrequency, m_ui64TotalSampleCount + m_ui32OutputSampleCountPerSentBlock);
l_rDynamicBoxContext.markOutputAsReadyToSend(0, l_ui64SampleStartTime, l_ui64SampleEndTime);
m_ui64TotalSampleCount+=m_ui32OutputSampleCountPerSentBlock;
diff --git a/plugins/processing/signal-processing/src/box-algorithms/basic/ovpCBoxAlgorithmSignalDecimation.h b/plugins/processing/signal-processing/src/box-algorithms/basic/ovpCBoxAlgorithmSignalDecimation.h
index fc0cfd923d234333600c493b35b453072f2104c2..f676953a31974d7072fb9cec09d4afeae2156275 100644
--- a/plugins/processing/signal-processing/src/box-algorithms/basic/ovpCBoxAlgorithmSignalDecimation.h
+++ b/plugins/processing/signal-processing/src/box-algorithms/basic/ovpCBoxAlgorithmSignalDecimation.h
@@ -17,36 +17,36 @@ namespace OpenViBEPlugins
virtual void release(void) { delete this; }
- virtual OpenViBE::boolean initialize(void);
- virtual OpenViBE::boolean uninitialize(void);
- virtual OpenViBE::boolean processInput(OpenViBE::uint32 ui32InputIndex);
- virtual OpenViBE::boolean process(void);
+ virtual bool initialize(void);
+ virtual bool uninitialize(void);
+ virtual bool processInput(uint32_t ui32InputIndex);
+ virtual bool process(void);
_IsDerivedFromClass_Final_(OpenViBEToolkit::TBoxAlgorithm < OpenViBE::Plugins::IBoxAlgorithm >, OVP_ClassId_BoxAlgorithm_SignalDecimation);
protected:
- OpenViBE::int64 m_i64DecimationFactor;
- OpenViBE::uint32 m_ui32ChannelCount;
- OpenViBE::uint32 m_ui32InputSampleIndex;
- OpenViBE::uint32 m_ui32InputSampleCountPerSentBlock;
- OpenViBE::uint64 m_ui64InputSamplingFrequency;
- OpenViBE::uint32 m_ui32OutputSampleIndex;
- OpenViBE::uint32 m_ui32OutputSampleCountPerSentBlock;
- OpenViBE::uint64 m_ui64OutputSamplingFrequency;
+ int64_t m_i64DecimationFactor;
+ uint32_t m_ui32ChannelCount;
+ uint32_t m_ui32InputSampleIndex;
+ uint32_t m_ui32InputSampleCountPerSentBlock;
+ uint64_t m_ui64InputSamplingFrequency;
+ uint32_t m_ui32OutputSampleIndex;
+ uint32_t m_ui32OutputSampleCountPerSentBlock;
+ uint64_t m_ui64OutputSamplingFrequency;
- OpenViBE::uint64 m_ui64TotalSampleCount;
- OpenViBE::uint64 m_ui64StartTimeBase;
- OpenViBE::uint64 m_ui64LastStartTime;
- OpenViBE::uint64 m_ui64LastEndTime;
+ uint64_t m_ui64TotalSampleCount;
+ uint64_t m_ui64StartTimeBase;
+ uint64_t m_ui64LastStartTime;
+ uint64_t m_ui64LastEndTime;
OpenViBE::Kernel::IAlgorithmProxy* m_pStreamDecoder;
OpenViBE::Kernel::TParameterHandler < const OpenViBE::IMemoryBuffer* > ip_pMemoryBuffer;
OpenViBE::Kernel::TParameterHandler < OpenViBE::IMatrix* > op_pMatrix;
- OpenViBE::Kernel::TParameterHandler < OpenViBE::uint64 > op_ui64SamplingRate;
+ OpenViBE::Kernel::TParameterHandler < uint64_t > op_ui64SamplingRate;
OpenViBE::Kernel::IAlgorithmProxy* m_pStreamEncoder;
- OpenViBE::Kernel::TParameterHandler < OpenViBE::uint64 > ip_ui64SamplingRate;
+ OpenViBE::Kernel::TParameterHandler < uint64_t > ip_ui64SamplingRate;
OpenViBE::Kernel::TParameterHandler < OpenViBE::IMatrix* > ip_pMatrix;
OpenViBE::Kernel::TParameterHandler < OpenViBE::IMemoryBuffer* > op_pMemoryBuffer;
};
@@ -71,7 +71,7 @@ namespace OpenViBEPlugins
virtual OpenViBE::CIdentifier getCreatedClass(void) const { return OVP_ClassId_BoxAlgorithm_SignalDecimation; }
virtual OpenViBE::Plugins::IPluginObject* create(void) { return new OpenViBEPlugins::SignalProcessing::CBoxAlgorithmSignalDecimation; }
- virtual OpenViBE::boolean getBoxPrototype(
+ virtual bool getBoxPrototype(
OpenViBE::Kernel::IBoxProto& rBoxAlgorithmPrototype) const
{
rBoxAlgorithmPrototype.addInput ("Input signal", OV_TypeId_Signal);