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;
}
std::vector<enum audio::format> audio::algo::chunkware::Compressor::getSupportedFormat() {
std::vector<enum audio::format> out = getNativeSupportedFormat();
out.push_back(audio::format_int16);
etk::Vector<enum audio::format> audio::algo::chunkware::Compressor::getSupportedFormat() {
etk::Vector<enum audio::format> out = getNativeSupportedFormat();
out.pushBack(audio::format_int16);
return out;
}
std::vector<enum audio::format> audio::algo::chunkware::Compressor::getNativeSupportedFormat() {
std::vector<enum audio::format> out;
out.push_back(audio::format_double);
etk::Vector<enum audio::format> audio::algo::chunkware::Compressor::getNativeSupportedFormat() {
etk::Vector<enum audio::format> out;
out.pushBack(audio::format_double);
return out;
}
@ -82,7 +82,7 @@ void audio::algo::chunkware::Compressor::process(void* _output, const void* _inp
processDouble(vals, vals, _nbChannel);
for (int8_t kkk=0; kkk<_nbChannel ; ++kkk) {
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;
// get greater value;
for (int8_t iii=0; iii<_nbChannel; ++iii) {
double absValue = std::abs(_in[iii]);
keyLink = std::max(keyLink, absValue);
double absValue = etk::abs(_in[iii]);
keyLink = etk::max(keyLink, absValue);
}
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.
* @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.
* @return list of supported format
*/
virtual std::vector<enum audio::format> getNativeSupportedFormat();
virtual etk::Vector<enum audio::format> getNativeSupportedFormat();
/**
* @brief Main input algo process.
* @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;
}
std::vector<enum audio::format> audio::algo::chunkware::Gate::getSupportedFormat() {
std::vector<enum audio::format> out = getNativeSupportedFormat();
out.push_back(audio::format_int16);
etk::Vector<enum audio::format> audio::algo::chunkware::Gate::getSupportedFormat() {
etk::Vector<enum audio::format> out = getNativeSupportedFormat();
out.pushBack(audio::format_int16);
return out;
}
std::vector<enum audio::format> audio::algo::chunkware::Gate::getNativeSupportedFormat() {
std::vector<enum audio::format> out;
out.push_back(audio::format_double);
etk::Vector<enum audio::format> audio::algo::chunkware::Gate::getNativeSupportedFormat() {
etk::Vector<enum audio::format> out;
out.pushBack(audio::format_double);
return out;
}
@ -77,7 +77,7 @@ void audio::algo::chunkware::Gate::process(void* _output, const void* _input, si
processDouble(vals, vals, _nbChannel);
for (int8_t kkk=0; kkk<_nbChannel ; ++kkk) {
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;
// get greater value;
for (int8_t iii=0; iii<_nbChannel; ++iii) {
double absValue = std::abs(_in[iii]);
keyLink = std::max(keyLink, absValue);
double absValue = etk::abs(_in[iii]);
keyLink = etk::max(keyLink, absValue);
}
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.
* @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.
* @return list of supported format
*/
virtual std::vector<enum audio::format> getNativeSupportedFormat();
virtual etk::Vector<enum audio::format> getNativeSupportedFormat();
/**
* @brief Main input algo process.
* @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);
for (int8_t iii=0; iii<_nbChannel; ++iii) {
m_outputBuffer[iii].resize(BUFFER_SIZE, 0.0);
m_outputBuffer[iii].assign(BUFFER_SIZE, 0.0);
}
m_isConfigured = true;
}
void audio::algo::chunkware::FastEnvelope::setCoef() {
// 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() {
std::vector<enum audio::format> out = getNativeSupportedFormat();
out.push_back(audio::format_int16);
etk::Vector<enum audio::format> audio::algo::chunkware::Limiter::getSupportedFormat() {
etk::Vector<enum audio::format> out = getNativeSupportedFormat();
out.pushBack(audio::format_int16);
return out;
}
std::vector<enum audio::format> audio::algo::chunkware::Limiter::getNativeSupportedFormat() {
std::vector<enum audio::format> out;
out.push_back(audio::format_double);
etk::Vector<enum audio::format> audio::algo::chunkware::Limiter::getNativeSupportedFormat() {
etk::Vector<enum audio::format> out;
out.pushBack(audio::format_double);
return out;
}
@ -117,7 +116,7 @@ void audio::algo::chunkware::Limiter::process(void* _output, const void* _input,
processDouble(vals, vals, _nbChannel);
for (int8_t kkk=0; kkk<_nbChannel ; ++kkk) {
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;
// get greater value;
for (int8_t iii=0; iii<_nbChannel; ++iii) {
double absValue = std::abs(_in[iii]);
keyLink = std::max(keyLink, absValue);
double absValue = etk::abs(_in[iii]);
keyLink = etk::max(keyLink, absValue);
}
// we always want to feed the sidechain AT LEATS the threshold value
if (keyLink < m_threshold) {

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

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

123
test/main.cpp
View File

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

2
version.txt
View File

@ -1 +1 @@
0.2.0
1.0.0