musicdsp/audio-algo-chunkware
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: musicdsp:7cdc3856baaf0ef1b9c8e55ffaf0e44a3ca47b5e
Branches Tags
musicdsp:main
musicdsp:dev
musicdsp:v1.0.0
musicdsp:0.2.0
musicdsp:0.1.1
musicdsp:0.1.0
..
compare: musicdsp:1be102a51c4db4cb863700c008af2001d49b01d2
Branches Tags
musicdsp:dev
musicdsp:main
musicdsp:v1.0.0
musicdsp:0.2.0
musicdsp:0.1.1
musicdsp:0.1.0

8 Commits
7cdc3856ba ... 1be102a51c

Author SHA1 Message Date
Edouard DUPIN
1be102a51c [RELEASE] Release v1.0.0 2021-02-16 21:47:38 +01:00
Edouard DUPIN
4446c24e07 [DEBUG] build is back 2017-11-07 13:38:04 +01:00
Edouard DUPIN
b56fd19a20 [DEV] update new ETK 2017-09-26 15:57:44 +02:00
Edouard DUPIN
58e843f8aa [DEV] continue removing STL 2017-09-14 00:59:21 +02:00
Edouard DUPIN
005f102253 [DEV] remove STL 2017-09-07 23:38:26 +02:00
Edouard DUPIN
484e81e834 [DEV] continue removing stl 2017-08-28 00:07:23 +02:00
Edouard DUPIN
e8778a51aa Change corent licence file 2017-01-05 21:28:23 +01:00
Edouard DUPIN
180b94ab7c [DEV] update dev tag version 2016-10-23 18:32:22 +02:00
10 changed files with 103 additions and 103 deletions
Show Stats Expand all files Collapse all files

0
license.txt → LICENSE
View File

18
audio/algo/chunkware/Compressor.cpp
View File

@ -49,15 +49,15 @@ void audio::algo::chunkware::Compressor::init() {
m_isConfigured = true; m_isConfigured = true;
} }
std::vector<enum audio::format> audio::algo::chunkware::Compressor::getSupportedFormat() { etk::Vector<enum audio::format> audio::algo::chunkware::Compressor::getSupportedFormat() {
std::vector<enum audio::format> out = getNativeSupportedFormat(); etk::Vector<enum audio::format> out = getNativeSupportedFormat();
out.push_back(audio::format_int16); out.pushBack(audio::format_int16);
return out; return out;
} }
std::vector<enum audio::format> audio::algo::chunkware::Compressor::getNativeSupportedFormat() { etk::Vector<enum audio::format> audio::algo::chunkware::Compressor::getNativeSupportedFormat() {
std::vector<enum audio::format> out; etk::Vector<enum audio::format> out;
out.push_back(audio::format_double); out.pushBack(audio::format_double);
return out; return out;
} }
@ -82,7 +82,7 @@ void audio::algo::chunkware::Compressor::process(void* _output, const void* _inp
processDouble(vals, vals, _nbChannel); processDouble(vals, vals, _nbChannel);
for (int8_t kkk=0; kkk<_nbChannel ; ++kkk) { for (int8_t kkk=0; kkk<_nbChannel ; ++kkk) {
vals[kkk] *= 32768.0; vals[kkk] *= 32768.0;
output[iii*_nbChannel+kkk] = int16_t(std::avg(-32768.0, vals[kkk], 32767.0)); output[iii*_nbChannel+kkk] = int16_t(etk::avg(-32768.0, vals[kkk], 32767.0));
} }
} }
} }
@ -108,8 +108,8 @@ void audio::algo::chunkware::Compressor::processDouble(double* _out, const doubl
double keyLink = 0; double keyLink = 0;
// get greater value; // get greater value;
for (int8_t iii=0; iii<_nbChannel; ++iii) { for (int8_t iii=0; iii<_nbChannel; ++iii) {
double absValue = std::abs(_in[iii]); double absValue = etk::abs(_in[iii]);
keyLink = std::max(keyLink, absValue); keyLink = etk::max(keyLink, absValue);
} }
processDouble(_out, _in, _nbChannel, keyLink); processDouble(_out, _in, _nbChannel, keyLink);
} }

4
audio/algo/chunkware/Compressor.hpp
View File

