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

[DEV] continue removing stl

Browse Source
This commit is contained in:
Edouard DUPIN 2017-08-28 00:08:17 +02:00
parent 2bd207471f
commit 567bdd6a86
29 changed files with 317 additions and 317 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
audio/drain/Algo.cpp
View File

@ -59,16 +59,16 @@ void audio::drain::Algo::configurationChange() {
} }
} }
std::string audio::drain::Algo::getDotDesc() { etk::String audio::drain::Algo::getDotDesc() {
std::string out; etk::String out;
if (m_input.getFormat() != m_output.getFormat()) { if (m_input.getFormat() != m_output.getFormat()) {
out += "\\nformat: " + etk::to_string(m_input.getFormat()) + "->" + etk::to_string(m_output.getFormat()); out += "\\nformat: " + etk::toString(m_input.getFormat()) + "->" + etk::to_string(m_output.getFormat());
} }
if (m_input.getMap() != m_output.getMap()) { if (m_input.getMap() != m_output.getMap()) {
out += "\\nmap: " + etk::to_string(m_input.getMap()) + "->" + etk::to_string(m_output.getMap()); out += "\\nmap: " + etk::toString(m_input.getMap()) + "->" + etk::to_string(m_output.getMap());
} }
if (m_input.getFrequency() != m_output.getFrequency()) { if (m_input.getFrequency() != m_output.getFrequency()) {
out += "\\nsamplerate: " + etk::to_string(m_input.getFrequency()) + "->" + etk::to_string(m_output.getFrequency()); out += "\\nsamplerate: " + etk::toString(m_input.getFrequency()) + "->" + etk::to_string(m_output.getFrequency());
} }
return out; return out;
} }
@ -116,7 +116,7 @@ void audio::drain::Algo::setStatusFunction(algoStatusFunction _newFunction) {
m_statusFunction = _newFunction; m_statusFunction = _newFunction;
} }
void audio::drain::Algo::generateStatus(const std::string& _status) { void audio::drain::Algo::generateStatus(const etk::String& _status) {
if (m_statusFunction != nullptr) { if (m_statusFunction != nullptr) {
if (m_name.size() == 0) { if (m_name.size() == 0) {
m_statusFunction(m_type, _status); m_statusFunction(m_type, _status);

72
audio/drain/Algo.hpp
View File

@ -5,8 +5,8 @@
*/ */
#pragma once #pragma once
#include <string> #include <etk/String.hpp>
#include <vector> #include <etk/Vector.hpp>
#include <cstdint> #include <cstdint>
#include <audio/format.hpp> #include <audio/format.hpp>
#include <audio/channel.hpp> #include <audio/channel.hpp>
@ -27,28 +27,28 @@ namespace audio {
* @brief audio-algo library namespace * @brief audio-algo library namespace
*/ */
namespace drain{ namespace drain{
typedef std::function<void (const std::string& _origin, const std::string& _status)> algoStatusFunction; typedef std::function<void (const etk::String& _origin, const etk::String& _status)> algoStatusFunction;
class Algo : public ememory::EnableSharedFromThis<Algo> { class Algo : public ememory::EnableSharedFromThis<Algo> {
private: private:
std::string m_name; etk::String m_name;
public: public:
const std::string& getName() const { const etk::String& getName() const {
return m_name; return m_name;
} }
void setName(const std::string& _name) { void setName(const etk::String& _name) {
m_name = _name; m_name = _name;
} }
protected: protected:
std::string m_type; etk::String m_type;
public: public:
const std::string& getType() const { const etk::String& getType() const {
return m_type; return m_type;
} }
void setType(const std::string& _type) { void setType(const etk::String& _type) {
m_type = _type; m_type = _type;
} }
public: public:
virtual std::string getDotDesc(); virtual etk::String getDotDesc();
private: private:
bool m_temporary; bool m_temporary;
public: public:
@ -63,9 +63,9 @@ namespace audio {
public: public:
void setStatusFunction(algoStatusFunction _newFunction); void setStatusFunction(algoStatusFunction _newFunction);
protected: protected:
void generateStatus(const std::string& _status); void generateStatus(const etk::String& _status);
protected: protected:
std::vector<int8_t> m_outputData; etk::Vector<int8_t> m_outputData;
int8_t m_formatSize; //!< sample size int8_t m_formatSize; //!< sample size
/** /**
* @brief Constructor * @brief Constructor
@ -138,58 +138,58 @@ namespace audio {
// TODO : Manage the change of the timestamp ... // TODO : Manage the change of the timestamp ...
virtual size_t needInputData(size_t _output); virtual size_t needInputData(size_t _output);
protected: // note when nothing ==> support all type protected: // note when nothing ==> support all type
std::vector<audio::format> m_supportedFormat; etk::Vector<audio::format> m_supportedFormat;
public: public:
virtual std::vector<audio::format> getFormatSupportedInput() { virtual etk::Vector<audio::format> getFormatSupportedInput() {
if (m_output.getConfigured() == true) { if (m_output.getConfigured() == true) {
std::vector<audio::format> out; etk::Vector<audio::format> out;
out.push_back(m_output.getFormat()); out.pushBack(m_output.getFormat());
return out; return out;
} }
return m_supportedFormat; return m_supportedFormat;
}; };
virtual std::vector<audio::format> getFormatSupportedOutput() { virtual etk::Vector<audio::format> getFormatSupportedOutput() {
if (m_input.getConfigured() == true) { if (m_input.getConfigured() == true) {
std::vector<audio::format> out; etk::Vector<audio::format> out;
out.push_back(m_input.getFormat()); out.pushBack(m_input.getFormat());
return out; return out;
} }
return m_supportedFormat; return m_supportedFormat;
}; };
protected: // note when nothing ==> support all type protected: // note when nothing ==> support all type
std::vector<std::vector<audio::channel> > m_supportedMap; etk::Vector<etk::Vector<audio::channel> > m_supportedMap;
public: public:
virtual std::vector<std::vector<audio::channel> > getMapSupportedInput() { virtual etk::Vector<etk::Vector<audio::channel> > getMapSupportedInput() {
if (m_output.getConfigured() == true) { if (m_output.getConfigured() == true) {
std::vector<std::vector<audio::channel> > out; etk::Vector<etk::Vector<audio::channel> > out;
out.push_back(m_output.getMap()); out.pushBack(m_output.getMap());
return out; return out;
} }
return m_supportedMap; return m_supportedMap;
}; };
virtual std::vector<std::vector<audio::channel> > getMapSupportedOutput() { virtual etk::Vector<etk::Vector<audio::channel> > getMapSupportedOutput() {
if (m_input.getConfigured() == true) { if (m_input.getConfigured() == true) {
std::vector<std::vector<audio::channel> > out; etk::Vector<etk::Vector<audio::channel> > out;
out.push_back(m_input.getMap()); out.pushBack(m_input.getMap());
return out; return out;
} }
return m_supportedMap; return m_supportedMap;
}; };
protected: // note when nothing ==> support all type protected: // note when nothing ==> support all type
std::vector<float> m_supportedFrequency; etk::Vector<float> m_supportedFrequency;
public: public:
virtual std::vector<float> getFrequencySupportedInput() { virtual etk::Vector<float> getFrequencySupportedInput() {
if (m_output.getConfigured() == true) { if (m_output.getConfigured() == true) {
std::vector<float> out; etk::Vector<float> out;
out.push_back(m_output.getFrequency()); out.pushBack(m_output.getFrequency());
return out; return out;
} }
return m_supportedFrequency; return m_supportedFrequency;
}; };
virtual std::vector<float> getFrequencySupportedOutput() { virtual etk::Vector<float> getFrequencySupportedOutput() {
if (m_input.getConfigured() == true) { if (m_input.getConfigured() == true) {
std::vector<float> out; etk::Vector<float> out;
out.push_back(m_input.getFrequency()); out.pushBack(m_input.getFrequency());
return out; return out;
} }
return m_supportedFrequency; return m_supportedFrequency;
@ -202,19 +202,19 @@ namespace audio {
* @return true set done * @return true set done
* @return false An error occured * @return false An error occured
*/ */
virtual bool setParameter(const std::string& _parameter, const std::string& _value) { return false; } virtual bool setParameter(const etk::String& _parameter, const etk::String& _value) { return false; }
/** /**
* @brief Get a parameter value * @brief Get a parameter value
* @param[in] _parameter Parameter name. * @param[in] _parameter Parameter name.
* @return The requested value. * @return The requested value.
*/ */
virtual std::string getParameter(const std::string& _parameter) const { return "[ERROR]"; } virtual etk::String getParameter(const etk::String& _parameter) const { return "[ERROR]"; }
/** /**
* @brief Get a parameter value * @brief Get a parameter value
* @param[in] _parameter Parameter name. * @param[in] _parameter Parameter name.
* @return The requested value. * @return The requested value.
*/ */
virtual std::string getParameterProperty(const std::string& _parameter) const { return "[ERROR]"; }; virtual etk::String getParameterProperty(const etk::String& _parameter) const { return "[ERROR]"; };
}; };
} }
} }

2
audio/drain/AutoLogInOut.cpp
View File

@ -7,7 +7,7 @@
#include "AutoLogInOut.hpp" #include "AutoLogInOut.hpp"
#include "debug.hpp" #include "debug.hpp"
audio::drain::AutoLogInOut::AutoLogInOut(const std::string& _value) : audio::drain::AutoLogInOut::AutoLogInOut(const etk::String& _value) :
m_value(_value) { m_value(_value) {
DRAIN_VERBOSE(" '" << m_value << "' [START]"); DRAIN_VERBOSE(" '" << m_value << "' [START]");
} }

6
audio/drain/AutoLogInOut.hpp
View File

@ -5,16 +5,16 @@
*/ */
#pragma once #pragma once
#include <string> #include <etk/String.hpp>
#include "debug.hpp" #include "debug.hpp"
namespace audio { namespace audio {
namespace drain{ namespace drain{
class AutoLogInOut { class AutoLogInOut {
private: private:
std::string m_value; etk::String m_value;
public: public:
AutoLogInOut(const std::string& _value); AutoLogInOut(const etk::String& _value);
~AutoLogInOut(); ~AutoLogInOut();
}; };
} }

4
audio/drain/CircularBuffer.cpp
View File

@ -196,7 +196,7 @@ size_t audio::drain::CircularBuffer::read(void* _data, size_t _nbChunk, const au
} else if (deltaTime.count() > 0) { } else if (deltaTime.count() > 0) {
// Add empty sample in the output buffer ... // Add empty sample in the output buffer ...
size_t nbSampleEmpty = m_frequency*deltaTime.count()/100000000; size_t nbSampleEmpty = m_frequency*deltaTime.count()/100000000;
nbSampleEmpty = std::min(nbSampleEmpty, _nbChunk); nbSampleEmpty = etk::min(nbSampleEmpty, _nbChunk);
DRAIN_WARNING("add Empty sample in the output buffer " << nbSampleEmpty << " / " << _nbChunk); DRAIN_WARNING("add Empty sample in the output buffer " << nbSampleEmpty << " / " << _nbChunk);
memset(_data, 0, nbSampleEmpty * m_sizeChunk); memset(_data, 0, nbSampleEmpty * m_sizeChunk);
if (nbSampleEmpty == _nbChunk) { if (nbSampleEmpty == _nbChunk) {
@ -258,7 +258,7 @@ void audio::drain::CircularBuffer::setReadPosition(const audio::Time& _time) {
// check the time of the read : // check the time of the read :
audio::Duration deltaTime = _time - m_timeRead; audio::Duration deltaTime = _time - m_timeRead;
size_t nbSampleToRemove = int64_t(m_frequency)*int64_t(deltaTime.count())/1000000000LL; size_t nbSampleToRemove = int64_t(m_frequency)*int64_t(deltaTime.count())/1000000000LL;
nbSampleToRemove = std::min(nbSampleToRemove, m_size); nbSampleToRemove = etk::min(nbSampleToRemove, m_size);
DRAIN_VERBOSE("Remove sample in the buffer " << nbSampleToRemove << " / " << m_size); DRAIN_VERBOSE("Remove sample in the buffer " << nbSampleToRemove << " / " << m_size);
audio::Duration updateTime(0,(int64_t(nbSampleToRemove)*1000000000LL)/int64_t(m_frequency)); audio::Duration updateTime(0,(int64_t(nbSampleToRemove)*1000000000LL)/int64_t(m_frequency));
DRAIN_VERBOSE(" add time : " << updateTime.count() << "ns / " << deltaTime.count() << "ns"); DRAIN_VERBOSE(" add time : " << updateTime.count() << "ns / " << deltaTime.count() << "ns");

4
audio/drain/CircularBuffer.hpp
View File

@ -6,7 +6,7 @@
#pragma once #pragma once
#include <etk/types.hpp> #include <etk/types.hpp>
#include <vector> #include <etk/Vector.hpp>
#include <chrono> #include <chrono>
#include <audio/Time.hpp> #include <audio/Time.hpp>
#include <audio/Duration.hpp> #include <audio/Duration.hpp>
@ -40,7 +40,7 @@ namespace audio {
*/ */
class CircularBuffer { class CircularBuffer {
private: private:
std::vector<uint8_t> m_data; //!< data pointer etk::Vector<uint8_t> m_data; //!< data pointer
void* m_write; //!< write pointer void* m_write; //!< write pointer
void* m_read; //!< read pointer void* m_read; //!< read pointer
audio::Time m_timeRead; //!< current read time audio::Time m_timeRead; //!< current read time

4
audio/drain/EndPointCallback.hpp
View File

@ -15,13 +15,13 @@ namespace audio {
size_t _nbChunk, size_t _nbChunk,
enum audio::format _format, enum audio::format _format,
uint32_t _frequency, uint32_t _frequency,
const std::vector<audio::channel>& _map)> playbackFunction; const etk::Vector<audio::channel>& _map)> playbackFunction;
typedef std::function<void (const void* _data, typedef std::function<void (const void* _data,
const audio::Time& _readTime, const audio::Time& _readTime,
size_t _nbChunk, size_t _nbChunk,
enum audio::format _format, enum audio::format _format,
uint32_t _frequency, uint32_t _frequency,
const std::vector<audio::channel>& _map)> recordFunction; const etk::Vector<audio::channel>& _map)> recordFunction;
class EndPointCallback : public EndPoint { class EndPointCallback : public EndPoint {
private: private:
playbackFunction m_outputFunction; playbackFunction m_outputFunction;

2
audio/drain/EndPointWrite.cpp
View File

@ -94,7 +94,7 @@ bool audio::drain::EndPointWrite::process(audio::Time& _time,
m_bufferUnderFlowSize = 0; m_bufferUnderFlowSize = 0;
DRAIN_VERBOSE("Write " << _outputNbChunk << " chunks"); DRAIN_VERBOSE("Write " << _outputNbChunk << " chunks");
// check if we have enought data: // check if we have enought data:
int32_t nbChunkToCopy = std::min(_inputNbChunk, m_buffer.getSize()); int32_t nbChunkToCopy = etk::min(_inputNbChunk, m_buffer.getSize());
if (nbChunkToCopy != _inputNbChunk) { if (nbChunkToCopy != _inputNbChunk) {
generateStatus("EPW_UNDERFLOW"); generateStatus("EPW_UNDERFLOW");
} }

2
audio/drain/EndPointWrite.hpp
View File

@ -16,7 +16,7 @@ namespace audio {
size_t _nbChunk, size_t _nbChunk,
enum audio::format _format, enum audio::format _format,
uint32_t _frequency, uint32_t _frequency,
const std::vector<audio::channel>& _map)> playbackFunctionWrite; const etk::Vector<audio::channel>& _map)> playbackFunctionWrite;
class EndPointWrite : public EndPoint { class EndPointWrite : public EndPoint {
private: private:
audio::drain::CircularBuffer m_buffer; audio::drain::CircularBuffer m_buffer;

16
audio/drain/Equalizer.cpp
View File

@ -18,8 +18,8 @@ audio::drain::Equalizer::Equalizer() {
void audio::drain::Equalizer::init() { void audio::drain::Equalizer::init() {
audio::drain::Algo::init(); audio::drain::Algo::init();
audio::drain::Algo::m_type = "Equalizer"; audio::drain::Algo::m_type = "Equalizer";
m_supportedFormat.push_back(audio::format_int16); m_supportedFormat.pushBack(audio::format_int16);
m_supportedFormat.push_back(audio::format_int16); m_supportedFormat.pushBack(audio::format_int16);
configureBiQuad(); configureBiQuad();
} }
@ -52,7 +52,7 @@ bool audio::drain::Equalizer::process(audio::Time& _time,
return true; return true;
} }
bool audio::drain::Equalizer::setParameter(const std::string& _parameter, const std::string& _value) { bool audio::drain::Equalizer::setParameter(const etk::String& _parameter, const etk::String& _value) {
//DRAIN_WARNING("set : " << _parameter << " " << _value); //DRAIN_WARNING("set : " << _parameter << " " << _value);
if (_parameter == "config") { if (_parameter == "config") {
m_config = ejson::Object(_value); m_config = ejson::Object(_value);
@ -64,17 +64,17 @@ bool audio::drain::Equalizer::setParameter(const std::string& _parameter, const
return false; return false;
} }
std::string audio::drain::Equalizer::getParameter(const std::string& _parameter) const { etk::String audio::drain::Equalizer::getParameter(const etk::String& _parameter) const {
return "error"; return "error";
} }
std::string audio::drain::Equalizer::getParameterProperty(const std::string& _parameter) const { etk::String audio::drain::Equalizer::getParameterProperty(const etk::String& _parameter) const {
return "error"; return "error";
} }
void audio::drain::Equalizer::addBiquad(int32_t _idBiquad, const ejson::Object& _object) { void audio::drain::Equalizer::addBiquad(int32_t _idBiquad, const ejson::Object& _object) {
// get type: // get type:
std::string typeString = _object["type"].toString().get("none"); etk::String typeString = _object["type"].toString().get("none");
if (typeString == "direct-value") { if (typeString == "direct-value") {
double a0 = _object["a0"].toNumber().get(0.0); double a0 = _object["a0"].toNumber().get(0.0);
double a1 = _object["a1"].toNumber().get(0.0); double a1 = _object["a1"].toNumber().get(0.0);
@ -125,7 +125,7 @@ void audio::drain::Equalizer::configureBiQuad() {
return; return;
} }
for (size_t iii=0; iii<getOutputFormat().getMap().size(); ++iii) { for (size_t iii=0; iii<getOutputFormat().getMap().size(); ++iii) {
std::string channelName = etk::to_string(getOutputFormat().getMap()[iii]); etk::String channelName = etk::toString(getOutputFormat().getMap()[iii]);
const ejson::Array channelConfig = m_config[channelName].toArray(); const ejson::Array channelConfig = m_config[channelName].toArray();
if (channelConfig.exist() == false) { if (channelConfig.exist() == false) {
// no config ... not a problem ... // no config ... not a problem ...
@ -145,6 +145,6 @@ void audio::drain::Equalizer::configureBiQuad() {
return; return;
} }
std::vector<std::pair<float,float> > audio::drain::Equalizer::calculateTheory() { etk::Vector<etk::Pair<float,float> > audio::drain::Equalizer::calculateTheory() {
return m_algo.calculateTheory(); return m_algo.calculateTheory();
} }

8
audio/drain/Equalizer.hpp
View File

@ -36,9 +36,9 @@ namespace audio {
protected: protected:
ejson::Object m_config; // configuration of the equalizer. ejson::Object m_config; // configuration of the equalizer.
public: public:
virtual bool setParameter(const std::string& _parameter, const std::string& _value); virtual bool setParameter(const etk::String& _parameter, const etk::String& _value);
virtual std::string getParameter(const std::string& _parameter) const; virtual etk::String getParameter(const etk::String& _parameter) const;
virtual std::string getParameterProperty(const std::string& _parameter) const; virtual etk::String getParameterProperty(const etk::String& _parameter) const;
protected: protected:
void addBiquad(int32_t _idBiquad, const ejson::Object& _object); void addBiquad(int32_t _idBiquad, const ejson::Object& _object);
audio::algo::drain::Equalizer m_algo; audio::algo::drain::Equalizer m_algo;
@ -48,7 +48,7 @@ namespace audio {
void configureBiQuad(); void configureBiQuad();
public: public:
// for debug & tools only // for debug & tools only
std::vector<std::pair<float,float> > calculateTheory(); etk::Vector<etk::Pair<float,float> > calculateTheory();
}; };
} }
} }

12
audio/drain/FormatUpdate.cpp
View File

@ -49,14 +49,14 @@ static void convert__int16_on_int32__to__int16(void* _input, void* _output, size
int32_t* in = static_cast<int32_t*>(_input); int32_t* in = static_cast<int32_t*>(_input);
int16_t* out = static_cast<int16_t*>(_output); int16_t* out = static_cast<int16_t*>(_output);
for (size_t iii=0; iii<_nbSample; ++iii) { for (size_t iii=0; iii<_nbSample; ++iii) {
out[iii] = static_cast<int16_t>(std::min(std::max(INT16_MIN, in[iii]), INT16_MAX)); out[iii] = static_cast<int16_t>(etk::min(etk::max(INT16_MIN, in[iii]), INT16_MAX));
} }
} }
static void convert__int16_on_int32__to__int32(void* _input, void* _output, size_t _nbSample) { static void convert__int16_on_int32__to__int32(void* _input, void* _output, size_t _nbSample) {
int32_t* in = static_cast<int32_t*>(_input); int32_t* in = static_cast<int32_t*>(_input);
int32_t* out = static_cast<int32_t*>(_output); int32_t* out = static_cast<int32_t*>(_output);
for (size_t iii=0; iii<_nbSample; ++iii) { for (size_t iii=0; iii<_nbSample; ++iii) {
int32_t value = std::min(std::max(INT16_MIN, in[iii]), INT16_MAX); int32_t value = etk::min(etk::max(INT16_MIN, in[iii]), INT16_MAX);
out[iii] = value << 16; out[iii] = value << 16;
} }
} }
@ -74,7 +74,7 @@ static void convert__int32__to__int16(void* _input, void* _output, size_t _nbSam
int16_t* out = static_cast<int16_t*>(_output); int16_t* out = static_cast<int16_t*>(_output);
for (size_t iii=0; iii<_nbSample; ++iii) { for (size_t iii=0; iii<_nbSample; ++iii) {
int32_t value = in[iii] >> 16; int32_t value = in[iii] >> 16;
out[iii] = static_cast<int16_t>(std::min(std::max(INT16_MIN, value), INT16_MAX)); out[iii] = static_cast<int16_t>(etk::min(etk::max(INT16_MIN, value), INT16_MAX));
} }
} }
static void convert__int32__to__int16_on_int32(void* _input, void* _output, size_t _nbSample) { static void convert__int32__to__int16_on_int32(void* _input, void* _output, size_t _nbSample) {
@ -98,7 +98,7 @@ static void convert__float__to__int16(void* _input, void* _output, size_t _nbSam
int16_t* out = static_cast<int16_t*>(_output); int16_t* out = static_cast<int16_t*>(_output);
for (size_t iii=0; iii<_nbSample; ++iii) { for (size_t iii=0; iii<_nbSample; ++iii) {
float value = in[iii] * static_cast<float>(INT16_MAX); float value = in[iii] * static_cast<float>(INT16_MAX);
value = std::min(std::max(static_cast<float>(INT16_MIN), value), static_cast<float>(INT16_MAX)); value = etk::min(etk::max(static_cast<float>(INT16_MIN), value), static_cast<float>(INT16_MAX));
out[iii] = static_cast<int16_t>(value); out[iii] = static_cast<int16_t>(value);
//DRAIN_DEBUG(iii << " in=" << in[iii] << " out=" << out[iii]); //DRAIN_DEBUG(iii << " in=" << in[iii] << " out=" << out[iii]);
} }
@ -108,7 +108,7 @@ static void convert__float__to__int16_on_int32(void* _input, void* _output, size
int32_t* out = static_cast<int32_t*>(_output); int32_t* out = static_cast<int32_t*>(_output);
for (size_t iii=0; iii<_nbSample; ++iii) { for (size_t iii=0; iii<_nbSample; ++iii) {
float value = in[iii] * static_cast<float>(INT16_MAX); float value = in[iii] * static_cast<float>(INT16_MAX);
value = std::min(std::max(static_cast<float>(INT32_MIN), value), static_cast<float>(INT32_MAX)); value = etk::min(etk::max(static_cast<float>(INT32_MIN), value), static_cast<float>(INT32_MAX));
out[iii] = static_cast<int32_t>(value); out[iii] = static_cast<int32_t>(value);
} }
} }
@ -117,7 +117,7 @@ static void convert__float__to__int32(void* _input, void* _output, size_t _nbSam
int32_t* out = static_cast<int32_t*>(_output); int32_t* out = static_cast<int32_t*>(_output);
for (size_t iii=0; iii<_nbSample; ++iii) { for (size_t iii=0; iii<_nbSample; ++iii) {
float value = in[iii] * static_cast<float>(INT32_MAX); float value = in[iii] * static_cast<float>(INT32_MAX);
value = std::min(std::max(static_cast<float>(INT32_MIN), value), static_cast<float>(INT32_MAX)); value = etk::min(etk::max(static_cast<float>(INT32_MIN), value), static_cast<float>(INT32_MAX));
out[iii] = static_cast<int32_t>(value); out[iii] = static_cast<int32_t>(value);
} }
} }

14
audio/drain/IOFormatInterface.cpp
View File

@ -7,7 +7,7 @@
#include "IOFormatInterface.hpp" #include "IOFormatInterface.hpp"
#include "debug.hpp" #include "debug.hpp"
std::ostream& audio::drain::operator <<(std::ostream& _os, const IOFormatInterface& _obj) { etk::Stream& audio::drain::operator <<(etk::Stream& _os, const IOFormatInterface& _obj) {
_os << "{"; _os << "{";
if (_obj.getConfigured() == false) { if (_obj.getConfigured() == false) {
_os << "Not configured"; _os << "Not configured";
@ -25,11 +25,11 @@ audio::drain::IOFormatInterface::IOFormatInterface() :
m_format(audio::format_unknow), m_format(audio::format_unknow),
m_map(), m_map(),
m_frequency(0) { m_frequency(0) {
m_map.push_back(audio::channel_frontLeft); m_map.pushBack(audio::channel_frontLeft);
m_map.push_back(audio::channel_frontRight); m_map.pushBack(audio::channel_frontRight);
} }
audio::drain::IOFormatInterface::IOFormatInterface(std::vector<enum audio::channel> _map, enum audio::format _format, float _frequency) : audio::drain::IOFormatInterface::IOFormatInterface(etk::Vector<enum audio::channel> _map, enum audio::format _format, float _frequency) :
m_configured(true), m_configured(true),
m_format(_format), m_format(_format),
m_map(_map), m_map(_map),
@ -37,7 +37,7 @@ audio::drain::IOFormatInterface::IOFormatInterface(std::vector<enum audio::chann
} }
void audio::drain::IOFormatInterface::set(std::vector<enum audio::channel> _map, enum audio::format _format, float _frequency) { void audio::drain::IOFormatInterface::set(etk::Vector<enum audio::channel> _map, enum audio::format _format, float _frequency) {
bool hasChange = false; bool hasChange = false;
if (m_map != _map) { if (m_map != _map) {
m_map = _map; m_map = _map;
@ -78,11 +78,11 @@ void audio::drain::IOFormatInterface::setFormat(enum audio::format _value) {
configurationChange(); configurationChange();
} }
const std::vector<enum audio::channel>& audio::drain::IOFormatInterface::getMap() const{ const etk::Vector<enum audio::channel>& audio::drain::IOFormatInterface::getMap() const{
return m_map; return m_map;
} }
void audio::drain::IOFormatInterface::setMap(const std::vector<enum audio::channel>& _value) { void audio::drain::IOFormatInterface::setMap(const etk::Vector<enum audio::channel>& _value) {
if (m_map == _value) { if (m_map == _value) {
return; return;
} }

16
audio/drain/IOFormatInterface.hpp
View File

@ -5,8 +5,8 @@
*/ */
#pragma once #pragma once
#include <string> #include <etk/String.hpp>
#include <vector> #include <etk/Vector.hpp>
#include <cstdint> #include <cstdint>
#include <audio/format.hpp> #include <audio/format.hpp>
#include <audio/channel.hpp> #include <audio/channel.hpp>
@ -21,8 +21,8 @@ namespace audio {
class IOFormatInterface { class IOFormatInterface {
public: public:
IOFormatInterface(); IOFormatInterface();
IOFormatInterface(std::vector<enum audio::channel> _map, enum audio::format _format=audio::format_int16, float _frequency=48000.0f); IOFormatInterface(etk::Vector<enum audio::channel> _map, enum audio::format _format=audio::format_int16, float _frequency=48000.0f);
void set(std::vector<enum audio::channel> _map, enum audio::format _format=audio::format_int16, float _frequency=48000.0f); void set(etk::Vector<enum audio::channel> _map, enum audio::format _format=audio::format_int16, float _frequency=48000.0f);
protected: protected:
bool m_configured; bool m_configured;
public: public:
@ -42,18 +42,18 @@ namespace audio {
*/ */
void setFormat(enum audio::format _value); void setFormat(enum audio::format _value);
protected: protected:
std::vector<enum audio::channel> m_map; //!< input channel Map etk::Vector<enum audio::channel> m_map; //!< input channel Map
public: public:
/** /**
* @brief Get the algo channel Map. * @brief Get the algo channel Map.
* @return the current channel Map. * @return the current channel Map.
*/ */
const std::vector<enum audio::channel>& getMap() const; const etk::Vector<enum audio::channel>& getMap() const;
/** /**
* @brief Set the algo channel Map. * @brief Set the algo channel Map.
* @param[in] _value New channel Map. * @param[in] _value New channel Map.
*/ */
void setMap(const std::vector<enum audio::channel>& _value); void setMap(const etk::Vector<enum audio::channel>& _value);
protected: protected:
float m_frequency; //!< input Algo Format float m_frequency; //!< input Algo Format
public: public:
@ -83,7 +83,7 @@ namespace audio {
*/ */
void setCallback(const std::function<void()>& _functor); void setCallback(const std::function<void()>& _functor);
}; };
std::ostream& operator <<(std::ostream& _os, const audio::drain::IOFormatInterface& _obj); etk::Stream& operator <<(etk::Stream& _os, const audio::drain::IOFormatInterface& _obj);
} }
} }

124
audio/drain/Process.cpp
View File

@ -4,8 +4,8 @@
* @license MPL v2.0 (see license file) * @license MPL v2.0 (see license file)
*/ */
#include <string> #include <etk/String.hpp>
#include <vector> #include <etk/Vector.hpp>
#include <cstdint> #include <cstdint>
#include <audio/format.hpp> #include <audio/format.hpp>
#include <audio/channel.hpp> #include <audio/channel.hpp>
@ -69,7 +69,7 @@ bool audio::drain::Process::pull(audio::Time& _time,
} }
} }
// copy only data availlable : // copy only data availlable :
int32_t minByTeSize = std::min(m_data.size(), _nbChunk*_chunkSize); int32_t minByTeSize = etk::min(m_data.size(), _nbChunk*_chunkSize);
if (minByTeSize >= 0) { if (minByTeSize >= 0) {
memcpy(_data, &m_data[0], minByTeSize); memcpy(_data, &m_data[0], minByTeSize);
m_data.erase(m_data.begin(), m_data.begin()+minByTeSize); m_data.erase(m_data.begin(), m_data.begin()+minByTeSize);
@ -104,7 +104,7 @@ bool audio::drain::Process::process(audio::Time& _time,
void audio::drain::Process::pushBack(ememory::SharedPtr<audio::drain::Algo> _algo) { void audio::drain::Process::pushBack(ememory::SharedPtr<audio::drain::Algo> _algo) {
removeAlgoDynamic(); removeAlgoDynamic();
_algo->setStatusFunction(std::bind(&audio::drain::Process::generateStatus, this, std::placeholders::_1, std::placeholders::_2)); _algo->setStatusFunction(std::bind(&audio::drain::Process::generateStatus, this, std::placeholders::_1, std::placeholders::_2));
m_listAlgo.push_back(_algo); m_listAlgo.pushBack(_algo);
} }
void audio::drain::Process::pushFront(ememory::SharedPtr<audio::drain::Algo> _algo) { void audio::drain::Process::pushFront(ememory::SharedPtr<audio::drain::Algo> _algo) {
@ -113,8 +113,8 @@ void audio::drain::Process::pushFront(ememory::SharedPtr<audio::drain::Algo> _al
m_listAlgo.insert(m_listAlgo.begin(), _algo); m_listAlgo.insert(m_listAlgo.begin(), _algo);
} }
template<typename T> std::vector<T> getUnion(const std::vector<T>& _out, const std::vector<T>& _in) { template<typename T> etk::Vector<T> getUnion(const etk::Vector<T>& _out, const std::vector<T>& _in) {
std::vector<T> out; etk::Vector<T> out;
if (_out.size() == 0) { if (_out.size() == 0) {
// Last is ok for all format // Last is ok for all format
// ==> set the limit with the next element // ==> set the limit with the next element
@ -126,7 +126,7 @@ template<typename T> std::vector<T> getUnion(const std::vector<T>& _out, const s
for (size_t ooo=0; ooo<_out.size(); ++ooo) { for (size_t ooo=0; ooo<_out.size(); ++ooo) {
for (size_t iii=0; iii<_in.size(); ++iii) { for (size_t iii=0; iii<_in.size(); ++iii) {
if (_out[ooo] == _in[iii]) { if (_out[ooo] == _in[iii]) {
out.push_back(_out[ooo]); out.pushBack(_out[ooo]);
} }
} }
} }
@ -173,54 +173,54 @@ void audio::drain::Process::updateAlgo(size_t _position) {
) )
) { ) {
// step 1 : check frequency: // step 1 : check frequency:
std::vector<float> freqOut; etk::Vector<float> freqOut;
std::vector<float> freqIn; etk::Vector<float> freqIn;
if (_position == 0) { if (_position == 0) {
freqOut.push_back(m_inputConfig.getFrequency()); freqOut.pushBack(m_inputConfig.getFrequency());
} else { } else {
freqOut = m_listAlgo[_position-1]->getFrequencySupportedOutput(); freqOut = m_listAlgo[_position-1]->getFrequencySupportedOutput();
} }
if (_position == m_listAlgo.size()) { if (_position == m_listAlgo.size()) {
freqIn.push_back(m_outputConfig.getFrequency()); freqIn.pushBack(m_outputConfig.getFrequency());
} else { } else {
freqIn = m_listAlgo[_position]->getFrequencySupportedInput(); freqIn = m_listAlgo[_position]->getFrequencySupportedInput();
} }
std::vector<float> freq = getUnion<float>(freqOut, freqIn); etk::Vector<float> freq = getUnion<float>(freqOut, freqIn);
DRAIN_VERBOSE(" freq out :" << freqOut); DRAIN_VERBOSE(" freq out :" << freqOut);
DRAIN_VERBOSE(" freq in :" << freqIn); DRAIN_VERBOSE(" freq in :" << freqIn);
DRAIN_VERBOSE(" freq union :" << freq); DRAIN_VERBOSE(" freq union :" << freq);
// step 2 : Check map: // step 2 : Check map:
std::vector<std::vector<audio::channel> > mapOut; etk::Vector<etk::Vector<audio::channel> > mapOut;
std::vector<std::vector<audio::channel> > mapIn; etk::Vector<etk::Vector<audio::channel> > mapIn;
if (_position == 0) { if (_position == 0) {
mapOut.push_back(m_inputConfig.getMap()); mapOut.pushBack(m_inputConfig.getMap());
} else { } else {
mapOut = m_listAlgo[_position-1]->getMapSupportedOutput(); mapOut = m_listAlgo[_position-1]->getMapSupportedOutput();
} }
if (_position == m_listAlgo.size()) { if (_position == m_listAlgo.size()) {
mapIn.push_back(m_outputConfig.getMap()); mapIn.pushBack(m_outputConfig.getMap());
} else { } else {
mapIn = m_listAlgo[_position]->getMapSupportedInput(); mapIn = m_listAlgo[_position]->getMapSupportedInput();
} }
std::vector<std::vector<audio::channel> > map = getUnion<std::vector<audio::channel> >(mapOut, mapIn); etk::Vector<etk::Vector<audio::channel> > map = getUnion<std::vector<audio::channel> >(mapOut, mapIn);
DRAIN_VERBOSE(" map out :" << mapOut); DRAIN_VERBOSE(" map out :" << mapOut);
DRAIN_VERBOSE(" map in :" << mapIn); DRAIN_VERBOSE(" map in :" << mapIn);
DRAIN_VERBOSE(" map union :" << map); DRAIN_VERBOSE(" map union :" << map);
// step 3 : Check Format: // step 3 : Check Format:
std::vector<audio::format> formatOut; etk::Vector<audio::format> formatOut;
std::vector<audio::format> formatIn; etk::Vector<audio::format> formatIn;
if (_position == 0) { if (_position == 0) {
formatOut.push_back(m_inputConfig.getFormat()); formatOut.pushBack(m_inputConfig.getFormat());
} else { } else {
formatOut = m_listAlgo[_position-1]->getFormatSupportedOutput(); formatOut = m_listAlgo[_position-1]->getFormatSupportedOutput();
} }
if (_position == m_listAlgo.size()) { if (_position == m_listAlgo.size()) {
formatIn.push_back(m_outputConfig.getFormat()); formatIn.pushBack(m_outputConfig.getFormat());
} else { } else {
formatIn = m_listAlgo[_position]->getFormatSupportedInput(); formatIn = m_listAlgo[_position]->getFormatSupportedInput();
} }
std::vector<audio::format> format = getUnion<audio::format>(formatOut, formatIn); etk::Vector<audio::format> format = getUnion<audio::format>(formatOut, formatIn);
DRAIN_VERBOSE(" format out :" << formatOut); DRAIN_VERBOSE(" format out :" << formatOut);
DRAIN_VERBOSE(" format in :" << formatIn); DRAIN_VERBOSE(" format in :" << formatIn);
DRAIN_VERBOSE(" format union :" << format); DRAIN_VERBOSE(" format union :" << format);
@ -439,7 +439,7 @@ bool audio::drain::Process::processIn(void* _inData,
return false; return false;
} }
static void link(etk::FSNode& _node, const std::string& _first, const std::string& _op, const std::string& _second, bool _isLink=true) { static void link(etk::FSNode& _node, const etk::String& _first, const etk::String& _op, const std::string& _second, bool _isLink=true) {
if (_op == "->") { if (_op == "->") {
if (_isLink) { if (_isLink) {
_node << " " << _first << " -> " << _second << ";\n"; _node << " " << _first << " -> " << _second << ";\n";
@ -459,8 +459,8 @@ static void link(etk::FSNode& _node, const std::string& _first, const std::strin
void audio::drain::Process::generateDot(etk::FSNode& _node, void audio::drain::Process::generateDot(etk::FSNode& _node,
int32_t _offset, int32_t _offset,
int32_t _basicID, int32_t _basicID,
std::string& _nameIn, etk::String& _nameIn,
std::string& _nameOut, etk::String& _nameOut,
bool _reserseGraph) { bool _reserseGraph) {
_node << " subgraph clusterNode_" << _basicID << "_process {\n"; _node << " subgraph clusterNode_" << _basicID << "_process {\n";
_node << " label=\"Drain::Process" << (_reserseGraph?"_R":"_N") << "\";\n"; _node << " label=\"Drain::Process" << (_reserseGraph?"_R":"_N") << "\";\n";
@ -470,14 +470,14 @@ void audio::drain::Process::generateDot(etk::FSNode& _node,
// ---------------------- // ----------------------
// -- STEP 1 -- // -- STEP 1 --
// ---------------------- // ----------------------
_nameIn = "INTERFACE_ALGO_" + etk::to_string(_basicID) + "_in"; _nameIn = "INTERFACE_ALGO_" + etk::toString(_basicID) + "_in";
_node << " " << _nameIn << " [ label=\"format=" << etk::to_string(getInputConfig().getFormat()) _node << " " << _nameIn << " [ label=\"format=" << etk::toString(getInputConfig().getFormat())
<< "\\n freq=" << getInputConfig().getFrequency() << "\\n freq=" << getInputConfig().getFrequency()
<< "\\n channelMap=" << etk::to_string(getInputConfig().getMap()) << "\\n in\" ];\n"; << "\\n channelMap=" << etk::toString(getInputConfig().getMap()) << "\\n in\" ];\n";
// ---------------------- // ----------------------
// -- STEP 2 -- // -- STEP 2 --
// ---------------------- // ----------------------
std::string connectString = _nameIn; etk::String connectString = _nameIn;
_node << " node [shape=box];\n"; _node << " node [shape=box];\n";
// ---------------------- // ----------------------
// -- STEP 3 -- // -- STEP 3 --
@ -486,12 +486,12 @@ void audio::drain::Process::generateDot(etk::FSNode& _node,
if (m_listAlgo[iii] == nullptr) { if (m_listAlgo[iii] == nullptr) {
continue; continue;
} }
std::string connectStringSecond = "ALGO_" + etk::to_string(_basicID) + "__" + etk::to_string(iii); etk::String connectStringSecond = "ALGO_" + etk::toString(_basicID) + "__" + etk::to_string(iii);
_node << " " << connectStringSecond << " [label=\"ALGO\\ntype='" << m_listAlgo[iii]->getType() << "'"; _node << " " << connectStringSecond << " [label=\"ALGO\\ntype='" << m_listAlgo[iii]->getType() << "'";
if (m_listAlgo[iii]->getName() != "") { if (m_listAlgo[iii]->getName() != "") {
_node << "\\nname='" << m_listAlgo[iii]->getName() << "'"; _node << "\\nname='" << m_listAlgo[iii]->getName() << "'";
} }
std::string tmpDesc = m_listAlgo[iii]->getDotDesc(); etk::String tmpDesc = m_listAlgo[iii]->getDotDesc();
if (tmpDesc.size() != 0) { if (tmpDesc.size() != 0) {
_node << tmpDesc; _node << tmpDesc;
} }
@ -506,10 +506,10 @@ void audio::drain::Process::generateDot(etk::FSNode& _node,
// ---------------------- // ----------------------
// -- STEP 5 -- // -- STEP 5 --
// ---------------------- // ----------------------
_nameOut = "INTERFACE_ALGO_" + etk::to_string(_basicID) + "_out"; _nameOut = "INTERFACE_ALGO_" + etk::toString(_basicID) + "_out";
_node << " " << _nameOut << " [ label=\"format=" << etk::to_string(getOutputConfig().getFormat()) _node << " " << _nameOut << " [ label=\"format=" << etk::toString(getOutputConfig().getFormat())
<< "\\n freq=" << getOutputConfig().getFrequency() << "\\n freq=" << getOutputConfig().getFrequency()
<< "\\n channelMap=" << etk::to_string(getOutputConfig().getMap()) << "\\n out\" ];\n"; << "\\n channelMap=" << etk::toString(getOutputConfig().getMap()) << "\\n out\" ];\n";
// ---------------------- // ----------------------
// -- STEP 6 -- // -- STEP 6 --
// ---------------------- // ----------------------
@ -518,14 +518,14 @@ void audio::drain::Process::generateDot(etk::FSNode& _node,
// ---------------------- // ----------------------
// -- STEP 1 -- // -- STEP 1 --
// ---------------------- // ----------------------
_nameIn = "INTERFACE_ALGO_" + etk::to_string(_basicID) + "_out"; _nameIn = "INTERFACE_ALGO_" + etk::toString(_basicID) + "_out";
_node << " " << _nameIn << " [ label=\"format=" << etk::to_string(getOutputConfig().getFormat()) _node << " " << _nameIn << " [ label=\"format=" << etk::toString(getOutputConfig().getFormat())
<< "\\n freq=" << getOutputConfig().getFrequency() << "\\n freq=" << getOutputConfig().getFrequency()
<< "\\n channelMap=" << etk::to_string(getOutputConfig().getMap()) << "\\n out\" ];\n"; << "\\n channelMap=" << etk::toString(getOutputConfig().getMap()) << "\\n out\" ];\n";
// ---------------------- // ----------------------
// -- STEP 2 -- // -- STEP 2 --
// ---------------------- // ----------------------
std::string connectString = _nameIn; etk::String connectString = _nameIn;
_node << " node [shape=box];\n"; _node << " node [shape=box];\n";
// ---------------------- // ----------------------
// -- STEP 3 -- // -- STEP 3 --
@ -535,12 +535,12 @@ void audio::drain::Process::generateDot(etk::FSNode& _node,
if (m_listAlgo[iii] == nullptr) { if (m_listAlgo[iii] == nullptr) {
continue; continue;
} }
std::string connectStringSecond = "ALGO_" + etk::to_string(_basicID) + "__" + etk::to_string(iii); etk::String connectStringSecond = "ALGO_" + etk::toString(_basicID) + "__" + etk::to_string(iii);
_node << " " << connectStringSecond << " [label=\"ALGO\\ntype='" << m_listAlgo[iii]->getType() << "'"; _node << " " << connectStringSecond << " [label=\"ALGO\\ntype='" << m_listAlgo[iii]->getType() << "'";
if (m_listAlgo[iii]->getName() != "") { if (m_listAlgo[iii]->getName() != "") {
_node << "\\nname='" << m_listAlgo[iii]->getName() << "'"; _node << "\\nname='" << m_listAlgo[iii]->getName() << "'";
} }
std::string tmpDesc = m_listAlgo[iii]->getDotDesc(); etk::String tmpDesc = m_listAlgo[iii]->getDotDesc();
if (tmpDesc.size() != 0) { if (tmpDesc.size() != 0) {
_node << tmpDesc; _node << tmpDesc;
} }
@ -557,10 +557,10 @@ void audio::drain::Process::generateDot(etk::FSNode& _node,
// ---------------------- // ----------------------
// -- STEP 5 -- // -- STEP 5 --
// ---------------------- // ----------------------
_nameOut = "INTERFACE_ALGO_" + etk::to_string(_basicID) + "_in"; _nameOut = "INTERFACE_ALGO_" + etk::toString(_basicID) + "_in";
_node << " " << _nameOut << " [ label=\"format=" << etk::to_string(getInputConfig().getFormat()) _node << " " << _nameOut << " [ label=\"format=" << etk::toString(getInputConfig().getFormat())
<< "\\n freq=" << getInputConfig().getFrequency() << "\\n freq=" << getInputConfig().getFrequency()
<< "\\n channelMap=" << etk::to_string(getInputConfig().getMap()) << "\\n in\" ];\n"; << "\\n channelMap=" << etk::toString(getInputConfig().getMap()) << "\\n in\" ];\n";
// ---------------------- // ----------------------
// -- STEP 6 -- // -- STEP 6 --
// ---------------------- // ----------------------
@ -569,35 +569,35 @@ void audio::drain::Process::generateDot(etk::FSNode& _node,
_node << " }\n"; _node << " }\n";
} }
void audio::drain::Process::generateDotProcess(etk::FSNode& _node, int32_t _offset, int32_t _basicID, std::string& _nameIn, std::string& _nameOut, bool _reserseGraph) { void audio::drain::Process::generateDotProcess(etk::FSNode& _node, int32_t _offset, int32_t _basicID, etk::String& _nameIn, etk::String& _nameOut, bool _reserseGraph) {
_node << " subgraph clusterNode_" << _basicID << "_process {\n"; _node << " subgraph clusterNode_" << _basicID << "_process {\n";
_node << " label=\"Drain::Process" << (_reserseGraph?"_R":"_N") << "\";\n"; _node << " label=\"Drain::Process" << (_reserseGraph?"_R":"_N") << "\";\n";
_node << " node [shape=ellipse];\n"; _node << " node [shape=ellipse];\n";
if (_reserseGraph == true) { if (_reserseGraph == true) {
_nameIn = "INTERFACE_ALGO_" + etk::to_string(_basicID) + "_in"; _nameIn = "INTERFACE_ALGO_" + etk::toString(_basicID) + "_in";
_node << " " << _nameIn << " [ label=\"format=" << etk::to_string(getInputConfig().getFormat()) _node << " " << _nameIn << " [ label=\"format=" << etk::toString(getInputConfig().getFormat())
<< "\\n freq=" << getInputConfig().getFrequency() << "\\n freq=" << getInputConfig().getFrequency()
<< "\\n channelMap=" << etk::to_string(getInputConfig().getMap()) << "\\n in\" ];\n"; << "\\n channelMap=" << etk::toString(getInputConfig().getMap()) << "\\n in\" ];\n";
} else { } else {
_nameIn = "INTERFACE_ALGO_" + etk::to_string(_basicID) + "_out"; _nameIn = "INTERFACE_ALGO_" + etk::toString(_basicID) + "_out";
_node << " " << _nameIn << " [ label=\"format=" << etk::to_string(getOutputConfig().getFormat()) _node << " " << _nameIn << " [ label=\"format=" << etk::toString(getOutputConfig().getFormat())
<< "\\n freq=" << getOutputConfig().getFrequency() << "\\n freq=" << getOutputConfig().getFrequency()
<< "\\n channelMap=" << etk::to_string(getOutputConfig().getMap()) << "\\n out\" ];\n"; << "\\n channelMap=" << etk::toString(getOutputConfig().getMap()) << "\\n out\" ];\n";
} }
std::string connectString = _nameIn; etk::String connectString = _nameIn;
_node << " node [shape=box];\n"; _node << " node [shape=box];\n";
if (_reserseGraph == false) { if (_reserseGraph == false) {
for (size_t iii=0; iii<m_listAlgo.size(); ++iii) { for (size_t iii=0; iii<m_listAlgo.size(); ++iii) {
if (m_listAlgo[iii] == nullptr) { if (m_listAlgo[iii] == nullptr) {
continue; continue;
} }
std::string connectStringSecond = "ALGO_" + etk::to_string(_basicID) + "__" + etk::to_string(iii); etk::String connectStringSecond = "ALGO_" + etk::toString(_basicID) + "__" + etk::to_string(iii);
_node << " " << connectStringSecond << " [label=\"ALGO\\ntype='" << m_listAlgo[iii]->getType() << "'"; _node << " " << connectStringSecond << " [label=\"ALGO\\ntype='" << m_listAlgo[iii]->getType() << "'";
if (m_listAlgo[iii]->getName() != "") { if (m_listAlgo[iii]->getName() != "") {
_node << "\\nname='" << m_listAlgo[iii]->getName() << "'"; _node << "\\nname='" << m_listAlgo[iii]->getName() << "'";
} }
std::string tmpDesc = m_listAlgo[iii]->getDotDesc(); etk::String tmpDesc = m_listAlgo[iii]->getDotDesc();
if (tmpDesc.size() != 0) { if (tmpDesc.size() != 0) {
_node << tmpDesc; _node << tmpDesc;
} }
@ -611,12 +611,12 @@ void audio::drain::Process::generateDotProcess(etk::FSNode& _node, int32_t _offs
if (m_listAlgo[iii] == nullptr) { if (m_listAlgo[iii] == nullptr) {
continue; continue;
} }
std::string connectStringSecond = "ALGO_" + etk::to_string(_basicID) + "__" + etk::to_string(iii); etk::String connectStringSecond = "ALGO_" + etk::toString(_basicID) + "__" + etk::to_string(iii);
_node << " " << connectStringSecond << " [label=\"ALGO\\ntype='" << m_listAlgo[iii]->getType() << "'"; _node << " " << connectStringSecond << " [label=\"ALGO\\ntype='" << m_listAlgo[iii]->getType() << "'";
if (m_listAlgo[iii]->getName() != "") { if (m_listAlgo[iii]->getName() != "") {
_node << "\\nname='" << m_listAlgo[iii]->getName() << "'"; _node << "\\nname='" << m_listAlgo[iii]->getName() << "'";
} }
std::string tmpDesc = m_listAlgo[iii]->getDotDesc(); etk::String tmpDesc = m_listAlgo[iii]->getDotDesc();
if (tmpDesc.size() != 0) { if (tmpDesc.size() != 0) {
_node << tmpDesc; _node << tmpDesc;
} }
@ -627,15 +627,15 @@ void audio::drain::Process::generateDotProcess(etk::FSNode& _node, int32_t _offs
} }
_node << " node [shape=ellipse];\n"; _node << " node [shape=ellipse];\n";
if (_reserseGraph == true) { if (_reserseGraph == true) {
_nameOut = "INTERFACE_ALGO_" + etk::to_string(_basicID) + "_out"; _nameOut = "INTERFACE_ALGO_" + etk::toString(_basicID) + "_out";
_node << " " << _nameOut << " [ label=\"format=" << etk::to_string(getOutputConfig().getFormat()) _node << " " << _nameOut << " [ label=\"format=" << etk::toString(getOutputConfig().getFormat())
<< "\\n freq=" << getOutputConfig().getFrequency() << "\\n freq=" << getOutputConfig().getFrequency()
<< "\\n channelMap=" << etk::to_string(getOutputConfig().getMap()) << "\\n out\" ];\n"; << "\\n channelMap=" << etk::toString(getOutputConfig().getMap()) << "\\n out\" ];\n";
} else { } else {
_nameOut = "INTERFACE_ALGO_" + etk::to_string(_basicID) + "_in"; _nameOut = "INTERFACE_ALGO_" + etk::toString(_basicID) + "_in";
_node << " " << _nameOut << " [ label=\"format=" << etk::to_string(getInputConfig().getFormat()) _node << " " << _nameOut << " [ label=\"format=" << etk::toString(getInputConfig().getFormat())
<< "\\n freq=" << getInputConfig().getFrequency() << "\\n freq=" << getInputConfig().getFrequency()
<< "\\n channelMap=" << etk::to_string(getInputConfig().getMap()) << "\\n in\" ];\n"; << "\\n channelMap=" << etk::toString(getInputConfig().getMap()) << "\\n in\" ];\n";
} }
if (_reserseGraph == false) { if (_reserseGraph == false) {
link(_node, connectString, "->", _nameOut); link(_node, connectString, "->", _nameOut);
@ -646,7 +646,7 @@ void audio::drain::Process::generateDotProcess(etk::FSNode& _node, int32_t _offs
} }
void audio::drain::Process::generateStatus(const std::string& _origin, const std::string& _status) { void audio::drain::Process::generateStatus(const etk::String& _origin, const etk::String& _status) {
if (m_statusFunction != nullptr) { if (m_statusFunction != nullptr) {
m_statusFunction(_origin, _status); m_statusFunction(_origin, _status);
} }

24
audio/drain/Process.hpp
View File

@ -5,8 +5,8 @@
*/ */
#pragma once #pragma once
#include <string> #include <etk/String.hpp>
#include <vector> #include <etk/Vector.hpp>
#include <cstdint> #include <cstdint>
#include <audio/format.hpp> #include <audio/format.hpp>
#include <audio/channel.hpp> #include <audio/channel.hpp>
@ -17,10 +17,10 @@
namespace audio { namespace audio {
namespace drain{ namespace drain{
typedef std::function<void (const std::string& _origin, const std::string& _status)> statusFunction; typedef std::function<void (const etk::String& _origin, const etk::String& _status)> statusFunction;
class Process { class Process {
protected: protected:
std::vector<int8_t> m_data; //!< temporary overlap output buffer (change size of the output data) etk::Vector<int8_t> m_data; //!< temporary overlap output buffer (change size of the output data)
public: public:
Process(); Process();
virtual ~Process(); virtual ~Process();
@ -94,7 +94,7 @@ namespace audio {
m_outputConfig = _interface; m_outputConfig = _interface;
} }
protected: protected:
std::vector<ememory::SharedPtr<drain::Algo> > m_listAlgo; etk::Vector<ememory::SharedPtr<drain::Algo> > m_listAlgo;
public: public:
void pushBack(ememory::SharedPtr<drain::Algo> _algo); void pushBack(ememory::SharedPtr<drain::Algo> _algo);
void pushFront(ememory::SharedPtr<drain::Algo> _algo); void pushFront(ememory::SharedPtr<drain::Algo> _algo);
@ -105,17 +105,17 @@ namespace audio {
size_t size() { size_t size() {
return m_listAlgo.size(); return m_listAlgo.size();
} }
std::vector<ememory::SharedPtr<drain::Algo> >::iterator begin() { etk::Vector<ememory::SharedPtr<drain::Algo> >::iterator begin() {
return m_listAlgo.begin(); return m_listAlgo.begin();
} }
std::vector<ememory::SharedPtr<drain::Algo> >::iterator end() { etk::Vector<ememory::SharedPtr<drain::Algo> >::iterator end() {
return m_listAlgo.end(); return m_listAlgo.end();
} }
ememory::SharedPtr<drain::Algo> operator[](int32_t _id) { ememory::SharedPtr<drain::Algo> operator[](int32_t _id) {
return m_listAlgo[_id]; return m_listAlgo[_id];
} }
template<typename T> ememory::SharedPtr<T> get(const std::string& _name) { template<typename T> ememory::SharedPtr<T> get(const etk::String& _name) {
for (size_t iii=0; iii<m_listAlgo.size(); ++iii) { for (size_t iii=0; iii<m_listAlgo.size(); ++iii) {
if (m_listAlgo[iii] == nullptr) { if (m_listAlgo[iii] == nullptr) {
continue; continue;
@ -126,7 +126,7 @@ namespace audio {
} }
return ememory::SharedPtr<T>(); return ememory::SharedPtr<T>();
} }
template<typename T> ememory::SharedPtr<const T> get(const std::string& _name) const { template<typename T> ememory::SharedPtr<const T> get(const etk::String& _name) const {
for (size_t iii=0; iii<m_listAlgo.size(); ++iii) { for (size_t iii=0; iii<m_listAlgo.size(); ++iii) {
if (m_listAlgo[iii] == nullptr) { if (m_listAlgo[iii] == nullptr) {
continue; continue;
@ -168,7 +168,7 @@ namespace audio {
private: private:
statusFunction m_statusFunction; statusFunction m_statusFunction;
public: public:
void generateStatus(const std::string& _origin, const std::string& _status); void generateStatus(const etk::String& _origin, const etk::String& _status);
void setStatusFunction(statusFunction _newFunction); void setStatusFunction(statusFunction _newFunction);
private: private:
bool m_isConfigured; bool m_isConfigured;
@ -179,9 +179,9 @@ namespace audio {
void displayAlgo(); void displayAlgo();
void updateAlgo(size_t _position); void updateAlgo(size_t _position);
public: public:
void generateDot(etk::FSNode& _node, int32_t _offset, int32_t _basicID, std::string& _nameIn, std::string& _nameOut, bool _reserseGraph); void generateDot(etk::FSNode& _node, int32_t _offset, int32_t _basicID, etk::String& _nameIn, etk::String& _nameOut, bool _reserseGraph);
// TODO : Remove this one when we find a good way to do it ... // TODO : Remove this one when we find a good way to do it ...
void generateDotProcess(etk::FSNode& _node, int32_t _offset, int32_t _basicID, std::string& _nameIn, std::string& _nameOut, bool _reserseGraph); void generateDotProcess(etk::FSNode& _node, int32_t _offset, int32_t _basicID, etk::String& _nameIn, etk::String& _nameOut, bool _reserseGraph);
}; };
} }
} }

2
audio/drain/Resampler.cpp
View File

@ -20,7 +20,7 @@ audio::drain::Resampler::Resampler() :
void audio::drain::Resampler::init() { void audio::drain::Resampler::init() {
audio::drain::Algo::init(); audio::drain::Algo::init();
m_type = "Resampler"; m_type = "Resampler";
m_supportedFormat.push_back(audio::format_int16); m_supportedFormat.pushBack(audio::format_int16);
m_residualTimeInResampler = audio::Duration(0); m_residualTimeInResampler = audio::Duration(0);
} }

46
audio/drain/Volume.cpp
View File

@ -18,8 +18,8 @@ audio::drain::Volume::Volume() :
void audio::drain::Volume::init() { void audio::drain::Volume::init() {
audio::drain::Algo::init(); audio::drain::Algo::init();
m_type = "Volume"; m_type = "Volume";
m_supportedFormat.push_back(audio::format_int16); m_supportedFormat.pushBack(audio::format_int16);
m_supportedFormat.push_back(audio::format_int16_on_int32); m_supportedFormat.pushBack(audio::format_int16_on_int32);
} }
ememory::SharedPtr<audio::drain::Volume> audio::drain::Volume::create() { ememory::SharedPtr<audio::drain::Volume> audio::drain::Volume::create() {
@ -37,7 +37,7 @@ static int32_t neareastsss(float _val) {
while (_val > float(1<<out)) { while (_val > float(1<<out)) {
out++; out++;
} }
return std::min(16,out); return etk::min(16,out);
} }
@ -294,32 +294,32 @@ void audio::drain::Volume::volumeChange() {
} }
std::vector<audio::format> audio::drain::Volume::getFormatSupportedInput() { etk::Vector<audio::format> audio::drain::Volume::getFormatSupportedInput() {
std::vector<audio::format> tmp; etk::Vector<audio::format> tmp;
if (m_output.getFormat() == audio::format_float) { if (m_output.getFormat() == audio::format_float) {
tmp.push_back(audio::format_float); tmp.pushBack(audio::format_float);
} }
if ( m_output.getFormat() == audio::format_int16 if ( m_output.getFormat() == audio::format_int16
|| m_output.getFormat() == audio::format_int16_on_int32 || m_output.getFormat() == audio::format_int16_on_int32
|| m_output.getFormat() == audio::format_int32) { || m_output.getFormat() == audio::format_int32) {
tmp.push_back(audio::format_int16); tmp.pushBack(audio::format_int16);
tmp.push_back(audio::format_int16_on_int32); tmp.pushBack(audio::format_int16_on_int32);
tmp.push_back(audio::format_int32); tmp.pushBack(audio::format_int32);
} }
return tmp; return tmp;
}; };
std::vector<audio::format> audio::drain::Volume::getFormatSupportedOutput() { etk::Vector<audio::format> audio::drain::Volume::getFormatSupportedOutput() {
std::vector<audio::format> tmp; etk::Vector<audio::format> tmp;
if (m_input.getFormat() == audio::format_float) { if (m_input.getFormat() == audio::format_float) {
tmp.push_back(audio::format_float); tmp.pushBack(audio::format_float);
} }
if ( m_input.getFormat() == audio::format_int16 if ( m_input.getFormat() == audio::format_int16
|| m_input.getFormat() == audio::format_int16_on_int32 || m_input.getFormat() == audio::format_int16_on_int32
|| m_input.getFormat() == audio::format_int32) { || m_input.getFormat() == audio::format_int32) {
tmp.push_back(audio::format_int16); tmp.pushBack(audio::format_int16);
tmp.push_back(audio::format_int16_on_int32); tmp.pushBack(audio::format_int16_on_int32);
tmp.push_back(audio::format_int32); tmp.pushBack(audio::format_int32);
} }
return tmp; return tmp;
}; };
@ -371,11 +371,11 @@ void audio::drain::Volume::addVolumeStage(const ememory::SharedPtr<audio::drain:
return; return;
} }
} }
m_volumeList.push_back(_volume); m_volumeList.pushBack(_volume);
volumeChange(); volumeChange();
} }
bool audio::drain::Volume::setParameter(const std::string& _parameter, const std::string& _value) { bool audio::drain::Volume::setParameter(const etk::String& _parameter, const etk::String& _value) {
if (_parameter == "FLOW") { if (_parameter == "FLOW") {
// set Volume ... // set Volume ...
for (auto &it : m_volumeList) { for (auto &it : m_volumeList) {
@ -403,7 +403,7 @@ bool audio::drain::Volume::setParameter(const std::string& _parameter, const std
return false; return false;
} }
std::string audio::drain::Volume::getParameter(const std::string& _parameter) const { etk::String audio::drain::Volume::getParameter(const etk::String& _parameter) const {
if (_parameter == "FLOW") { if (_parameter == "FLOW") {
// set Volume ... // set Volume ...
for (auto &it : m_volumeList) { for (auto &it : m_volumeList) {
@ -411,7 +411,7 @@ std::string audio::drain::Volume::getParameter(const std::string& _parameter) co
continue; continue;
} }
if (it->getName() == "FLOW") { if (it->getName() == "FLOW") {
return etk::to_string(it->getVolume()) + "dB"; return etk::toString(it->getVolume()) + "dB";
} }
} }
} }
@ -419,7 +419,7 @@ std::string audio::drain::Volume::getParameter(const std::string& _parameter) co
return "[ERROR]"; return "[ERROR]";
} }
std::string audio::drain::Volume::getParameterProperty(const std::string& _parameter) const { etk::String audio::drain::Volume::getParameterProperty(const etk::String& _parameter) const {
if (_parameter == "FLOW") { if (_parameter == "FLOW") {
// set Volume ... // set Volume ...
for (auto &it : m_volumeList) { for (auto &it : m_volumeList) {
@ -435,13 +435,13 @@ std::string audio::drain::Volume::getParameterProperty(const std::string& _param
return "[ERROR]"; return "[ERROR]";
} }
std::string audio::drain::Volume::getDotDesc() { etk::String audio::drain::Volume::getDotDesc() {
std::string out = audio::drain::Algo::getDotDesc(); etk::String out = audio::drain::Algo::getDotDesc();
for (auto &it : m_volumeList) { for (auto &it : m_volumeList) {
if (it == nullptr) { if (it == nullptr) {
continue; continue;
} }
out += "\\n" + it->getName() + "=" + etk::to_string(it->getVolume()) + "dB"; out += "\\n" + it->getName() + "=" + etk::toString(it->getVolume()) + "dB";
if (it->getMute() == true) { if (it->getMute() == true) {
out += " MUTE"; out += " MUTE";
} }

20
audio/drain/Volume.hpp
View File

@ -16,16 +16,16 @@ namespace audio {
// data structure. // data structure.
class VolumeElement { class VolumeElement {
public: public:
VolumeElement(const std::string& _name="ERROR-VOLUME-NAME", float _volumedB=0.0f) : VolumeElement(const etk::String& _name="ERROR-VOLUME-NAME", float _volumedB=0.0f) :
m_name(_name), m_name(_name),
m_volumedB(_volumedB), m_volumedB(_volumedB),
m_mute(false) { m_mute(false) {
} }
private: private:
std::string m_name; etk::String m_name;
public: public:
std::string getName() const { etk::String getName() const {
return m_name; return m_name;
} }
private: private:
@ -54,7 +54,7 @@ namespace audio {
// TODO: Manage set volume // TODO: Manage set volume
class Volume : public audio::drain::Algo { class Volume : public audio::drain::Algo {
private: private:
std::vector<ememory::SharedPtr<drain::VolumeElement> > m_volumeList; etk::Vector<ememory::SharedPtr<drain::VolumeElement> > m_volumeList;
// for float input : // for float input :
float m_volumeAppli; float m_volumeAppli;
// for integer input : // for integer input :
@ -83,17 +83,17 @@ namespace audio {
void*& _output, void*& _output,
size_t& _outputNbChunk); size_t& _outputNbChunk);
public: public:
virtual std::vector<audio::format> getFormatSupportedInput(); virtual etk::Vector<audio::format> getFormatSupportedInput();
virtual std::vector<audio::format> getFormatSupportedOutput(); virtual etk::Vector<audio::format> getFormatSupportedOutput();
public: public:
virtual void addVolumeStage(const ememory::SharedPtr<drain::VolumeElement>& _volume); virtual void addVolumeStage(const ememory::SharedPtr<drain::VolumeElement>& _volume);
virtual bool setParameter(const std::string& _parameter, const std::string& _value); virtual bool setParameter(const etk::String& _parameter, const etk::String& _value);
virtual std::string getParameter(const std::string& _parameter) const; virtual etk::String getParameter(const etk::String& _parameter) const;
virtual std::string getParameterProperty(const std::string& _parameter) const; virtual etk::String getParameterProperty(const etk::String& _parameter) const;
public: public:
void volumeChange(); void volumeChange();
public: public:
virtual std::string getDotDesc(); virtual etk::String getDotDesc();
}; };
} }
} }

8
audio/drain/airtalgo.hpp
View File

@ -5,7 +5,7 @@
*/ */
#pragma once #pragma once
#include <string> #include <etk/String.hpp>
#include <audio/format.hpp> #include <audio/format.hpp>
#include <audio/drain/channel.hpp> #include <audio/drain/channel.hpp>
#include <chrono> #include <chrono>
@ -25,18 +25,18 @@ namespace audio {
* @param[in] _name Name of the Algorithm. * @param[in] _name Name of the Algorithm.
* @return Instanciate algorithm * @return Instanciate algorithm
*/ */
drain::Algo* createAlgo(const std::string& _name); drain::Algo* createAlgo(const etk::String& _name);
/** /**
* @brief Add a Factory Algorithm in the internal List (static for all instance) * @brief Add a Factory Algorithm in the internal List (static for all instance)
* @param[in] _name Name of the Algorithm. * @param[in] _name Name of the Algorithm.
* @param[in] _functor Function of the factory * @param[in] _functor Function of the factory
*/ */
void addAlgoFactory(const std::string& _name, std::function<drain::Algo*(void)> _functor); void addAlgoFactory(const etk::String& _name, std::function<drain::Algo*(void)> _functor);
/** /**
* @brief Remove a Factory Algorithm in the internal List (static for all instance) * @brief Remove a Factory Algorithm in the internal List (static for all instance)
* @param[in] _name Name of the Algorithm. * @param[in] _name Name of the Algorithm.
*/ */
void RmAlgoFactory(const std::string& _name); void RmAlgoFactory(const etk::String& _name);
} }
} }

2
test/main.cpp
View File

@ -14,7 +14,7 @@ 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);
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 ( data == "-h" if ( data == "-h"
|| data == "--help") { || data == "--help") {
TEST_INFO("Help : "); TEST_INFO("Help : ");

104
tools/drainBiQuadProfiling/appl/Windows.cpp
View File

@ -40,26 +40,26 @@ appl::Windows::Windows() :
m_gain(0.0), m_gain(0.0),
m_quality(0.707) { m_quality(0.707) {
addObjectType("appl::Windows"); addObjectType("appl::Windows");
m_listSampleRate.push_back(192000); m_listSampleRate.pushBack(192000);
m_listSampleRate.push_back(176400); m_listSampleRate.pushBack(176400);
m_listSampleRate.push_back(96000); m_listSampleRate.pushBack(96000);
m_listSampleRate.push_back(88200); m_listSampleRate.pushBack(88200);
m_listSampleRate.push_back(48000); m_listSampleRate.pushBack(48000);
m_listSampleRate.push_back(44100); m_listSampleRate.pushBack(44100);
m_listSampleRate.push_back(32000); m_listSampleRate.pushBack(32000);
m_listSampleRate.push_back(22050); m_listSampleRate.pushBack(22050);
m_listSampleRate.push_back(16000); m_listSampleRate.pushBack(16000);
m_listSampleRate.push_back(11025); m_listSampleRate.pushBack(11025);
m_listSampleRate.push_back(8000); m_listSampleRate.pushBack(8000);
m_listSampleRate.push_back(4000); m_listSampleRate.pushBack(4000);
m_listType.push_back(audio::algo::drain::biQuadType_none); m_listType.pushBack(audio::algo::drain::biQuadType_none);
m_listType.push_back(audio::algo::drain::biQuadType_lowPass); m_listType.pushBack(audio::algo::drain::biQuadType_lowPass);
m_listType.push_back(audio::algo::drain::biQuadType_highPass); m_listType.pushBack(audio::algo::drain::biQuadType_highPass);
m_listType.push_back(audio::algo::drain::biQuadType_bandPass); m_listType.pushBack(audio::algo::drain::biQuadType_bandPass);
m_listType.push_back(audio::algo::drain::biQuadType_notch); m_listType.pushBack(audio::algo::drain::biQuadType_notch);
m_listType.push_back(audio::algo::drain::biQuadType_peak); m_listType.pushBack(audio::algo::drain::biQuadType_peak);
m_listType.push_back(audio::algo::drain::biQuadType_lowShelf); m_listType.pushBack(audio::algo::drain::biQuadType_lowShelf);
m_listType.push_back(audio::algo::drain::biQuadType_highShelf); m_listType.pushBack(audio::algo::drain::biQuadType_highShelf);
} }
void appl::Windows::init() { void appl::Windows::init() {
@ -100,15 +100,15 @@ void appl::Windows::onCallbackSampleRateUp() {
} else { } else {
m_sampleRate = m_listSampleRate[0]; m_sampleRate = m_listSampleRate[0];
} }
ewol::parameterSetOnObjectNamed("sample-rate", "value", etk::to_string(m_sampleRate)); ewol::parameterSetOnObjectNamed("sample-rate", "value", etk::toString(m_sampleRate));
ewol::parameterSetOnObjectNamed("frequency-slider", "max", etk::to_string(m_sampleRate/2)); ewol::parameterSetOnObjectNamed("frequency-slider", "max", etk::toString(m_sampleRate/2));
onCallbackStart(); onCallbackStart();
return; return;
} }
} }
m_sampleRate = m_listSampleRate[0]; m_sampleRate = m_listSampleRate[0];
ewol::parameterSetOnObjectNamed("sample-rate", "value", etk::to_string(m_sampleRate)); ewol::parameterSetOnObjectNamed("sample-rate", "value", etk::toString(m_sampleRate));
ewol::parameterSetOnObjectNamed("frequency-slider", "max", etk::to_string(m_sampleRate/2)); ewol::parameterSetOnObjectNamed("frequency-slider", "max", etk::toString(m_sampleRate/2));
onCallbackStart(); onCallbackStart();
} }
@ -121,15 +121,15 @@ void appl::Windows::onCallbackSampleRateLow() {
} else { } else {
m_sampleRate = m_listSampleRate[m_listSampleRate.size()-1]; m_sampleRate = m_listSampleRate[m_listSampleRate.size()-1];
} }
ewol::parameterSetOnObjectNamed("sample-rate", "value", etk::to_string(m_sampleRate)); ewol::parameterSetOnObjectNamed("sample-rate", "value", etk::toString(m_sampleRate));
ewol::parameterSetOnObjectNamed("frequency-slider", "max", etk::to_string(m_sampleRate/2)); ewol::parameterSetOnObjectNamed("frequency-slider", "max", etk::toString(m_sampleRate/2));
onCallbackStart(); onCallbackStart();
return; return;
} }
} }
m_sampleRate = m_listSampleRate[0]; m_sampleRate = m_listSampleRate[0];
ewol::parameterSetOnObjectNamed("sample-rate", "value", etk::to_string(m_sampleRate)); ewol::parameterSetOnObjectNamed("sample-rate", "value", etk::toString(m_sampleRate));
ewol::parameterSetOnObjectNamed("frequency-slider", "max", etk::to_string(m_sampleRate/2)); ewol::parameterSetOnObjectNamed("frequency-slider", "max", etk::toString(m_sampleRate/2));
onCallbackStart(); onCallbackStart();
} }
@ -142,13 +142,13 @@ void appl::Windows::onCallbackTypeUp() {
} else { } else {
m_type = m_listType[0]; m_type = m_listType[0];
} }
ewol::parameterSetOnObjectNamed("type", "value", etk::to_string(m_type)); ewol::parameterSetOnObjectNamed("type", "value", etk::toString(m_type));
onCallbackStart(); onCallbackStart();
return; return;
} }
} }
m_type = m_listType[0]; m_type = m_listType[0];
ewol::parameterSetOnObjectNamed("type", "value", etk::to_string(m_type)); ewol::parameterSetOnObjectNamed("type", "value", etk::toString(m_type));
onCallbackStart(); onCallbackStart();
} }
@ -161,58 +161,58 @@ void appl::Windows::onCallbackTypeLow() {
} else { } else {
m_type = m_listType[m_listType.size()-1]; m_type = m_listType[m_listType.size()-1];
} }
ewol::parameterSetOnObjectNamed("type", "value", etk::to_string(m_type)); ewol::parameterSetOnObjectNamed("type", "value", etk::toString(m_type));
onCallbackStart(); onCallbackStart();
return; return;
} }
} }
m_type = m_listType[0]; m_type = m_listType[0];
ewol::parameterSetOnObjectNamed("type", "value", etk::to_string(m_type)); ewol::parameterSetOnObjectNamed("type", "value", etk::toString(m_type));
onCallbackStart(); onCallbackStart();
} }
void appl::Windows::onCallbackGain(const std::string& _value) { void appl::Windows::onCallbackGain(const etk::String& _value) {
m_gain = etk::string_to_float(_value); m_gain = etk::string_to_float(_value);
ewol::parameterSetOnObjectNamed("gain-slider", "value", etk::to_string(_value)); ewol::parameterSetOnObjectNamed("gain-slider", "value", etk::toString(_value));
APPL_INFO("Gain " << m_gain); APPL_INFO("Gain " << m_gain);
onCallbackStart(); onCallbackStart();
} }
void appl::Windows::onCallbackGainSlider(const float& _value) { void appl::Windows::onCallbackGainSlider(const float& _value) {
m_gain = _value; m_gain = _value;
ewol::parameterSetOnObjectNamed("gain", "value", etk::to_string(_value)); ewol::parameterSetOnObjectNamed("gain", "value", etk::toString(_value));
APPL_INFO("Gain " << m_gain); APPL_INFO("Gain " << m_gain);
onCallbackStart(); onCallbackStart();
} }
void appl::Windows::onCallbackQuality(const std::string& _value) { void appl::Windows::onCallbackQuality(const etk::String& _value) {
m_quality = etk::string_to_float(_value); m_quality = etk::string_to_float(_value);
ewol::parameterSetOnObjectNamed("quality-slider", "value", etk::to_string(_value)); ewol::parameterSetOnObjectNamed("quality-slider", "value", etk::toString(_value));
APPL_INFO("quality " << m_quality); APPL_INFO("quality " << m_quality);
onCallbackStart(); onCallbackStart();
} }
void appl::Windows::onCallbackQualitySlider(const float& _value) { void appl::Windows::onCallbackQualitySlider(const float& _value) {
m_quality = _value; m_quality = _value;
ewol::parameterSetOnObjectNamed("quality", "value", etk::to_string(_value)); ewol::parameterSetOnObjectNamed("quality", "value", etk::toString(_value));
APPL_INFO("quality " << m_quality); APPL_INFO("quality " << m_quality);
onCallbackStart(); onCallbackStart();
} }
void appl::Windows::onCallbackFrequency(const std::string& _value) { void appl::Windows::onCallbackFrequency(const etk::String& _value) {
m_cutFrequency = etk::string_to_float(_value); m_cutFrequency = etk::string_to_float(_value);
ewol::parameterSetOnObjectNamed("frequency-slider", "value", etk::to_string(_value)); ewol::parameterSetOnObjectNamed("frequency-slider", "value", etk::toString(_value));
APPL_INFO("cut frequency " << m_cutFrequency); APPL_INFO("cut frequency " << m_cutFrequency);
onCallbackStart(); onCallbackStart();
} }
void appl::Windows::onCallbackFrequencySlider(const float& _value) { void appl::Windows::onCallbackFrequencySlider(const float& _value) {
m_cutFrequency = _value; m_cutFrequency = _value;
ewol::parameterSetOnObjectNamed("frequency", "value", etk::to_string(_value)); ewol::parameterSetOnObjectNamed("frequency", "value", etk::toString(_value));
APPL_INFO("cut frequency " << m_cutFrequency); APPL_INFO("cut frequency " << m_cutFrequency);
onCallbackStart(); onCallbackStart();
} }
@ -225,15 +225,15 @@ void appl::Windows::onCallbackFrequencySlider(const float& _value) {
void appl::Windows::onCallbackStart() { void appl::Windows::onCallbackStart() {
APPL_INFO("start "); APPL_INFO("start ");
int32_t iii = 10; int32_t iii = 10;
std::vector<audio::channel> map; etk::Vector<audio::channel> map;
map.push_back(audio::channel_frontCenter); map.pushBack(audio::channel_frontCenter);
// audio::drain::IOFormatInterface format(map, audio::format_int16, m_sampleRate); // audio::drain::IOFormatInterface format(map, audio::format_int16, m_sampleRate);
// audio::drain::IOFormatInterface format(map, audio::format_float, m_sampleRate); // audio::drain::IOFormatInterface format(map, audio::format_float, m_sampleRate);
// create biquad // create biquad
audio::algo::drain::BiQuad<audio::float_t> bq; audio::algo::drain::BiQuad<audio::float_t> bq;
// configure parameter // configure parameter
bq.setBiquad(m_type, m_cutFrequency, m_quality, m_gain, m_sampleRate); bq.setBiquad(m_type, m_cutFrequency, m_quality, m_gain, m_sampleRate);
std::vector<std::pair<float,float> > theory = bq.calculateTheory(m_sampleRate); etk::Vector<etk::Pair<float,float> > theory = bq.calculateTheory(m_sampleRate);
m_displayer->clear(); m_displayer->clear();
m_displayer->setValue(theory); m_displayer->setValue(theory);
} }
@ -245,7 +245,7 @@ void appl::Windows::onCallbackStart16() {
audio::algo::drain::BiQuad<audio::int16_16_t> bq; audio::algo::drain::BiQuad<audio::int16_16_t> bq;
// configure parameter // configure parameter
bq.setBiquad(m_type, m_cutFrequency, m_quality, m_gain, m_sampleRate); bq.setBiquad(m_type, m_cutFrequency, m_quality, m_gain, m_sampleRate);
std::vector<std::pair<float,float> > pratic; etk::Vector<etk::Pair<float,float> > pratic;
size_t len = 512; size_t len = 512;
for (size_t iii=1; iii < len; iii++) { for (size_t iii=1; iii < len; iii++) {
float freq = iii / (len - 1.0) * m_sampleRate / 2.0; float freq = iii / (len - 1.0) * m_sampleRate / 2.0;
@ -254,7 +254,7 @@ void appl::Windows::onCallbackStart16() {
double m_phase = 0; double m_phase = 0;
double baseCycle = 2.0*M_PI/double(m_sampleRate) * double(freq); double baseCycle = 2.0*M_PI/double(m_sampleRate) * double(freq);
float gain = 0; float gain = 0;
std::vector<audio::int16_16_t> data; etk::Vector<audio::int16_16_t> data;
// create sinus // create sinus
data.resize(16000, 0); data.resize(16000, 0);
for (int32_t iii=0; iii<data.size(); iii++) { for (int32_t iii=0; iii<data.size(); iii++) {
@ -273,11 +273,11 @@ void appl::Windows::onCallbackStart16() {
APPL_SAVE_FILE_MACRO(int16_t,"aaa_test_OUTPUT_16.raw",&data[0],data.size()); APPL_SAVE_FILE_MACRO(int16_t,"aaa_test_OUTPUT_16.raw",&data[0],data.size());
audio::int16_16_t value = 0; audio::int16_16_t value = 0;
for (size_t iii=800; iii<data.size()-200; ++iii) { for (size_t iii=800; iii<data.size()-200; ++iii) {
value = std::max(value, data[iii]); value = etk::max(value, data[iii]);
} }
gain = 20.0 * std::log10(value.getDouble()/32000.0); gain = 20.0 * std::log10(value.getDouble()/32000.0);
APPL_VERBOSE("LEVEL " << iii << " out = " << value << " % : " << gain); APPL_VERBOSE("LEVEL " << iii << " out = " << value << " % : " << gain);
pratic.push_back(std::make_pair<float, float>(float(freq),float(gain))); pratic.pushBack(etk::makePair<float, float>(float(freq),float(gain)));
} }
m_displayer->setValue(pratic); m_displayer->setValue(pratic);
} }
@ -288,7 +288,7 @@ void appl::Windows::onCallbackStartFloat() {
audio::algo::drain::BiQuad<audio::float_t> bq; audio::algo::drain::BiQuad<audio::float_t> bq;
// configure parameter // configure parameter
bq.setBiquad(m_type, m_cutFrequency, m_quality, m_gain, m_sampleRate); bq.setBiquad(m_type, m_cutFrequency, m_quality, m_gain, m_sampleRate);
std::vector<std::pair<float,float> > pratic; etk::Vector<etk::Pair<float,float> > pratic;
size_t len = 512; size_t len = 512;
for (size_t iii=1; iii < len; iii++) { for (size_t iii=1; iii < len; iii++) {
float freq = iii / (len - 1.0) * m_sampleRate / 2.0; float freq = iii / (len - 1.0) * m_sampleRate / 2.0;
@ -297,7 +297,7 @@ void appl::Windows::onCallbackStartFloat() {
double m_phase = 0; double m_phase = 0;
double baseCycle = 2.0*M_PI/double(m_sampleRate) * double(freq); double baseCycle = 2.0*M_PI/double(m_sampleRate) * double(freq);
float gain = 0; float gain = 0;
std::vector<audio::float_t> data; etk::Vector<audio::float_t> data;
// create sinus // create sinus
data.resize(16000, 0); data.resize(16000, 0);
for (int32_t iii=0; iii<data.size(); iii++) { for (int32_t iii=0; iii<data.size(); iii++) {
@ -312,11 +312,11 @@ void appl::Windows::onCallbackStartFloat() {
APPL_SAVE_FILE_MACRO(float,"aaa_test_OUTPUT_F.raw",&data[0],data.size()); APPL_SAVE_FILE_MACRO(float,"aaa_test_OUTPUT_F.raw",&data[0],data.size());
audio::float_t value = 0.0f; audio::float_t value = 0.0f;
for (size_t iii=800; iii<data.size()-200; ++iii) { for (size_t iii=800; iii<data.size()-200; ++iii) {
value = std::max(value, data[iii]); value = etk::max(value, data[iii]);
} }
gain = 20.0 * std::log10(value.getDouble()/1.0); gain = 20.0 * std::log10(value.getDouble()/1.0);
APPL_VERBOSE("LEVEL " << iii << " out = " << value << " % : " << gain); APPL_VERBOSE("LEVEL " << iii << " out = " << value << " % : " << gain);
pratic.push_back(std::make_pair<float, float>(float(freq),float(gain))); pratic.pushBack(etk::makePair<float, float>(float(freq),float(gain)));
} }
m_displayer->setValue(pratic); m_displayer->setValue(pratic);
} }

10
tools/drainBiQuadProfiling/appl/Windows.hpp
View File

@ -25,20 +25,20 @@ namespace appl {
void onCallbackSampleRateUp(); void onCallbackSampleRateUp();
void onCallbackTypeUp(); void onCallbackTypeUp();
void onCallbackTypeLow(); void onCallbackTypeLow();
void onCallbackGain(const std::string& _value); void onCallbackGain(const etk::String& _value);
void onCallbackGainSlider(const float& _value); void onCallbackGainSlider(const float& _value);
void onCallbackFrequency(const std::string& _value); void onCallbackFrequency(const etk::String& _value);
void onCallbackFrequencySlider(const float& _value); void onCallbackFrequencySlider(const float& _value);
void onCallbackQuality(const std::string& _value); void onCallbackQuality(const etk::String& _value);
void onCallbackQualitySlider(const float& _value); void onCallbackQualitySlider(const float& _value);
void onCallbackStart(); void onCallbackStart();
void onCallbackStart16(); void onCallbackStart16();
void onCallbackStartFloat(); void onCallbackStartFloat();
protected: protected:
int32_t m_sampleRate; int32_t m_sampleRate;
std::vector<int32_t> m_listSampleRate; etk::Vector<int32_t> m_listSampleRate;
enum audio::algo::drain::biQuadType m_type; enum audio::algo::drain::biQuadType m_type;
std::vector<enum audio::algo::drain::biQuadType> m_listType; etk::Vector<enum audio::algo::drain::biQuadType> m_listType;
float m_cutFrequency; float m_cutFrequency;
float m_gain; float m_gain;
float m_quality; float m_quality;

24
tools/drainBiQuadProfiling/appl/widget/DisplayFrequency.cpp
View File

@ -28,8 +28,8 @@ appl::widget::DisplayFrequency::~DisplayFrequency() {
} }
void appl::widget::DisplayFrequency::setValue(const std::vector<std::pair<float,float> >& _data) { void appl::widget::DisplayFrequency::setValue(const etk::Vector<etk::Pair<float,float> >& _data) {
m_data.push_back(_data); m_data.pushBack(_data);
markToRedraw(); markToRedraw();
} }
@ -84,21 +84,21 @@ void appl::widget::DisplayFrequency::onRegenerateDisplay() {
for (size_t kkk=0; kkk<m_data.size(); kkk++) { for (size_t kkk=0; kkk<m_data.size(); kkk++) {
for (size_t iii=0; iii<m_data[kkk].size(); ++iii) { for (size_t iii=0; iii<m_data[kkk].size(); ++iii) {
if (std::abs(m_data[kkk][iii].second) != std::numeric_limits<float>::infinity()) { if (std::abs(m_data[kkk][iii].second) != std::numeric_limits<float>::infinity()) {
m_gainMax = std::max(m_gainMax, m_data[kkk][iii].second); m_gainMax = etk::max(m_gainMax, m_data[kkk][iii].second);
m_gainMin = std::min(m_gainMin, m_data[kkk][iii].second); m_gainMin = etk::min(m_gainMin, m_data[kkk][iii].second);
} }
if (displayLog == false) { if (displayLog == false) {
if (std::abs(m_data[kkk][iii].first) != std::numeric_limits<float>::infinity()) { if (std::abs(m_data[kkk][iii].first) != std::numeric_limits<float>::infinity()) {
m_frequencyMax = std::max(m_frequencyMax, m_data[kkk][iii].first); m_frequencyMax = etk::max(m_frequencyMax, m_data[kkk][iii].first);
m_frequencyMin = std::min(m_frequencyMin, m_data[kkk][iii].first); m_frequencyMin = etk::min(m_frequencyMin, m_data[kkk][iii].first);
} }
} else { } else {
if (std::abs(m_data[kkk][iii].first) != std::numeric_limits<float>::infinity()) { if (std::abs(m_data[kkk][iii].first) != std::numeric_limits<float>::infinity()) {
if (m_data[kkk][iii].first == 0) { if (m_data[kkk][iii].first == 0) {
continue; continue;
} }
m_frequencyMax = std::max(m_frequencyMax, std::log(m_data[kkk][iii].first)); m_frequencyMax = etk::max(m_frequencyMax, std::log(m_data[kkk][iii].first));
m_frequencyMin = std::min(m_frequencyMin, std::log(m_data[kkk][iii].first)); m_frequencyMin = etk::min(m_frequencyMin, std::log(m_data[kkk][iii].first));
APPL_INFO("plop " << m_data[kkk][iii].first << " " << std::log(m_data[kkk][iii].first)); APPL_INFO("plop " << m_data[kkk][iii].first << " " << std::log(m_data[kkk][iii].first));
} }
} }
@ -148,22 +148,22 @@ void appl::widget::DisplayFrequency::onRegenerateDisplay() {
} }
} }
m_text.setDefaultColorFg(etk::color::green); m_text.setDefaultColorFg(etk::color::green);
std::string textToDisplay = etk::to_string(m_frequencyMin) + " Hz"; etk::String textToDisplay = etk::toString(m_frequencyMin) + " Hz";
vec3 size = m_text.calculateSize(textToDisplay); vec3 size = m_text.calculateSize(textToDisplay);
m_text.setPos(vec2(m_borderSize.x(), m_borderSize.y()-size.y())); m_text.setPos(vec2(m_borderSize.x(), m_borderSize.y()-size.y()));
m_text.print(textToDisplay); m_text.print(textToDisplay);
textToDisplay = etk::to_string(m_frequencyMax) + " Hz"; textToDisplay = etk::toString(m_frequencyMax) + " Hz";
size = m_text.calculateSize(textToDisplay); size = m_text.calculateSize(textToDisplay);
m_text.setPos(vec2(m_size.x()-m_borderSize.x()-size.x(), m_borderSize.y()-size.y())); m_text.setPos(vec2(m_size.x()-m_borderSize.x()-size.x(), m_borderSize.y()-size.y()));
m_text.print(textToDisplay); m_text.print(textToDisplay);
textToDisplay = etk::to_string(m_gainMin) + " dB"; textToDisplay = etk::toString(m_gainMin) + " dB";
size = m_text.calculateSize(textToDisplay); size = m_text.calculateSize(textToDisplay);
m_text.setPos(vec2(m_borderSize.x(), m_borderSize.y())); m_text.setPos(vec2(m_borderSize.x(), m_borderSize.y()));
m_text.print(textToDisplay); m_text.print(textToDisplay);
textToDisplay = etk::to_string(m_gainMax) + " dB"; textToDisplay = etk::toString(m_gainMax) + " dB";
size = m_text.calculateSize(textToDisplay); size = m_text.calculateSize(textToDisplay);
m_text.setPos(vec2(m_borderSize.x(), m_size.y() - m_borderSize.y())); m_text.setPos(vec2(m_borderSize.x(), m_size.y() - m_borderSize.y()));
m_text.print(textToDisplay); m_text.print(textToDisplay);

4
tools/drainBiQuadProfiling/appl/widget/DisplayFrequency.hpp
View File

@ -25,12 +25,12 @@ namespace appl {
//! @brief destructor //! @brief destructor
virtual ~DisplayFrequency(); virtual ~DisplayFrequency();
private: private:
std::vector<std::vector<std::pair<float,float> > > m_data; //!< data that might be displayed etk::Vector<etk::Vector<etk::Pair<float,float> > > m_data; //!< data that might be displayed
public: public:
void clear() { void clear() {
m_data.clear(); m_data.clear();
} }
void setValue(const std::vector<std::pair<float,float> >& _data); void setValue(const etk::Vector<etk::Pair<float,float> >& _data);
private: private:
float m_gainMin; //!< display minimum gain value float m_gainMin; //!< display minimum gain value
float m_gainMax; //!< display maximum gain value float m_gainMax; //!< display maximum gain value

60
tools/drainEqualizerProfiling/appl/Windows.cpp
View File

@ -34,18 +34,18 @@
appl::Windows::Windows() : appl::Windows::Windows() :
m_sampleRate(48000) { m_sampleRate(48000) {
addObjectType("appl::Windows"); addObjectType("appl::Windows");
m_listSampleRate.push_back(192000); m_listSampleRate.pushBack(192000);
m_listSampleRate.push_back(176400); m_listSampleRate.pushBack(176400);
m_listSampleRate.push_back(96000); m_listSampleRate.pushBack(96000);
m_listSampleRate.push_back(88200); m_listSampleRate.pushBack(88200);
m_listSampleRate.push_back(48000); m_listSampleRate.pushBack(48000);
m_listSampleRate.push_back(44100); m_listSampleRate.pushBack(44100);
m_listSampleRate.push_back(32000); m_listSampleRate.pushBack(32000);
m_listSampleRate.push_back(22050); m_listSampleRate.pushBack(22050);
m_listSampleRate.push_back(16000); m_listSampleRate.pushBack(16000);
m_listSampleRate.push_back(11025); m_listSampleRate.pushBack(11025);
m_listSampleRate.push_back(8000); m_listSampleRate.pushBack(8000);
m_listSampleRate.push_back(4000); m_listSampleRate.pushBack(4000);
m_listGain.resize(10, 0.0f); m_listGain.resize(10, 0.0f);
} }
@ -87,13 +87,13 @@ void appl::Windows::onCallbackSampleRateUp() {
} else { } else {
m_sampleRate = m_listSampleRate[0]; m_sampleRate = m_listSampleRate[0];
} }
ewol::parameterSetOnObjectNamed("sample-rate", "value", etk::to_string(m_sampleRate)); ewol::parameterSetOnObjectNamed("sample-rate", "value", etk::toString(m_sampleRate));
onCallbackStart(); onCallbackStart();
return; return;
} }
} }
m_sampleRate = m_listSampleRate[0]; m_sampleRate = m_listSampleRate[0];
ewol::parameterSetOnObjectNamed("sample-rate", "value", etk::to_string(m_sampleRate)); ewol::parameterSetOnObjectNamed("sample-rate", "value", etk::toString(m_sampleRate));
onCallbackStart(); onCallbackStart();
} }
@ -106,13 +106,13 @@ void appl::Windows::onCallbackSampleRateLow() {
} else { } else {
m_sampleRate = m_listSampleRate[m_listSampleRate.size()-1]; m_sampleRate = m_listSampleRate[m_listSampleRate.size()-1];
} }
ewol::parameterSetOnObjectNamed("sample-rate", "value", etk::to_string(m_sampleRate)); ewol::parameterSetOnObjectNamed("sample-rate", "value", etk::toString(m_sampleRate));
onCallbackStart(); onCallbackStart();
return; return;
} }
} }
m_sampleRate = m_listSampleRate[0]; m_sampleRate = m_listSampleRate[0];
ewol::parameterSetOnObjectNamed("sample-rate", "value", etk::to_string(m_sampleRate)); ewol::parameterSetOnObjectNamed("sample-rate", "value", etk::toString(m_sampleRate));
onCallbackStart(); onCallbackStart();
} }
@ -122,8 +122,8 @@ void appl::Windows::onCallbackGain(const float& _value, int32_t _id) {
} }
ememory::SharedPtr<audio::drain::Equalizer> appl::Windows::createEqualizer(enum audio::format _format) { ememory::SharedPtr<audio::drain::Equalizer> appl::Windows::createEqualizer(enum audio::format _format) {
std::vector<audio::channel> map; etk::Vector<audio::channel> map;
map.push_back(audio::channel_frontCenter); map.pushBack(audio::channel_frontCenter);
audio::drain::IOFormatInterface format(map, _format, m_sampleRate); audio::drain::IOFormatInterface format(map, _format, m_sampleRate);
// create equalizer // create equalizer
ememory::SharedPtr<audio::drain::Equalizer> out = audio::drain::Equalizer::create(); ememory::SharedPtr<audio::drain::Equalizer> out = audio::drain::Equalizer::create();
@ -132,7 +132,7 @@ ememory::SharedPtr<audio::drain::Equalizer> appl::Windows::createEqualizer(enum
// configure output // configure output
out->setOutputFormat(format); out->setOutputFormat(format);
// create ejson: // create ejson:
std::string conf; etk::String conf;
conf += "{\n"; conf += "{\n";
conf += " global: [\n"; conf += " global: [\n";
for (size_t iii=3; iii<m_listGain.size(); ++iii) { for (size_t iii=3; iii<m_listGain.size(); ++iii) {
@ -157,8 +157,8 @@ ememory::SharedPtr<audio::drain::Equalizer> appl::Windows::createEqualizer(enum
conf += " {\n"; conf += " {\n";
conf += " type:'peak',\n"; conf += " type:'peak',\n";
conf += " quality:2,\n"; conf += " quality:2,\n";
conf += " cut-frequency:" + etk::to_string(cutFrequency) + ",\n"; conf += " cut-frequency:" + etk::toString(cutFrequency) + ",\n";
conf += " gain:" + etk::to_string(m_listGain[iii]) + "\n"; conf += " gain:" + etk::toString(m_listGain[iii]) + "\n";
conf += " }\n"; conf += " }\n";
} }
conf += " ]\n"; conf += " ]\n";
@ -172,7 +172,7 @@ ememory::SharedPtr<audio::drain::Equalizer> appl::Windows::createEqualizer(enum
void appl::Windows::onCallbackStart() { void appl::Windows::onCallbackStart() {
APPL_INFO("start "); APPL_INFO("start ");
ememory::SharedPtr<audio::drain::Equalizer> eq = appl::Windows::createEqualizer(); ememory::SharedPtr<audio::drain::Equalizer> eq = appl::Windows::createEqualizer();
std::vector<std::pair<float,float> > theory = eq->calculateTheory(); etk::Vector<etk::Pair<float,float> > theory = eq->calculateTheory();
m_displayer->clear(); m_displayer->clear();
m_displayer->setValue(theory); m_displayer->setValue(theory);
} }
@ -181,9 +181,9 @@ void appl::Windows::onCallbackStart() {
void appl::Windows::onCallbackStart16() { void appl::Windows::onCallbackStart16() {
APPL_INFO("start "); APPL_INFO("start ");
ememory::SharedPtr<audio::drain::Equalizer> eq = appl::Windows::createEqualizer(audio::format_int16); ememory::SharedPtr<audio::drain::Equalizer> eq = appl::Windows::createEqualizer(audio::format_int16);
std::vector<std::pair<float,float> > pratic; etk::Vector<etk::Pair<float,float> > pratic;
size_t len = 512; size_t len = 512;
std::vector<int16_t> data; etk::Vector<int16_t> data;
data.resize(16000, 0); data.resize(16000, 0);
for (size_t iii=1; iii < len; iii++) { for (size_t iii=1; iii < len; iii++) {
float freq = iii / (len - 1.0) * m_sampleRate / 2.0; float freq = iii / (len - 1.0) * m_sampleRate / 2.0;
@ -210,11 +210,11 @@ void appl::Windows::onCallbackStart16() {
APPL_SAVE_FILE_MACRO(int16_t, "aaa_test_OUTPUT.raw", output, outputNbChunk); APPL_SAVE_FILE_MACRO(int16_t, "aaa_test_OUTPUT.raw", output, outputNbChunk);
int16_t value = 0; int16_t value = 0;
for (size_t iii=800; iii<outputNbChunk-200; ++iii) { for (size_t iii=800; iii<outputNbChunk-200; ++iii) {
value = std::max(value, output[iii]); value = etk::max(value, output[iii]);
} }
gain = 20.0 * std::log10(double(value)/32000.0); gain = 20.0 * std::log10(double(value)/32000.0);
APPL_VERBOSE("LEVEL " << iii << " out = " << value << " % : " << gain); APPL_VERBOSE("LEVEL " << iii << " out = " << value << " % : " << gain);
pratic.push_back(std::make_pair<float, float>(float(freq),float(gain))); pratic.pushBack(etk::makePair<float, float>(float(freq),float(gain)));
} }
m_displayer->setValue(pratic); m_displayer->setValue(pratic);
} }
@ -222,9 +222,9 @@ void appl::Windows::onCallbackStart16() {
void appl::Windows::onCallbackStartFloat() { void appl::Windows::onCallbackStartFloat() {
APPL_INFO("start "); APPL_INFO("start ");
ememory::SharedPtr<audio::drain::Equalizer> eq = appl::Windows::createEqualizer(audio::format_float); ememory::SharedPtr<audio::drain::Equalizer> eq = appl::Windows::createEqualizer(audio::format_float);
std::vector<std::pair<float,float> > pratic; etk::Vector<etk::Pair<float,float> > pratic;
size_t len = 512; size_t len = 512;
std::vector<float> data; etk::Vector<float> data;
data.resize(16000, 0); data.resize(16000, 0);
for (size_t iii=1; iii < len; iii++) { for (size_t iii=1; iii < len; iii++) {
float freq = iii / (len - 1.0) * m_sampleRate / 2.0; float freq = iii / (len - 1.0) * m_sampleRate / 2.0;
@ -251,11 +251,11 @@ void appl::Windows::onCallbackStartFloat() {
APPL_SAVE_FILE_MACRO(int16_t,"aaa_test_OUTPUT_F.raw",output, outputNbChunk); APPL_SAVE_FILE_MACRO(int16_t,"aaa_test_OUTPUT_F.raw",output, outputNbChunk);
float value = 0; float value = 0;
for (size_t iii=800; iii<outputNbChunk-200; ++iii) { for (size_t iii=800; iii<outputNbChunk-200; ++iii) {
value = std::max(value, output[iii]); value = etk::max(value, output[iii]);
} }
gain = 20.0 * std::log10(double(value)/1.0); gain = 20.0 * std::log10(double(value)/1.0);
APPL_VERBOSE("LEVEL " << iii << " out = " << value << " % : " << gain); APPL_VERBOSE("LEVEL " << iii << " out = " << value << " % : " << gain);
pratic.push_back(std::make_pair<float, float>(float(freq),float(gain))); pratic.pushBack(etk::makePair<float, float>(float(freq),float(gain)));
} }
m_displayer->setValue(pratic); m_displayer->setValue(pratic);
} }

4
tools/drainEqualizerProfiling/appl/Windows.hpp
View File

@ -59,9 +59,9 @@ namespace appl {
void onCallbackStartFloat(); void onCallbackStartFloat();
protected: protected:
int32_t m_sampleRate; int32_t m_sampleRate;
std::vector<int32_t> m_listSampleRate; etk::Vector<int32_t> m_listSampleRate;
std::vector<float> m_listGain; etk::Vector<float> m_listGain;
ememory::SharedPtr<audio::drain::Equalizer> createEqualizer(enum audio::format _format = audio::format_float); ememory::SharedPtr<audio::drain::Equalizer> createEqualizer(enum audio::format _format = audio::format_float);
}; };
} }

24
tools/drainEqualizerProfiling/appl/widget/DisplayFrequency.cpp
View File

@ -28,8 +28,8 @@ appl::widget::DisplayFrequency::~DisplayFrequency() {
} }
void appl::widget::DisplayFrequency::setValue(const std::vector<std::pair<float,float> >& _data) { void appl::widget::DisplayFrequency::setValue(const etk::Vector<etk::Pair<float,float> >& _data) {
m_data.push_back(_data); m_data.pushBack(_data);
markToRedraw(); markToRedraw();
} }
@ -84,22 +84,22 @@ void appl::widget::DisplayFrequency::onRegenerateDisplay() {
for (size_t kkk=0; kkk<m_data.size(); kkk++) { for (size_t kkk=0; kkk<m_data.size(); kkk++) {
for (size_t iii=0; iii<m_data[kkk].size(); ++iii) { for (size_t iii=0; iii<m_data[kkk].size(); ++iii) {
if (std::abs(m_data[kkk][iii].second) != std::numeric_limits<float>::infinity()) { if (std::abs(m_data[kkk][iii].second) != std::numeric_limits<float>::infinity()) {
m_gainMax = std::max(m_gainMax, m_data[kkk][iii].second); m_gainMax = etk::max(m_gainMax, m_data[kkk][iii].second);
m_gainMin = std::min(m_gainMin, m_data[kkk][iii].second); m_gainMin = etk::min(m_gainMin, m_data[kkk][iii].second);
//APPL_INFO("plop " << m_data[kkk][iii].second); //APPL_INFO("plop " << m_data[kkk][iii].second);
} }
if (displayLog == false) { if (displayLog == false) {
if (std::abs(m_data[kkk][iii].first) != std::numeric_limits<float>::infinity()) { if (std::abs(m_data[kkk][iii].first) != std::numeric_limits<float>::infinity()) {
m_frequencyMax = std::max(m_frequencyMax, m_data[kkk][iii].first); m_frequencyMax = etk::max(m_frequencyMax, m_data[kkk][iii].first);
m_frequencyMin = std::min(m_frequencyMin, m_data[kkk][iii].first); m_frequencyMin = etk::min(m_frequencyMin, m_data[kkk][iii].first);
} }
} else { } else {
if (std::abs(m_data[kkk][iii].first) != std::numeric_limits<float>::infinity()) { if (std::abs(m_data[kkk][iii].first) != std::numeric_limits<float>::infinity()) {
if (m_data[kkk][iii].first == 0) { if (m_data[kkk][iii].first == 0) {
continue; continue;
} }
m_frequencyMax = std::max(m_frequencyMax, std::log(m_data[kkk][iii].first)); m_frequencyMax = etk::max(m_frequencyMax, std::log(m_data[kkk][iii].first));
m_frequencyMin = std::min(m_frequencyMin, std::log(m_data[kkk][iii].first)); m_frequencyMin = etk::min(m_frequencyMin, std::log(m_data[kkk][iii].first));
//APPL_INFO("plop " << m_data[kkk][iii].first << " " << std::log(m_data[kkk][iii].first)); //APPL_INFO("plop " << m_data[kkk][iii].first << " " << std::log(m_data[kkk][iii].first));
} }
} }
@ -155,22 +155,22 @@ void appl::widget::DisplayFrequency::onRegenerateDisplay() {
} }
} }
m_text.setDefaultColorFg(etk::color::green); m_text.setDefaultColorFg(etk::color::green);
std::string textToDisplay = etk::to_string(m_frequencyMin) + " Hz"; etk::String textToDisplay = etk::toString(m_frequencyMin) + " Hz";
vec3 size = m_text.calculateSize(textToDisplay); vec3 size = m_text.calculateSize(textToDisplay);
m_text.setPos(vec2(m_borderSize.x(), m_borderSize.y()-size.y())); m_text.setPos(vec2(m_borderSize.x(), m_borderSize.y()-size.y()));
m_text.print(textToDisplay); m_text.print(textToDisplay);
textToDisplay = etk::to_string(m_frequencyMax) + " Hz"; textToDisplay = etk::toString(m_frequencyMax) + " Hz";
size = m_text.calculateSize(textToDisplay); size = m_text.calculateSize(textToDisplay);
m_text.setPos(vec2(m_size.x()-m_borderSize.x()-size.x(), m_borderSize.y()-size.y())); m_text.setPos(vec2(m_size.x()-m_borderSize.x()-size.x(), m_borderSize.y()-size.y()));
m_text.print(textToDisplay); m_text.print(textToDisplay);
textToDisplay = etk::to_string(m_gainMin) + " dB"; textToDisplay = etk::toString(m_gainMin) + " dB";
size = m_text.calculateSize(textToDisplay); size = m_text.calculateSize(textToDisplay);
m_text.setPos(vec2(m_borderSize.x(), m_borderSize.y())); m_text.setPos(vec2(m_borderSize.x(), m_borderSize.y()));
m_text.print(textToDisplay); m_text.print(textToDisplay);
textToDisplay = etk::to_string(m_gainMax) + " dB"; textToDisplay = etk::toString(m_gainMax) + " dB";
size = m_text.calculateSize(textToDisplay); size = m_text.calculateSize(textToDisplay);
m_text.setPos(vec2(m_borderSize.x(), m_size.y() - m_borderSize.y())); m_text.setPos(vec2(m_borderSize.x(), m_size.y() - m_borderSize.y()));
m_text.print(textToDisplay); m_text.print(textToDisplay);

4
tools/drainEqualizerProfiling/appl/widget/DisplayFrequency.hpp
View File

@ -25,12 +25,12 @@ namespace appl {
//! @brief destructor //! @brief destructor
virtual ~DisplayFrequency(); virtual ~DisplayFrequency();
private: private:
std::vector<std::vector<std::pair<float,float> > > m_data; //!< data that might be displayed etk::Vector<etk::Vector<etk::Pair<float,float> > > m_data; //!< data that might be displayed
public: public:
void clear() { void clear() {
m_data.clear(); m_data.clear();
} }
void setValue(const std::vector<std::pair<float,float> >& _data); void setValue(const etk::Vector<etk::Pair<float,float> >& _data);
private: private:
float m_gainMin; //!< display minimum gain value float m_gainMin; //!< display minimum gain value
float m_gainMax; //!< display maximum gain value float m_gainMax; //!< display maximum gain value