musicdsp/audio-algo-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:07:34 +02:00
parent 0e031fc91d
commit 8d75111d97
5 changed files with 42 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
audio/algo/drain/BiQuad.hpp
View File

@ -182,13 +182,13 @@ namespace audio {
/**
* @brief Get direct Coefficients
*/
std::vector<TYPE> getCoef() {
std::vector<TYPE> out;
out.push_back(m_a[0]);
out.push_back(m_a[1]);
out.push_back(m_a[2]);
out.push_back(m_b[0]);
out.push_back(m_b[1]);
etk::Vector<TYPE> getCoef() {
etk::Vector<TYPE> out;
out.pushBack(m_a[0]);
out.pushBack(m_a[1]);
out.pushBack(m_a[2]);
out.pushBack(m_b[0]);
out.pushBack(m_b[1]);
return out;
}
/**
@ -249,8 +249,8 @@ namespace audio {
* @param[in] _sampleRate input qample rate
* @retrun list of frequency/power in dB
*/
std::vector<std::pair<float,float> > calculateTheory(double _sampleRate){
std::vector<std::pair<float,float> > out;
etk::Vector<etk::Pair<float,float> > calculateTheory(double _sampleRate){
etk::Vector<etk::Pair<float,float> > out;
double norm;
bool buildLinear = true;
size_t len = 512;
@ -276,7 +276,7 @@ namespace audio {
y = -200.0;
}
//APPL_DEBUG("theory = " << freq << " power=" << y);
out.push_back(std::make_pair<float,float>(freq, y));
out.pushBack(etk::makePair<float,float>(freq, y));
}
return out;
}

4
audio/algo/drain/BiQuadType.cpp
View File

@ -22,10 +22,10 @@ static int32_t listValuesSize = sizeof(listValues)/sizeof(char*);
namespace etk {
template<> std::string to_string<enum audio::algo::drain::biQuadType>(const enum audio::algo::drain::biQuadType& _variable) {
template<> etk::String toString<enum audio::algo::drain::biQuadType>(const enum audio::algo::drain::biQuadType& _variable) {
return listValues[_variable];
}
template <> bool from_string<enum audio::algo::drain::biQuadType>(enum audio::algo::drain::biQuadType& _variableRet, const std::string& _value) {
template <> bool from_string<enum audio::algo::drain::biQuadType>(enum audio::algo::drain::biQuadType& _variableRet, const etk::String& _value) {
for (int32_t iii=0; iii<listValuesSize; ++iii) {
if (_value == listValues[iii]) {
_variableRet = static_cast<enum audio::algo::drain::biQuadType>(iii);

32
audio/algo/drain/Equalizer.cpp
View File

@ -74,11 +74,11 @@ namespace audio {
virtual bool addBiquad(int32_t _idChannel, audio::algo::drain::biQuadType _type, double _frequencyCut, double _qualityFactor, double _gain) = 0;
public:
// for debug & tools only
virtual std::vector<std::pair<float,float> > calculateTheory() = 0;
virtual etk::Vector<etk::Pair<float,float> > calculateTheory() = 0;
};
template<typename TYPE> class EqualizerPrivateType : public audio::algo::drain::EqualizerPrivate {
protected:
std::vector<std::vector<audio::algo::drain::BiQuad<TYPE> > > m_biquads;
etk::Vector<etk::Vector<audio::algo::drain::BiQuad<TYPE> > > m_biquads;
public:
/**
* @brief Constructor
@ -122,7 +122,7 @@ namespace audio {
bq.setBiquadCoef(_a0, _a1, _a2, _b0, _b1);
// add this bequad for every Channel:
for (size_t iii=0; iii<m_biquads.size(); ++iii) {
m_biquads[iii].push_back(bq);
m_biquads[iii].pushBack(bq);
}
return true;
}
@ -131,7 +131,7 @@ namespace audio {
bq.setBiquad(_type, _frequencyCut, _qualityFactor, _gain, m_sampleRate);
// add this bequad for every Channel:
for (size_t iii=0; iii<m_biquads.size(); ++iii) {
m_biquads[iii].push_back(bq);
m_biquads[iii].pushBack(bq);
}
return true;
}
@ -139,7 +139,7 @@ namespace audio {
audio::algo::drain::BiQuad<TYPE> bq;
bq.setBiquadCoef(_a0, _a1, _a2, _b0, _b1);
if (_idChannel<m_biquads.size()) {
m_biquads[_idChannel].push_back(bq);
m_biquads[_idChannel].pushBack(bq);
}
return true;
}
@ -147,17 +147,17 @@ namespace audio {
audio::algo::drain::BiQuad<TYPE> bq;
bq.setBiquad(_type, _frequencyCut, _qualityFactor, _gain, m_sampleRate);
if (_idChannel<m_biquads.size()) {
m_biquads[_idChannel].push_back(bq);
m_biquads[_idChannel].pushBack(bq);
}
return true;
}
virtual std::vector<std::pair<float,float> > calculateTheory() {
std::vector<std::pair<float,float> > out;
virtual etk::Vector<etk::Pair<float,float> > calculateTheory() {
etk::Vector<etk::Pair<float,float> > out;
for (size_t iii=0; iii<m_biquads[0].size(); ++iii) {
if (iii == 0) {
out = m_biquads[0][iii].calculateTheory(m_sampleRate);
} else {
std::vector<std::pair<float,float> > tmp = m_biquads[0][iii].calculateTheory(m_sampleRate);
etk::Vector<etk::Pair<float,float> > tmp = m_biquads[0][iii].calculateTheory(m_sampleRate);
for (size_t jjj=0; jjj< out.size(); ++jjj) {
out[jjj].second += tmp[jjj].second;
}
@ -293,15 +293,15 @@ void audio::algo::drain::Equalizer::reset() {
m_private->reset();
}
std::vector<enum audio::format> audio::algo::drain::Equalizer::getSupportedFormat() {
std::vector<enum audio::format> out = audio::algo::drain::Equalizer::getNativeSupportedFormat();
etk::Vector<enum audio::format> audio::algo::drain::Equalizer::getSupportedFormat() {
etk::Vector<enum audio::format> out = audio::algo::drain::Equalizer::getNativeSupportedFormat();
return out;
}
std::vector<enum audio::format> audio::algo::drain::Equalizer::getNativeSupportedFormat() {
std::vector<enum audio::format> out;
out.push_back(audio::format_float);
etk::Vector<enum audio::format> audio::algo::drain::Equalizer::getNativeSupportedFormat() {
etk::Vector<enum audio::format> out;
out.pushBack(audio::format_float);
return out;
}
@ -343,10 +343,10 @@ bool audio::algo::drain::Equalizer::addBiquad(int32_t _idChannel, audio::algo::d
return m_private->addBiquad(_idChannel, _type, _frequencyCut, _qualityFactor, _gain);
}
std::vector<std::pair<float,float> > audio::algo::drain::Equalizer::calculateTheory() {
etk::Vector<etk::Pair<float,float> > audio::algo::drain::Equalizer::calculateTheory() {
if (m_private == nullptr) {
AA_DRAIN_ERROR("Equalizer does not init ...");
return std::vector<std::pair<float,float> >();
return etk::Vector<etk::Pair<float,float> >();
}
return m_private->calculateTheory();
}

8
audio/algo/drain/Equalizer.hpp
View File

@ -7,7 +7,7 @@
#include <etk/types.hpp>
#include <ememory/memory.hpp>
#include <vector>
#include <etk/Vector.hpp>
#include <audio/format.hpp>
#include <audio/algo/drain/BiQuadType.hpp>
@ -41,12 +41,12 @@ namespace audio {
* @brief Get list of format suported in input.
* @return list of supported format
*/
virtual std::vector<enum audio::format> getSupportedFormat();
virtual etk::Vector<enum audio::format> getSupportedFormat();
/**
* @brief Get list of algorithm format suported. No format convertion.
* @return list of supported format
*/
virtual std::vector<enum audio::format> getNativeSupportedFormat();
virtual etk::Vector<enum audio::format> getNativeSupportedFormat();
/**
* @brief Main input algo process.
* @param[in,out] _output Output data.
@ -72,7 +72,7 @@ namespace audio {
bool addBiquad(int32_t _idChannel, audio::algo::drain::biQuadType _type, double _frequencyCut, double _qualityFactor, double _gain);
public:
// for debug & tools only
std::vector<std::pair<float,float> > calculateTheory();
etk::Vector<etk::Pair<float,float> > calculateTheory();
protected:
ememory::SharedPtr<EqualizerPrivate> m_private; //!< private data (abstract the type of the data flow).
};

20
test/main.cpp
View File

@ -35,8 +35,8 @@ class Performance {
void toc() {
m_timeStop = std::chrono::steady_clock::now();
std::chrono::nanoseconds time = m_timeStop - m_timeStart;
m_minProcessing = std::min(m_minProcessing, time);
m_maxProcessing = std::max(m_maxProcessing, time);
m_minProcessing = etk::min(m_minProcessing, time);
m_maxProcessing = etk::max(m_maxProcessing, time);
m_totalTimeProcessing += time;
m_totalIteration++;
@ -58,9 +58,9 @@ class Performance {
};
float performanceEqualizerType(audio::format _type) {
std::vector<float> input;
etk::Vector<float> input;
input.resize(1024, 0);
std::vector<float> output;
etk::Vector<float> output;
output.resize(input.size()*10, 0);
double sampleRate = 48000;
{
@ -116,17 +116,17 @@ void performanceEqualizer() {
int main(int _argc, const char** _argv) {
// the only one init for etk:
etk::init(_argc, _argv);
std::string inputName = "";
std::string outputName = "output.raw";
etk::String inputName = "";
etk::String outputName = "output.raw";
bool performance = false;
bool perf = false;
int64_t sampleRateIn = 48000;
int64_t sampleRateOut = 48000;
int32_t nbChan = 1;
int32_t quality = 4;
std::string test = "";
etk::String test = "";
for (int32_t iii=0; iii<_argc ; ++iii) {
std::string data = _argv[iii];
etk::String data = _argv[iii];
if (etk::start_with(data,"--in=")) {
inputName = &data[5];
} else if (etk::start_with(data,"--out=")) {
@ -178,10 +178,10 @@ int main(int _argc, const char** _argv) {
exit(-1);
}
TEST_INFO("Read input:");
std::vector<int16_t> inputData = etk::FSNodeReadAllDataType<int16_t>(inputName);
etk::Vector<int16_t> inputData = etk::FSNodeReadAllDataType<int16_t>(inputName);
TEST_INFO(" " << inputData.size() << " samples");
// resize output :
std::vector<int16_t> output;
etk::Vector<int16_t> output;
output.resize(inputData.size()*sampleRateOut/sampleRateIn+5000, 0);
// process in chunk of 256 samples
int32_t blockSize = 256*nbChan;