@ -47,12 +47,12 @@ namespace audio {
* @brief Get list of format suported in input. * @brief Get list of format suported in input.
* @return list of supported format * @return list of supported format
*/ */
virtual std::vector<enum audio::format> getSupportedFormat(); virtual etk::Vector<enum audio::format> getSupportedFormat();
/** /**
* @brief Get list of algorithm format suported. No format convertion. * @brief Get list of algorithm format suported. No format convertion.
* @return list of supported format * @return list of supported format
*/ */
virtual std::vector<enum audio::format> getNativeSupportedFormat(); virtual etk::Vector<enum audio::format> getNativeSupportedFormat();
/** /**
* @brief Main input algo process. * @brief Main input algo process.
* @param[in,out] _output Output data. * @param[in,out] _output Output data.

18
audio/algo/chunkware/Gate.cpp
View File

@ -47,15 +47,15 @@ void audio::algo::chunkware::Gate::init() {
m_isConfigured = true; m_isConfigured = true;
} }
std::vector<enum audio::format> audio::algo::chunkware::Gate::getSupportedFormat() { etk::Vector<enum audio::format> audio::algo::chunkware::Gate::getSupportedFormat() {
std::vector<enum audio::format> out = getNativeSupportedFormat(); etk::Vector<enum audio::format> out = getNativeSupportedFormat();
out.push_back(audio::format_int16); out.pushBack(audio::format_int16);
return out; return out;
} }
std::vector<enum audio::format> audio::algo::chunkware::Gate::getNativeSupportedFormat() { etk::Vector<enum audio::format> audio::algo::chunkware::Gate::getNativeSupportedFormat() {
std::vector<enum audio::format> out; etk::Vector<enum audio::format> out;
out.push_back(audio::format_double); out.pushBack(audio::format_double);
return out; return out;
} }
@ -77,7 +77,7 @@ void audio::algo::chunkware::Gate::process(void* _output, const void* _input, si
processDouble(vals, vals, _nbChannel); processDouble(vals, vals, _nbChannel);
for (int8_t kkk=0; kkk<_nbChannel ; ++kkk) { for (int8_t kkk=0; kkk<_nbChannel ; ++kkk) {
vals[kkk] *= 32768.0; vals[kkk] *= 32768.0;
output[iii*_nbChannel+kkk] = int16_t(std::avg(-32768.0, vals[kkk], 32767.0)); output[iii*_nbChannel+kkk] = int16_t(etk::avg(-32768.0, vals[kkk], 32767.0));
} }
} }
} }
@ -103,8 +103,8 @@ void audio::algo::chunkware::Gate::processDouble(double* _out, const double* _in
double keyLink = 0; double keyLink = 0;
// get greater value; // get greater value;
for (int8_t iii=0; iii<_nbChannel; ++iii) { for (int8_t iii=0; iii<_nbChannel; ++iii) {
double absValue = std::abs(_in[iii]); double absValue = etk::abs(_in[iii]);
keyLink = std::max(keyLink, absValue); keyLink = etk::max(keyLink, absValue);
} }
processDouble(_out, _in, _nbChannel, keyLink); processDouble(_out, _in, _nbChannel, keyLink);
} }

4
audio/algo/chunkware/Gate.hpp
View File

@ -47,12 +47,12 @@ namespace audio {
* @brief Get list of format suported in input. * @brief Get list of format suported in input.
* @return list of supported format * @return list of supported format
*/ */
virtual std::vector<enum audio::format> getSupportedFormat(); virtual etk::Vector<enum audio::format> getSupportedFormat();
/** /**
* @brief Get list of algorithm format suported. No format convertion. * @brief Get list of algorithm format suported. No format convertion.
* @return list of supported format * @return list of supported format
*/ */
virtual std::vector<enum audio::format> getNativeSupportedFormat(); virtual etk::Vector<enum audio::format> getNativeSupportedFormat();
/** /**
* @brief Main input algo process. * @brief Main input algo process.
* @param[in,out] _output Output data. * @param[in,out] _output Output data.

21
audio/algo/chunkware/Limiter.cpp
View File

@ -74,25 +74,24 @@ void audio::algo::chunkware::Limiter::init(int8_t _nbChannel) {
m_outputBuffer.resize(_nbChannel); m_outputBuffer.resize(_nbChannel);
for (int8_t iii=0; iii<_nbChannel; ++iii) { for (int8_t iii=0; iii<_nbChannel; ++iii) {
m_outputBuffer[iii].resize(BUFFER_SIZE, 0.0); m_outputBuffer[iii].resize(BUFFER_SIZE, 0.0);
m_outputBuffer[iii].assign(BUFFER_SIZE, 0.0);
} }
m_isConfigured = true; m_isConfigured = true;
} }
void audio::algo::chunkware::FastEnvelope::setCoef() { void audio::algo::chunkware::FastEnvelope::setCoef() {
// rises to 99% of in value over duration of time constant // rises to 99% of in value over duration of time constant
m_coefficient = std::pow(0.01, (1000.0 / (m_timeMs * m_sampleRate))); m_coefficient = etk::pow(0.01, (1000.0 / (m_timeMs * m_sampleRate)));
} }
std::vector<enum audio::format> audio::algo::chunkware::Limiter::getSupportedFormat() { etk::Vector<enum audio::format> audio::algo::chunkware::Limiter::getSupportedFormat() {
std::vector<enum audio::format> out = getNativeSupportedFormat(); etk::Vector<enum audio::format> out = getNativeSupportedFormat();
out.push_back(audio::format_int16); out.pushBack(audio::format_int16);
return out; return out;
} }
std::vector<enum audio::format> audio::algo::chunkware::Limiter::getNativeSupportedFormat() { etk::Vector<enum audio::format> audio::algo::chunkware::Limiter::getNativeSupportedFormat() {
std::vector<enum audio::format> out; etk::Vector<enum audio::format> out;
out.push_back(audio::format_double); out.pushBack(audio::format_double);
return out; return out;
} }
@ -117,7 +116,7 @@ void audio::algo::chunkware::Limiter::process(void* _output, const void* _input,
processDouble(vals, vals, _nbChannel); processDouble(vals, vals, _nbChannel);
for (int8_t kkk=0; kkk<_nbChannel ; ++kkk) { for (int8_t kkk=0; kkk<_nbChannel ; ++kkk) {
vals[kkk] *= 32768.0; vals[kkk] *= 32768.0;
output[iii*_nbChannel+kkk] = int16_t(std::avg(-32768.0, vals[kkk], 32767.0)); output[iii*_nbChannel+kkk] = int16_t(etk::avg(-32768.0, vals[kkk], 32767.0));
} }
} }
} }
@ -142,8 +141,8 @@ void audio::algo::chunkware::Limiter::processDouble(double* _out, const double*
double keyLink = 0; double keyLink = 0;
// get greater value; // get greater value;
for (int8_t iii=0; iii<_nbChannel; ++iii) { for (int8_t iii=0; iii<_nbChannel; ++iii) {
double absValue = std::abs(_in[iii]); double absValue = etk::abs(_in[iii]);
keyLink = std::max(keyLink, absValue); keyLink = etk::max(keyLink, absValue);
} }
// we always want to feed the sidechain AT LEATS the threshold value // we always want to feed the sidechain AT LEATS the threshold value
if (keyLink < m_threshold) { if (keyLink < m_threshold) {

14
audio/algo/chunkware/Limiter.hpp
View File

@ -28,8 +28,8 @@
#include <audio/format.hpp> #include <audio/format.hpp>
#include <audio/algo/chunkware/AttRelEnvelope.hpp> #include <audio/algo/chunkware/AttRelEnvelope.hpp>
#include <audio/algo/chunkware/Gain.hpp> #include <audio/algo/chunkware/Gain.hpp>
#include <chrono> #include <echrono/Steady.hpp>
#include <vector> #include <etk/Vector.hpp>
namespace audio { namespace audio {
namespace algo { namespace algo {
@ -63,12 +63,12 @@ namespace audio {
* @brief Get list of format suported in input. * @brief Get list of format suported in input.
* @return list of supported format * @return list of supported format
*/ */
virtual std::vector<enum audio::format> getSupportedFormat(); virtual etk::Vector<enum audio::format> getSupportedFormat();
/** /**
* @brief Get list of algorithm format suported. No format convertion. * @brief Get list of algorithm format suported. No format convertion.
* @return list of supported format * @return list of supported format
*/ */
virtual std::vector<enum audio::format> getNativeSupportedFormat(); virtual etk::Vector<enum audio::format> getNativeSupportedFormat();
/** /**
* @brief Main input algo process. * @brief Main input algo process.
* @param[in,out] _output Output data. * @param[in,out] _output Output data.
@ -97,7 +97,7 @@ namespace audio {
} }
protected: protected:
std::chrono::microseconds m_attackTime; //!< attaque time in ms. echrono::microseconds m_attackTime; //!< attaque time in ms.
public: public:
virtual void setAttack(double _ms); virtual void setAttack(double _ms);
virtual double getAttack() const { virtual double getAttack() const {
@ -105,7 +105,7 @@ namespace audio {
} }
protected: protected:
std::chrono::microseconds m_releaseTime; //!< attaque time in ms. echrono::microseconds m_releaseTime; //!< attaque time in ms.
public: public:
virtual void setRelease(double _ms); virtual void setRelease(double _ms);
virtual double getRelease() const { virtual double getRelease() const {
@ -150,7 +150,7 @@ namespace audio {
static const int BUFFER_SIZE = 1024; //!< buffer size (always a power of 2!) static const int BUFFER_SIZE = 1024; //!< buffer size (always a power of 2!)
uint32_t m_bufferMask; //!< buffer mask uint32_t m_bufferMask; //!< buffer mask
uint32_t m_cursor; //!< cursor uint32_t m_cursor; //!< cursor
std::vector<std::vector<double> > m_outputBuffer; //!< output buffer etk::Vector<etk::Vector<double> > m_outputBuffer; //!< output buffer
}; };
} }
} }

2
lutin_audio-algo-chunkware-test.py
View File

@ -13,7 +13,7 @@ def get_desc():
return "test chunkware" return "test chunkware"
def get_licence(): def get_licence():
return "APACHE-2" return "MPL-2"
def get_compagny_type(): def get_compagny_type():
return "com" return "com"

123
test/main.cpp
View File

@ -1,7 +1,7 @@
/** @file /** @file
* @author Edouard DUPIN * @author Edouard DUPIN
* @copyright 2015, Edouard DUPIN, all right reserved * @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file) * @license MPL v2.0 (see license file)
*/ */
#include <test-debug/debug.hpp> #include <test-debug/debug.hpp>
@ -10,13 +10,14 @@
#include <audio/algo/chunkware/Limiter.hpp> #include <audio/algo/chunkware/Limiter.hpp>
#include <audio/algo/chunkware/Gate.hpp> #include <audio/algo/chunkware/Gate.hpp>
#include <etk/os/FSNode.hpp> #include <etk/os/FSNode.hpp>
#include <chrono> #include <echrono/Steady.hpp>
#include <thread> #include <ethread/Thread.hpp>
#include <ethread/tools.hpp>
static std::vector<double> convert(const std::vector<int16_t>& _data) { static etk::Vector<double> convert(const etk::Vector<int16_t>& _data) {
std::vector<double> out; etk::Vector<double> out;
out.resize(_data.size(), 0.0); out.resize(_data.size(), 0.0);
for (size_t iii=0; iii<_data.size(); ++iii) { for (size_t iii=0; iii<_data.size(); ++iii) {
out[iii] = _data[iii]; out[iii] = _data[iii];
@ -27,11 +28,11 @@ static std::vector<double> convert(const std::vector<int16_t>& _data) {
return out; return out;
} }
static std::vector<int16_t> convert(const std::vector<double>& _data) { static etk::Vector<int16_t> convert(const etk::Vector<double>& _data) {
std::vector<int16_t> out; etk::Vector<int16_t> out;
out.resize(_data.size(), 0.0); out.resize(_data.size(), 0.0);
for (size_t iii=0; iii<_data.size(); ++iii) { for (size_t iii=0; iii<_data.size(); ++iii) {
out[iii] = int16_t(std::avg(-32768.0, _data[iii]*32768.0, 32767.0)); out[iii] = int16_t(etk::avg(-32768.0, _data[iii]*32768.0, 32767.0));
} }
return out; return out;
} }
@ -39,40 +40,40 @@ static std::vector<int16_t> convert(const std::vector<double>& _data) {
class Performance { class Performance {
private: private:
std::chrono::steady_clock::time_point m_timeStart; echrono::Steady m_timeStart;
std::chrono::steady_clock::time_point m_timeStop; echrono::Steady m_timeStop;
std::chrono::nanoseconds m_totalTimeProcessing; echrono::Duration m_totalTimeProcessing;
std::chrono::nanoseconds m_minProcessing; echrono::Duration m_minProcessing;
std::chrono::nanoseconds m_maxProcessing; echrono::Duration m_maxProcessing;
int32_t m_totalIteration; int32_t m_totalIteration;
public: public:
Performance() : Performance() :
m_totalTimeProcessing(0), m_totalTimeProcessing(0),
m_minProcessing(99999999999999LL), m_minProcessing(int64_t(99999999999999LL)),
m_maxProcessing(0), m_maxProcessing(0),
m_totalIteration(0) { m_totalIteration(0) {
} }
void tic() { void tic() {
m_timeStart = std::chrono::steady_clock::now(); m_timeStart = echrono::Steady::now();
} }
void toc() { void toc() {
m_timeStop = std::chrono::steady_clock::now(); m_timeStop = echrono::Steady::now();
std::chrono::nanoseconds time = m_timeStop - m_timeStart; echrono::Duration time = m_timeStop - m_timeStart;
m_minProcessing = std::min(m_minProcessing, time); m_minProcessing = etk::min(m_minProcessing, time);
m_maxProcessing = std::max(m_maxProcessing, time); m_maxProcessing = etk::max(m_maxProcessing, time);
m_totalTimeProcessing += time; m_totalTimeProcessing += time;
m_totalIteration++; m_totalIteration++;
} }
std::chrono::nanoseconds getTotalTimeProcessing() { echrono::Duration getTotalTimeProcessing() {
return m_totalTimeProcessing; return m_totalTimeProcessing;
} }
std::chrono::nanoseconds getMinProcessing() { echrono::Duration getMinProcessing() {
return m_minProcessing; return m_minProcessing;
} }
std::chrono::nanoseconds getMaxProcessing() { echrono::Duration getMaxProcessing() {
return m_maxProcessing; return m_maxProcessing;
} }
int32_t getTotalIteration() { int32_t getTotalIteration() {
@ -82,9 +83,9 @@ class Performance {
}; };
void performanceCompressor() { void performanceCompressor() {
std::vector<double> input; etk::Vector<double> input;
input.resize(8192, 0); input.resize(8192, 0);
std::vector<double> output; etk::Vector<double> output;
output.resize(8192, 0); output.resize(8192, 0);
double sampleRate = 48000.0; double sampleRate = 48000.0;
{ {
@ -108,22 +109,22 @@ void performanceCompressor() {
perfo.tic(); perfo.tic();
algo.process(&output[0], &input[0], input.size(), 1, audio::format_double); algo.process(&output[0], &input[0], input.size(), 1, audio::format_double);
perfo.toc(); perfo.toc();
std::this_thread::sleep_for(std::chrono::milliseconds(1)); ethread::sleepMilliSeconds((1));
} }
TEST_PRINT("Performance Compressor (double): "); TEST_PRINT("Performance Compressor (double): ");
TEST_PRINT(" blockSize=" << input.size() << " sample"); TEST_PRINT(" blockSize=" << input.size() << " sample");
TEST_PRINT(" min < avg < max =" << perfo.getMinProcessing().count() << "ns < " TEST_PRINT(" min < avg < max =" << perfo.getMinProcessing() << " < "
<< perfo.getTotalTimeProcessing().count()/perfo.getTotalIteration() << "ns < " << perfo.getTotalTimeProcessing().get()/perfo.getTotalIteration() << "ns < "
<< perfo.getMaxProcessing().count() << "ns "); << perfo.getMaxProcessing());
TEST_PRINT(" min < avg < max= " << (float((perfo.getMinProcessing().count()*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "% < " TEST_PRINT(" min < avg < max= " << (float((perfo.getMinProcessing().get()*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "% < "
<< (float(((perfo.getTotalTimeProcessing().count()/perfo.getTotalIteration())*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "% < " << (float(((perfo.getTotalTimeProcessing().get()/perfo.getTotalIteration())*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "% < "
<< (float((perfo.getMaxProcessing().count()*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "%"); << (float((perfo.getMaxProcessing().get()*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "%");
} }
void performanceLimiter() { void performanceLimiter() {
std::vector<double> input; etk::Vector<double> input;
input.resize(8192, 0); input.resize(8192, 0);
std::vector<double> output; etk::Vector<double> output;
output.resize(8192, 0); output.resize(8192, 0);
double sampleRate = 48000.0; double sampleRate = 48000.0;
{ {
@ -149,22 +150,22 @@ void performanceLimiter() {
perfo.tic(); perfo.tic();
algo.process(&output[0], &input[0], input.size(), 1, audio::format_double); algo.process(&output[0], &input[0], input.size(), 1, audio::format_double);
perfo.toc(); perfo.toc();
std::this_thread::sleep_for(std::chrono::milliseconds(1)); ethread::sleepMilliSeconds((1));
} }
TEST_PRINT("Performance Limiter (double): "); TEST_PRINT("Performance Limiter (double): ");
TEST_PRINT(" blockSize=" << input.size() << " sample"); TEST_PRINT(" blockSize=" << input.size() << " sample");
TEST_PRINT(" min < avg < max =" << perfo.getMinProcessing().count() << "ns < " TEST_PRINT(" min < avg < max =" << perfo.getMinProcessing() << " < "
<< perfo.getTotalTimeProcessing().count()/perfo.getTotalIteration() << "ns < " << perfo.getTotalTimeProcessing().get()/perfo.getTotalIteration() << "ns < "
<< perfo.getMaxProcessing().count() << "ns "); << perfo.getMaxProcessing());
TEST_PRINT(" min < avg < max = " << (float((perfo.getMinProcessing().count()*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "% < " TEST_PRINT(" min < avg < max = " << (float((perfo.getMinProcessing().get()*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "% < "
<< (float(((perfo.getTotalTimeProcessing().count()/perfo.getTotalIteration())*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "% < " << (float(((perfo.getTotalTimeProcessing().get()/perfo.getTotalIteration())*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "% < "
<< (float((perfo.getMaxProcessing().count()*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "%"); << (float((perfo.getMaxProcessing().get()*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "%");
} }
void performanceGate() { void performanceGate() {
std::vector<double> input; etk::Vector<double> input;
input.resize(8192, 0); input.resize(8192, 0);
std::vector<double> output; etk::Vector<double> output;
output.resize(8192, 0); output.resize(8192, 0);
double sampleRate = 48000.0; double sampleRate = 48000.0;
{ {
@ -190,16 +191,16 @@ void performanceGate() {
perfo.tic(); perfo.tic();
algo.process(&output[0], &input[0], input.size(), 1, audio::format_double); algo.process(&output[0], &input[0], input.size(), 1, audio::format_double);
perfo.toc(); perfo.toc();
std::this_thread::sleep_for(std::chrono::milliseconds(1)); ethread::sleepMilliSeconds((1));
} }
TEST_PRINT("Performance Gate (double): "); TEST_PRINT("Performance Gate (double): ");
TEST_PRINT(" blockSize=" << input.size() << " sample"); TEST_PRINT(" blockSize=" << input.size() << " sample");
TEST_PRINT(" min < avg < max =" << perfo.getMinProcessing().count() << "ns < " TEST_PRINT(" min < avg < max =" << perfo.getMinProcessing() << " < "
<< perfo.getTotalTimeProcessing().count()/perfo.getTotalIteration() << "ns < " << perfo.getTotalTimeProcessing().get()/perfo.getTotalIteration() << "ns < "
<< perfo.getMaxProcessing().count() << "ns "); << perfo.getMaxProcessing());
TEST_PRINT(" min < avg < max = " << (float((perfo.getMinProcessing().count()*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "% < " TEST_PRINT(" min < avg < max = " << (float((perfo.getMinProcessing().get()*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "% < "
<< (float(((perfo.getTotalTimeProcessing().count()/perfo.getTotalIteration())*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "% < " << (float(((perfo.getTotalTimeProcessing().get()/perfo.getTotalIteration())*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "% < "
<< (float((perfo.getMaxProcessing().count()*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "%"); << (float((perfo.getMaxProcessing().get()*sampleRate)/double(input.size()))/1000000000.0)*100.0 << "%");
} }
@ -208,12 +209,12 @@ void performanceGate() {
int main(int _argc, const char** _argv) { int main(int _argc, const char** _argv) {
// the only one init for etk: // the only one init for etk:
etk::init(_argc, _argv); etk::init(_argc, _argv);
std::string inputName = ""; etk::String inputName = "";
bool performance = false; bool performance = false;
bool perf = false; bool perf = false;
int64_t sampleRate = 48000; int64_t sampleRate = 48000;
for (int32_t iii=0; iii<_argc ; ++iii) { for (int32_t iii=0; iii<_argc ; ++iii) {
std::string data = _argv[iii]; etk::String data = _argv[iii];
if (etk::start_with(data,"--in=")) { if (etk::start_with(data,"--in=")) {
inputName = &data[5]; inputName = &data[5];
} else if (data == "--performance") { } else if (data == "--performance") {
@ -246,10 +247,10 @@ int main(int _argc, const char** _argv) {
exit(-1); exit(-1);
} }
TEST_INFO("Read input:"); TEST_INFO("Read input:");
std::vector<double> inputData = convert(etk::FSNodeReadAllDataType<int16_t>(inputName)); etk::Vector<double> inputData = convert(etk::FSNodeReadAllDataType<int16_t>(inputName));
TEST_INFO(" " << inputData.size() << " samples"); TEST_INFO(" " << inputData.size() << " samples");
// resize output : // resize output :
std::vector<double> output; etk::Vector<double> output;
output.resize(inputData.size(), 0); output.resize(inputData.size(), 0);
// process in chunk of 256 samples // process in chunk of 256 samples
int32_t blockSize = 256; int32_t blockSize = 256;
@ -271,7 +272,7 @@ int main(int _argc, const char** _argv) {
algo.process(audio::format_double, &output[iii*blockSize], &inputData[iii*blockSize], blockSize, 1); algo.process(audio::format_double, &output[iii*blockSize], &inputData[iii*blockSize], blockSize, 1);
if (perf == true) { if (perf == true) {
perfo.toc(); perfo.toc();
std::this_thread::sleep_for(std::chrono::milliseconds(1)); ethread::sleepMilliSeconds((1));
} }
} }
*/ */
@ -293,7 +294,7 @@ int main(int _argc, const char** _argv) {
algo.process(&output[iii*blockSize], &inputData[iii*blockSize], blockSize, 1, audio::format_double); algo.process(&output[iii*blockSize], &inputData[iii*blockSize], blockSize, 1, audio::format_double);
if (perf == true) { if (perf == true) {
perfo.toc(); perfo.toc();
std::this_thread::sleep_for(std::chrono::milliseconds(1)); ethread::sleepMilliSeconds((1));
} }
} }
@ -301,13 +302,13 @@ int main(int _argc, const char** _argv) {
if (perf == true) { if (perf == true) {
TEST_INFO("Performance Result: "); TEST_INFO("Performance Result: ");
TEST_INFO(" blockSize=" << blockSize << " sample"); TEST_INFO(" blockSize=" << blockSize << " sample");
TEST_INFO(" min=" << perfo.getMinProcessing().count() << " ns"); TEST_INFO(" min=" << perfo.getMinProcessing());
TEST_INFO(" max=" << perfo.getMaxProcessing().count() << " ns"); TEST_INFO(" max=" << perfo.getMaxProcessing());
TEST_INFO(" avg=" << perfo.getTotalTimeProcessing().count()/perfo.getTotalIteration() << " ns"); TEST_INFO(" avg=" << perfo.getTotalTimeProcessing().get()/perfo.getTotalIteration() << " ns");
TEST_INFO(" min=" << (float((perfo.getMinProcessing().count()*sampleRate)/blockSize)/1000000000.0)*100.0 << " %"); TEST_INFO(" min=" << (float((perfo.getMinProcessing().get()*sampleRate)/blockSize)/1000000000.0)*100.0 << " %");
TEST_INFO(" max=" << (float((perfo.getMaxProcessing().count()*sampleRate)/blockSize)/1000000000.0)*100.0 << " %"); TEST_INFO(" max=" << (float((perfo.getMaxProcessing().get()*sampleRate)/blockSize)/1000000000.0)*100.0 << " %");
TEST_INFO(" avg=" << (float(((perfo.getTotalTimeProcessing().count()/perfo.getTotalIteration())*sampleRate)/blockSize)/1000000000.0)*100.0 << " %"); TEST_INFO(" avg=" << (float(((perfo.getTotalTimeProcessing().get()/perfo.getTotalIteration())*sampleRate)/blockSize)/1000000000.0)*100.0 << " %");
} }
etk::FSNodeWriteAllDataType<int16_t>("output.raw", convert(output)); etk::FSNodeWriteAllDataType<int16_t>("output.raw", convert(output));

2
version.txt
View File

@ -1 +1 @@
0.2.0 1.0.0