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

[DEV] update gitignore & chaneg log base

Browse Source
This commit is contained in:
Edouard DUPIN 2015-02-05 21:33:12 +01:00
parent ff6c33d566
commit 4fe4ac40bf
11 changed files with 146 additions and 146 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
drain/Algo.cpp
View File

@ -16,7 +16,7 @@ drain::Algo::Algo() :
m_outputData(), m_outputData(),
m_formatSize(0), m_formatSize(0),
m_needProcess(false) { m_needProcess(false) {
AIRTALGO_VERBOSE("CREATE ALGO"); DRAIN_VERBOSE("CREATE ALGO");
} }
void drain::Algo::init() { void drain::Algo::init() {
@ -57,7 +57,7 @@ void drain::Algo::configurationChange() {
m_formatSize = sizeof(double); m_formatSize = sizeof(double);
break; break;
case audio::format_unknow: case audio::format_unknow:
AIRTALGO_ERROR("format not configured..."); DRAIN_ERROR("format not configured...");
m_formatSize = 8; m_formatSize = 8;
break; break;
} }

4
drain/AutoLogInOut.cpp
View File

@ -9,9 +9,9 @@
drain::AutoLogInOut::AutoLogInOut(const std::string& _value) : drain::AutoLogInOut::AutoLogInOut(const std::string& _value) :
m_value(_value) { m_value(_value) {
AIRTALGO_VERBOSE(" '" << m_value << "' [START]"); DRAIN_VERBOSE(" '" << m_value << "' [START]");
} }
drain::AutoLogInOut::~AutoLogInOut() { drain::AutoLogInOut::~AutoLogInOut() {
AIRTALGO_VERBOSE(" '" << m_value << "' [STOP]"); DRAIN_VERBOSE(" '" << m_value << "' [STOP]");
} }

20
drain/ChannelReorder.cpp
View File

@ -33,17 +33,17 @@ void drain::ChannelReorder::configurationChange() {
drain::AutoLogInOut("ChannelReorder (config)"); drain::AutoLogInOut("ChannelReorder (config)");
drain::Algo::configurationChange(); drain::Algo::configurationChange();
if (m_input.getFormat() != m_output.getFormat()) { if (m_input.getFormat() != m_output.getFormat()) {
AIRTALGO_ERROR("can not support Format Change ..."); DRAIN_ERROR("can not support Format Change ...");
m_needProcess = false; m_needProcess = false;
} }
if (m_input.getFrequency() != m_output.getFrequency()) { if (m_input.getFrequency() != m_output.getFrequency()) {
AIRTALGO_ERROR("can not support frequency Change ..."); DRAIN_ERROR("can not support frequency Change ...");
m_needProcess = false; m_needProcess = false;
} }
if (m_input.getMap() == m_output.getMap()) { if (m_input.getMap() == m_output.getMap()) {
// nothing to process... // nothing to process...
m_needProcess = false; m_needProcess = false;
AIRTALGO_INFO(" no need to convert ... " << m_input.getMap() << " ==> " << m_output.getMap()); DRAIN_INFO(" no need to convert ... " << m_input.getMap() << " ==> " << m_output.getMap());
return; return;
} }
} }
@ -64,7 +64,7 @@ bool drain::ChannelReorder::process(std::chrono::system_clock::time_point& _time
if (_input == nullptr) { if (_input == nullptr) {
_output = &(m_outputData[0]); _output = &(m_outputData[0]);
_outputNbChunk = 0; _outputNbChunk = 0;
AIRTALGO_ERROR("null pointer input ... "); DRAIN_ERROR("null pointer input ... ");
return false; return false;
} }
m_outputData.resize(_outputNbChunk*m_output.getMap().size()*m_formatSize); m_outputData.resize(_outputNbChunk*m_output.getMap().size()*m_formatSize);
@ -73,7 +73,7 @@ bool drain::ChannelReorder::process(std::chrono::system_clock::time_point& _time
switch (m_output.getFormat()) { switch (m_output.getFormat()) {
case audio::format_int8: case audio::format_int8:
{ {
AIRTALGO_VERBOSE("convert " << m_input.getMap() << " ==> " << m_output.getMap() << " format=" << int32_t(m_formatSize)); DRAIN_VERBOSE("convert " << m_input.getMap() << " ==> " << m_output.getMap() << " format=" << int32_t(m_formatSize));
int8_t* in = static_cast<int8_t*>(_input); int8_t* in = static_cast<int8_t*>(_input);
int8_t* out = static_cast<int8_t*>(_output); int8_t* out = static_cast<int8_t*>(_output);
for (size_t kkk=0; kkk<m_output.getMap().size(); ++kkk) { for (size_t kkk=0; kkk<m_output.getMap().size(); ++kkk) {
@ -89,7 +89,7 @@ bool drain::ChannelReorder::process(std::chrono::system_clock::time_point& _time
} }
} }
} }
AIRTALGO_VERBOSE(" " << convertId << " ==> " << kkk); DRAIN_VERBOSE(" " << convertId << " ==> " << kkk);
if (convertId == -1) { if (convertId == -1) {
for (size_t iii=0; iii<_outputNbChunk; ++iii) { for (size_t iii=0; iii<_outputNbChunk; ++iii) {
out[iii*m_output.getMap().size()+kkk] = 0; out[iii*m_output.getMap().size()+kkk] = 0;
@ -105,7 +105,7 @@ bool drain::ChannelReorder::process(std::chrono::system_clock::time_point& _time
default: default:
case audio::format_int16: case audio::format_int16:
{ {
AIRTALGO_VERBOSE("convert " << m_input.getMap() << " ==> " << m_output.getMap() << " format=" << int32_t(m_formatSize)); DRAIN_VERBOSE("convert " << m_input.getMap() << " ==> " << m_output.getMap() << " format=" << int32_t(m_formatSize));
int16_t* in = static_cast<int16_t*>(_input); int16_t* in = static_cast<int16_t*>(_input);
int16_t* out = static_cast<int16_t*>(_output); int16_t* out = static_cast<int16_t*>(_output);
for (size_t kkk=0; kkk<m_output.getMap().size(); ++kkk) { for (size_t kkk=0; kkk<m_output.getMap().size(); ++kkk) {
@ -121,7 +121,7 @@ bool drain::ChannelReorder::process(std::chrono::system_clock::time_point& _time
} }
} }
} }
AIRTALGO_VERBOSE(" " << convertId << " ==> " << kkk); DRAIN_VERBOSE(" " << convertId << " ==> " << kkk);
if (convertId == -1) { if (convertId == -1) {
for (size_t iii=0; iii<_outputNbChunk; ++iii) { for (size_t iii=0; iii<_outputNbChunk; ++iii) {
out[iii*m_output.getMap().size()+kkk] = 0; out[iii*m_output.getMap().size()+kkk] = 0;
@ -139,7 +139,7 @@ bool drain::ChannelReorder::process(std::chrono::system_clock::time_point& _time
case audio::format_int32: case audio::format_int32:
case audio::format_float: case audio::format_float:
{ {
AIRTALGO_VERBOSE("convert (2) " << m_input.getMap() << " ==> " << m_output.getMap()); DRAIN_VERBOSE("convert (2) " << m_input.getMap() << " ==> " << m_output.getMap());
uint32_t* in = static_cast<uint32_t*>(_input); uint32_t* in = static_cast<uint32_t*>(_input);
uint32_t* out = static_cast<uint32_t*>(_output); uint32_t* out = static_cast<uint32_t*>(_output);
for (size_t kkk=0; kkk<m_output.getMap().size(); ++kkk) { for (size_t kkk=0; kkk<m_output.getMap().size(); ++kkk) {
@ -169,7 +169,7 @@ bool drain::ChannelReorder::process(std::chrono::system_clock::time_point& _time
break; break;
case audio::format_double: case audio::format_double:
{ {
AIRTALGO_VERBOSE("convert (2) " << m_input.getMap() << " ==> " << m_output.getMap()); DRAIN_VERBOSE("convert (2) " << m_input.getMap() << " ==> " << m_output.getMap());
uint64_t* in = static_cast<uint64_t*>(_input); uint64_t* in = static_cast<uint64_t*>(_input);
uint64_t* out = static_cast<uint64_t*>(_output); uint64_t* out = static_cast<uint64_t*>(_output);
for (size_t kkk=0; kkk<m_output.getMap().size(); ++kkk) { for (size_t kkk=0; kkk<m_output.getMap().size(); ++kkk) {

8
drain/EndPointCallback.cpp
View File

@ -41,7 +41,7 @@ std::shared_ptr<drain::EndPointCallback> drain::EndPointCallback::create(haveNew
void drain::EndPointCallback::configurationChange() { void drain::EndPointCallback::configurationChange() {
drain::EndPoint::configurationChange(); drain::EndPoint::configurationChange();
AIRTALGO_INFO("update : format=" << m_output.getFormat() << " map=" << m_input.getMap() << " freq=" << m_input.getFrequency() << " size=" << int32_t(m_formatSize)); DRAIN_INFO("update : format=" << m_output.getFormat() << " map=" << m_input.getMap() << " freq=" << m_input.getFrequency() << " size=" << int32_t(m_formatSize));
m_needProcess = true; m_needProcess = true;
} }
@ -56,14 +56,14 @@ bool drain::EndPointCallback::process(std::chrono::system_clock::time_point& _ti
// update buffer size ... // update buffer size ...
m_outputData.resize(_inputNbChunk*m_output.getMap().size()*m_formatSize); m_outputData.resize(_inputNbChunk*m_output.getMap().size()*m_formatSize);
// call user // call user
AIRTALGO_VERBOSE("call user get " << _inputNbChunk << "*" << m_output.getMap().size() << " map=" << m_output.getMap() << " datasize=" << int32_t(m_formatSize)); DRAIN_VERBOSE("call user get " << _inputNbChunk << "*" << m_output.getMap().size() << " map=" << m_output.getMap() << " datasize=" << int32_t(m_formatSize));
m_outputFunction(_time, m_outputFunction(_time,
_inputNbChunk, _inputNbChunk,
m_output.getMap(), m_output.getMap(),
&m_outputData[0], &m_outputData[0],
m_output.getFormat()); m_output.getFormat());
if (m_outputData.size() != _inputNbChunk*m_output.getMap().size()*m_formatSize) { if (m_outputData.size() != _inputNbChunk*m_output.getMap().size()*m_formatSize) {
AIRTALGO_ERROR(" can not get enough data from user ... " << m_outputData.size() << " != " << _inputNbChunk*m_output.getMap().size()); DRAIN_ERROR(" can not get enough data from user ... " << m_outputData.size() << " != " << _inputNbChunk*m_output.getMap().size());
return false; return false;
} }
_output = &m_outputData[0]; _output = &m_outputData[0];
@ -72,7 +72,7 @@ bool drain::EndPointCallback::process(std::chrono::system_clock::time_point& _ti
} }
if (m_inputFunction != nullptr) { if (m_inputFunction != nullptr) {
// Call user ... // Call user ...
AIRTALGO_VERBOSE("call user set " << _inputNbChunk << "*" << m_input.getMap().size()); DRAIN_VERBOSE("call user set " << _inputNbChunk << "*" << m_input.getMap().size());
m_inputFunction(_time, m_inputFunction(_time,
_inputNbChunk, _inputNbChunk,
m_input.getMap(), m_input.getMap(),

14
drain/EndPointWrite.cpp
View File

@ -38,14 +38,14 @@ bool drain::EndPointWrite::process(std::chrono::system_clock::time_point& _time,
void*& _output, void*& _output,
size_t& _outputNbChunk){ size_t& _outputNbChunk){
drain::AutoLogInOut tmpLog("EndPointWrite"); drain::AutoLogInOut tmpLog("EndPointWrite");
//AIRTALGO_INFO(" nb Sample in buffer : " << m_tmpData.size()); //DRAIN_INFO(" nb Sample in buffer : " << m_tmpData.size());
if (m_function != nullptr) { if (m_function != nullptr) {
if (m_tmpData.size() <= 20000) { if (m_tmpData.size() <= 20000) {
m_function(_time, _inputNbChunk, m_output.getMap(), m_output.getFormat()); m_function(_time, _inputNbChunk, m_output.getMap(), m_output.getFormat());
} }
} }
// resize output buffer: // resize output buffer:
//AIRTALGO_INFO(" resize : " << (int32_t)m_formatSize << "*" << (int32_t)_inputNbChunk << "*" << (int32_t)m_outputMap.size()); //DRAIN_INFO(" resize : " << (int32_t)m_formatSize << "*" << (int32_t)_inputNbChunk << "*" << (int32_t)m_outputMap.size());
m_outputData.resize(m_formatSize*_inputNbChunk*m_output.getMap().size(), 0); m_outputData.resize(m_formatSize*_inputNbChunk*m_output.getMap().size(), 0);
// set output pointer: // set output pointer:
_outputNbChunk = m_outputData.size()/(m_formatSize*m_output.getMap().size()); _outputNbChunk = m_outputData.size()/(m_formatSize*m_output.getMap().size());
@ -53,26 +53,26 @@ bool drain::EndPointWrite::process(std::chrono::system_clock::time_point& _time,
std::unique_lock<std::mutex> lock(m_mutex); std::unique_lock<std::mutex> lock(m_mutex);
// check if data in the tmpBuffer // check if data in the tmpBuffer
if (m_tmpData.size() == 0) { if (m_tmpData.size() == 0) {
AIRTALGO_WARNING("No data in the user buffer (write null data ... " << _outputNbChunk << " chunks)"); DRAIN_WARNING("No data in the user buffer (write null data ... " << _outputNbChunk << " chunks)");
// just send no data ... // just send no data ...
return true; return true;
} }
AIRTALGO_INFO("Write " << _outputNbChunk << " chunks"); DRAIN_INFO("Write " << _outputNbChunk << " chunks");
// check if we have enought data: // check if we have enought data:
int32_t nbChunkToCopy = std::min(_inputNbChunk, m_tmpData.size()/(m_output.getMap().size()*m_formatSize)); int32_t nbChunkToCopy = std::min(_inputNbChunk, m_tmpData.size()/(m_output.getMap().size()*m_formatSize));
AIRTALGO_INFO(" " << nbChunkToCopy << " chunks ==> " << nbChunkToCopy*m_output.getMap().size()*m_formatSize << " Byte sizeBuffer=" << m_tmpData.size()); DRAIN_INFO(" " << nbChunkToCopy << " chunks ==> " << nbChunkToCopy*m_output.getMap().size()*m_formatSize << " Byte sizeBuffer=" << m_tmpData.size());
// copy data to the output: // copy data to the output:
memcpy(_output, &m_tmpData[0], nbChunkToCopy*m_output.getMap().size()*m_formatSize); memcpy(_output, &m_tmpData[0], nbChunkToCopy*m_output.getMap().size()*m_formatSize);
// remove old data: // remove old data:
m_tmpData.erase(m_tmpData.begin(), m_tmpData.begin() + nbChunkToCopy*m_output.getMap().size()*m_formatSize); m_tmpData.erase(m_tmpData.begin(), m_tmpData.begin() + nbChunkToCopy*m_output.getMap().size()*m_formatSize);
//AIRTALGO_INFO(" nb Sample in buffer : " << m_tmpData.size()); //DRAIN_INFO(" nb Sample in buffer : " << m_tmpData.size());
return true; return true;
} }
void drain::EndPointWrite::write(const void* _value, size_t _nbChunk) { void drain::EndPointWrite::write(const void* _value, size_t _nbChunk) {
std::unique_lock<std::mutex> lock(m_mutex); std::unique_lock<std::mutex> lock(m_mutex);
AIRTALGO_INFO("[ASYNC] Write data : " << _nbChunk << " chunks" DRAIN_INFO("[ASYNC] Write data : " << _nbChunk << " chunks"
<< " ==> " << _nbChunk*m_output.getMap().size() << " samples" << " ==> " << _nbChunk*m_output.getMap().size() << " samples"
<< " formatSize=" << int32_t(m_formatSize) << " formatSize=" << int32_t(m_formatSize)
<< " bufferSize=" << m_tmpData.size()); << " bufferSize=" << m_tmpData.size());

42
drain/FormatUpdate.cpp
View File

@ -103,7 +103,7 @@ static void convert__float__to__int16(void* _input, void* _output, size_t _nbSam
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 = std::min(std::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);
//AIRTALGO_DEBUG(iii << " in=" << in[iii] << " out=" << out[iii]); //DRAIN_DEBUG(iii << " in=" << in[iii] << " out=" << out[iii]);
} }
} }
static void convert__float__to__int16_on_int32(void* _input, void* _output, size_t _nbSample) { static void convert__float__to__int16_on_int32(void* _input, void* _output, size_t _nbSample) {
@ -145,11 +145,11 @@ std::shared_ptr<drain::FormatUpdate> drain::FormatUpdate::create() {
void drain::FormatUpdate::configurationChange() { void drain::FormatUpdate::configurationChange() {
drain::Algo::configurationChange(); drain::Algo::configurationChange();
if (m_input.getMap() != m_output.getMap()) { if (m_input.getMap() != m_output.getMap()) {
AIRTALGO_ERROR("can not support Map Change ..."); DRAIN_ERROR("can not support Map Change ...");
m_needProcess = false; m_needProcess = false;
} }
if (m_input.getFrequency() != m_output.getFrequency()) { if (m_input.getFrequency() != m_output.getFrequency()) {
AIRTALGO_ERROR("can not support frequency Change ..."); DRAIN_ERROR("can not support frequency Change ...");
m_needProcess = false; m_needProcess = false;
} }
if (m_input.getFormat() == m_output.getFormat()) { if (m_input.getFormat() == m_output.getFormat()) {
@ -163,19 +163,19 @@ void drain::FormatUpdate::configurationChange() {
switch (m_output.getFormat()) { switch (m_output.getFormat()) {
default: default:
case audio::format_int16: case audio::format_int16:
AIRTALGO_ERROR(" Impossible case 1"); DRAIN_ERROR(" Impossible case 1");
break; break;
case audio::format_int16_on_int32: case audio::format_int16_on_int32:
m_functionConvert = &convert__int16__to__int16_on_int32; m_functionConvert = &convert__int16__to__int16_on_int32;
AIRTALGO_DEBUG(" use converter : 'convert__int16__to__int16_on_int32' for " << m_input.getFormat() << " to " << m_output.getFormat()); DRAIN_DEBUG(" use converter : 'convert__int16__to__int16_on_int32' for " << m_input.getFormat() << " to " << m_output.getFormat());
break; break;
case audio::format_int32: case audio::format_int32:
m_functionConvert = &convert__int16__to__int32; m_functionConvert = &convert__int16__to__int32;
AIRTALGO_DEBUG(" use converter : 'convert__int16__to__int32' for " << m_input.getFormat() << " to " << m_output.getFormat()); DRAIN_DEBUG(" use converter : 'convert__int16__to__int32' for " << m_input.getFormat() << " to " << m_output.getFormat());
break; break;
case audio::format_float: case audio::format_float:
m_functionConvert = &convert__int16__to__float; m_functionConvert = &convert__int16__to__float;
AIRTALGO_DEBUG(" use converter : 'convert__int16__to__float' for " << m_input.getFormat() << " to " << m_output.getFormat()); DRAIN_DEBUG(" use converter : 'convert__int16__to__float' for " << m_input.getFormat() << " to " << m_output.getFormat());
break; break;
} }
break; break;
@ -184,18 +184,18 @@ void drain::FormatUpdate::configurationChange() {
default: default:
case audio::format_int16: case audio::format_int16:
m_functionConvert = &convert__int16_on_int32__to__int16; m_functionConvert = &convert__int16_on_int32__to__int16;
AIRTALGO_DEBUG(" use converter : 'convert__int16_on_int32__to__int16' for " << m_input.getFormat() << " to " << m_output.getFormat()); DRAIN_DEBUG(" use converter : 'convert__int16_on_int32__to__int16' for " << m_input.getFormat() << " to " << m_output.getFormat());
break; break;
case audio::format_int16_on_int32: case audio::format_int16_on_int32:
AIRTALGO_ERROR(" Impossible case 2"); DRAIN_ERROR(" Impossible case 2");
break; break;
case audio::format_int32: case audio::format_int32:
m_functionConvert = &convert__int16_on_int32__to__int32; m_functionConvert = &convert__int16_on_int32__to__int32;
AIRTALGO_DEBUG(" use converter : 'convert__int16_on_int32__to__int32' for " << m_input.getFormat() << " to " << m_output.getFormat()); DRAIN_DEBUG(" use converter : 'convert__int16_on_int32__to__int32' for " << m_input.getFormat() << " to " << m_output.getFormat());
break; break;
case audio::format_float: case audio::format_float:
m_functionConvert = &convert__int16_on_int32__to__float; m_functionConvert = &convert__int16_on_int32__to__float;
AIRTALGO_DEBUG(" use converter : 'convert__int16_on_int32__to__float' for " << m_input.getFormat() << " to " << m_output.getFormat()); DRAIN_DEBUG(" use converter : 'convert__int16_on_int32__to__float' for " << m_input.getFormat() << " to " << m_output.getFormat());
break; break;
} }
break; break;
@ -204,18 +204,18 @@ void drain::FormatUpdate::configurationChange() {
default: default:
case audio::format_int16: case audio::format_int16:
m_functionConvert = &convert__int32__to__int16; m_functionConvert = &convert__int32__to__int16;
AIRTALGO_DEBUG(" use converter : 'convert__int32__to__int16' for " << m_input.getFormat() << " to " << m_output.getFormat()); DRAIN_DEBUG(" use converter : 'convert__int32__to__int16' for " << m_input.getFormat() << " to " << m_output.getFormat());
break; break;
case audio::format_int16_on_int32: case audio::format_int16_on_int32:
m_functionConvert = &convert__int32__to__int16_on_int32; m_functionConvert = &convert__int32__to__int16_on_int32;
AIRTALGO_DEBUG(" use converter : 'convert__int32__to__int16_on_int32' for " << m_input.getFormat() << " to " << m_output.getFormat()); DRAIN_DEBUG(" use converter : 'convert__int32__to__int16_on_int32' for " << m_input.getFormat() << " to " << m_output.getFormat());
break; break;
case audio::format_int32: case audio::format_int32:
AIRTALGO_ERROR(" Impossible case 3"); DRAIN_ERROR(" Impossible case 3");
break; break;
case audio::format_float: case audio::format_float:
m_functionConvert = &convert__int32__to__float; m_functionConvert = &convert__int32__to__float;
AIRTALGO_DEBUG(" use converter : 'convert__int32__to__float' for " << m_input.getFormat() << " to " << m_output.getFormat()); DRAIN_DEBUG(" use converter : 'convert__int32__to__float' for " << m_input.getFormat() << " to " << m_output.getFormat());
break; break;
} }
break; break;
@ -224,18 +224,18 @@ void drain::FormatUpdate::configurationChange() {
default: default:
case audio::format_int16: case audio::format_int16:
m_functionConvert = &convert__float__to__int16; m_functionConvert = &convert__float__to__int16;
AIRTALGO_DEBUG(" use converter : 'convert__float__to__int16' for " << m_input.getFormat() << " to " << m_output.getFormat()); DRAIN_DEBUG(" use converter : 'convert__float__to__int16' for " << m_input.getFormat() << " to " << m_output.getFormat());
break; break;
case audio::format_int16_on_int32: case audio::format_int16_on_int32:
m_functionConvert = &convert__float__to__int16_on_int32; m_functionConvert = &convert__float__to__int16_on_int32;
AIRTALGO_DEBUG(" use converter : 'convert__float__to__int16_on_int32' for " << m_input.getFormat() << " to " << m_output.getFormat()); DRAIN_DEBUG(" use converter : 'convert__float__to__int16_on_int32' for " << m_input.getFormat() << " to " << m_output.getFormat());
break; break;
case audio::format_int32: case audio::format_int32:
m_functionConvert = &convert__float__to__int32; m_functionConvert = &convert__float__to__int32;
AIRTALGO_DEBUG(" use converter : 'convert__float__to__int32' for " << m_input.getFormat() << " to " << m_output.getFormat()); DRAIN_DEBUG(" use converter : 'convert__float__to__int32' for " << m_input.getFormat() << " to " << m_output.getFormat());
break; break;
case audio::format_float: case audio::format_float:
AIRTALGO_ERROR(" Impossible case 4"); DRAIN_ERROR(" Impossible case 4");
break; break;
} }
break; break;
@ -258,14 +258,14 @@ bool drain::FormatUpdate::process(std::chrono::system_clock::time_point& _time,
if (_input == nullptr) { if (_input == nullptr) {
_output = &(m_outputData[0]); _output = &(m_outputData[0]);
_outputNbChunk = 0; _outputNbChunk = 0;
AIRTALGO_ERROR("null pointer input ... "); DRAIN_ERROR("null pointer input ... ");
return false; return false;
} }
_outputNbChunk = _inputNbChunk; _outputNbChunk = _inputNbChunk;
m_outputData.resize(_outputNbChunk*m_input.getMap().size()*m_formatSize); m_outputData.resize(_outputNbChunk*m_input.getMap().size()*m_formatSize);
_output = &(m_outputData[0]); _output = &(m_outputData[0]);
if (m_functionConvert == nullptr) { if (m_functionConvert == nullptr) {
AIRTALGO_ERROR("null function ptr"); DRAIN_ERROR("null function ptr");
return false; return false;
} }
m_functionConvert(_input, _output, _outputNbChunk*m_input.getMap().size()); m_functionConvert(_input, _output, _outputNbChunk*m_input.getMap().size());

66
drain/Process.cpp
View File

@ -35,7 +35,7 @@ bool drain::Process::push(std::chrono::system_clock::time_point& _time,
size_t _nbChunk) { size_t _nbChunk) {
void* out = nullptr; void* out = nullptr;
size_t nbChunkOut; size_t nbChunkOut;
AIRTALGO_VERBOSE(" Process push"); DRAIN_VERBOSE(" Process push");
process(_time, _data, _nbChunk, out, nbChunkOut); process(_time, _data, _nbChunk, out, nbChunkOut);
return true; return true;
} }
@ -99,7 +99,7 @@ bool drain::Process::process(std::chrono::system_clock::time_point& _time,
_outNbChunk = _inNbChunk; _outNbChunk = _inNbChunk;
return true; return true;
} }
AIRTALGO_VERBOSE(" process : " << m_listAlgo.size() << " algos nbChunk=" << _outNbChunk); DRAIN_VERBOSE(" process : " << m_listAlgo.size() << " algos nbChunk=" << _outNbChunk);
for (size_t iii=0; iii<m_listAlgo.size(); ++iii) { for (size_t iii=0; iii<m_listAlgo.size(); ++iii) {
//std::cout << " Algo " << iii+1 << "/" << m_listAlgo.size() << std::endl; //std::cout << " Algo " << iii+1 << "/" << m_listAlgo.size() << std::endl;
if (m_listAlgo[iii] != nullptr) { if (m_listAlgo[iii] != nullptr) {
@ -161,27 +161,27 @@ void drain::Process::updateInterAlgo() {
// cahin is already configured // cahin is already configured
return ; return ;
} }
AIRTALGO_INFO(" display properties : nbAlgo : " << m_listAlgo.size()); DRAIN_INFO(" display properties : nbAlgo : " << m_listAlgo.size());
for (auto &it : m_listAlgo) { for (auto &it : m_listAlgo) {
AIRTALGO_INFO(" [" << it->getType() << "] '" << it->getName() << "'"); DRAIN_INFO(" [" << it->getType() << "] '" << it->getName() << "'");
if (it->getInputFormat().getConfigured() == true) { if (it->getInputFormat().getConfigured() == true) {
AIRTALGO_INFO(" Input : " << it->getInputFormat()); DRAIN_INFO(" Input : " << it->getInputFormat());
} else { } else {
AIRTALGO_INFO(" Input : Not configured"); DRAIN_INFO(" Input : Not configured");
AIRTALGO_INFO(" format : " << it->getFormatSupportedInput()); DRAIN_INFO(" format : " << it->getFormatSupportedInput());
AIRTALGO_INFO(" frequency : " << it->getFrequencySupportedInput()); DRAIN_INFO(" frequency : " << it->getFrequencySupportedInput());
AIRTALGO_INFO(" map : " << it->getMapSupportedInput()); DRAIN_INFO(" map : " << it->getMapSupportedInput());
} }
if (it->getOutputFormat().getConfigured() == true) { if (it->getOutputFormat().getConfigured() == true) {
AIRTALGO_INFO(" Output: " << it->getOutputFormat()); DRAIN_INFO(" Output: " << it->getOutputFormat());
} else { } else {
AIRTALGO_INFO(" Output : Not configured"); DRAIN_INFO(" Output : Not configured");
AIRTALGO_INFO(" format : " << it->getFormatSupportedOutput()); DRAIN_INFO(" format : " << it->getFormatSupportedOutput());
AIRTALGO_INFO(" frequency : " << it->getFrequencySupportedOutput()); DRAIN_INFO(" frequency : " << it->getFrequencySupportedOutput());
AIRTALGO_INFO(" map : " << it->getMapSupportedOutput()); DRAIN_INFO(" map : " << it->getMapSupportedOutput());
} }
} }
AIRTALGO_INFO("********* configuration START *************"); DRAIN_INFO("********* configuration START *************");
for (size_t iii=1; iii<m_listAlgo.size(); ++iii) { for (size_t iii=1; iii<m_listAlgo.size(); ++iii) {
if ( m_listAlgo[iii-1]->getOutputFormat().getConfigured() == false if ( m_listAlgo[iii-1]->getOutputFormat().getConfigured() == false
&& m_listAlgo[iii]->getInputFormat().getConfigured() == false) { && m_listAlgo[iii]->getInputFormat().getConfigured() == false) {
@ -201,7 +201,7 @@ void drain::Process::updateInterAlgo() {
if ( freq.size() >= 1 if ( freq.size() >= 1
&& map.size() >= 1 && map.size() >= 1
&& format.size() >= 1) { && format.size() >= 1) {
AIRTALGO_INFO(" find 1 compatibility :{format=" << format << ",frequency=" << freq << ",map=" << map << "}"); DRAIN_INFO(" find 1 compatibility :{format=" << format << ",frequency=" << freq << ",map=" << map << "}");
drain::IOFormatInterface tmp(map[0], format[0], freq[0]); drain::IOFormatInterface tmp(map[0], format[0], freq[0]);
m_listAlgo[iii-1]->setOutputFormat(tmp); m_listAlgo[iii-1]->setOutputFormat(tmp);
m_listAlgo[iii]->setInputFormat(tmp); m_listAlgo[iii]->setInputFormat(tmp);
@ -276,12 +276,12 @@ void drain::Process::updateInterAlgo() {
} }
} }
} }
AIRTALGO_INFO(" union:"); DRAIN_INFO(" union:");
AIRTALGO_INFO(" format : " << format); DRAIN_INFO(" format : " << format);
AIRTALGO_INFO(" frequency : " << freq); DRAIN_INFO(" frequency : " << freq);
AIRTALGO_INFO(" map : " << map); DRAIN_INFO(" map : " << map);
AIRTALGO_INFO(" update: out=" << out); DRAIN_INFO(" update: out=" << out);
AIRTALGO_INFO(" in=" << in); DRAIN_INFO(" in=" << in);
m_listAlgo[iii-1]->setOutputFormat(out); m_listAlgo[iii-1]->setOutputFormat(out);
m_listAlgo[iii]->setInputFormat(in); m_listAlgo[iii]->setInputFormat(in);
// TODO : Add updater with an optimisation of CPU // TODO : Add updater with an optimisation of CPU
@ -297,7 +297,7 @@ void drain::Process::updateInterAlgo() {
out.setFormat(audio::format_int16); out.setFormat(audio::format_int16);
algo->setOutputFormat(out); algo->setOutputFormat(out);
m_listAlgo.insert(m_listAlgo.begin()+iii, algo); m_listAlgo.insert(m_listAlgo.begin()+iii, algo);
AIRTALGO_INFO("convert " << out.getFormat() << " -> " << in.getFormat()); DRAIN_INFO("convert " << out.getFormat() << " -> " << in.getFormat());
iii++; iii++;
} }
// need add a resampler // need add a resampler
@ -307,7 +307,7 @@ void drain::Process::updateInterAlgo() {
out.setFrequency(in.getFrequency()); out.setFrequency(in.getFrequency());
algo->setOutputFormat(out); algo->setOutputFormat(out);
m_listAlgo.insert(m_listAlgo.begin()+iii, algo); m_listAlgo.insert(m_listAlgo.begin()+iii, algo);
AIRTALGO_INFO("convert " << out.getFrequency() << " -> " << in.getFrequency()); DRAIN_INFO("convert " << out.getFrequency() << " -> " << in.getFrequency());
out.setFrequency(in.getFrequency()); out.setFrequency(in.getFrequency());
iii++; iii++;
} }
@ -319,7 +319,7 @@ void drain::Process::updateInterAlgo() {
out.setMap(in.getMap()); out.setMap(in.getMap());
algo->setOutputFormat(out); algo->setOutputFormat(out);
m_listAlgo.insert(m_listAlgo.begin()+iii, algo); m_listAlgo.insert(m_listAlgo.begin()+iii, algo);
AIRTALGO_INFO("convert " << out.getMap() << " -> " << in.getMap()); DRAIN_INFO("convert " << out.getMap() << " -> " << in.getMap());
iii++; iii++;
} }
if (out.getFormat() != in.getFormat()) { if (out.getFormat() != in.getFormat()) {
@ -330,27 +330,27 @@ void drain::Process::updateInterAlgo() {
out.setFormat(in.getFormat()); out.setFormat(in.getFormat());
algo->setOutputFormat(out); algo->setOutputFormat(out);
m_listAlgo.insert(m_listAlgo.begin()+iii, algo); m_listAlgo.insert(m_listAlgo.begin()+iii, algo);
AIRTALGO_INFO("convert " << out.getFormat() << " -> " << in.getFormat()); DRAIN_INFO("convert " << out.getFormat() << " -> " << in.getFormat());
iii++; iii++;
} }
} else if ( m_listAlgo[iii-1]->getOutputFormat().getConfigured() == false } else if ( m_listAlgo[iii-1]->getOutputFormat().getConfigured() == false
|| m_listAlgo[iii]->getInputFormat().getConfigured() == false) { || m_listAlgo[iii]->getInputFormat().getConfigured() == false) {
AIRTALGO_ERROR(" configuration error mode in " << iii-1 << " && " << iii ); DRAIN_ERROR(" configuration error mode in " << iii-1 << " && " << iii );
} }
} }
AIRTALGO_INFO("********* configuration will be done *************"); DRAIN_INFO("********* configuration will be done *************");
for (auto &it : m_listAlgo) { for (auto &it : m_listAlgo) {
AIRTALGO_INFO(" [" << it->getType() << "] '" << it->getName() << "'"); DRAIN_INFO(" [" << it->getType() << "] '" << it->getName() << "'");
if (it->getInputFormat().getConfigured() == true) { if (it->getInputFormat().getConfigured() == true) {
AIRTALGO_INFO(" Input : " << it->getInputFormat()); DRAIN_INFO(" Input : " << it->getInputFormat());
} else { } else {
AIRTALGO_ERROR(" Input : Not configured"); DRAIN_ERROR(" Input : Not configured");
} }
if (it->getOutputFormat().getConfigured() == true) { if (it->getOutputFormat().getConfigured() == true) {
AIRTALGO_INFO(" Output: " << it->getOutputFormat()); DRAIN_INFO(" Output: " << it->getOutputFormat());
} else { } else {
AIRTALGO_ERROR(" Output : Not configured"); DRAIN_ERROR(" Output : Not configured");
} }
} }
m_isConfigured = true; m_isConfigured = true;

30
drain/Resampler.cpp
View File

@ -44,16 +44,16 @@ drain::Resampler::~Resampler() {
void drain::Resampler::configurationChange() { void drain::Resampler::configurationChange() {
drain::Algo::configurationChange(); drain::Algo::configurationChange();
if (m_input.getFormat() != m_output.getFormat()) { if (m_input.getFormat() != m_output.getFormat()) {
AIRTALGO_ERROR("can not support Format Change ..."); DRAIN_ERROR("can not support Format Change ...");
m_needProcess = false; m_needProcess = false;
} }
if (m_input.getFormat() != audio::format_int16) { if (m_input.getFormat() != audio::format_int16) {
AIRTALGO_ERROR("can not support Format other than int16_t ..."); DRAIN_ERROR("can not support Format other than int16_t ...");
m_needProcess = false; m_needProcess = false;
return; return;
} }
if (m_output.getMap() != m_output.getMap()) { if (m_output.getMap() != m_output.getMap()) {
AIRTALGO_ERROR("can not support map Change ..."); DRAIN_ERROR("can not support map Change ...");
m_needProcess = false; m_needProcess = false;
} }
if (m_input.getFrequency() == m_output.getFrequency()) { if (m_input.getFrequency() == m_output.getFrequency()) {
@ -72,7 +72,7 @@ void drain::Resampler::configurationChange() {
m_output.getFrequency(), m_output.getFrequency(),
10, &err); 10, &err);
#else #else
AIRTALGO_WARNING("SPEEX DSP lib not accessible ==> can not resample"); DRAIN_WARNING("SPEEX DSP lib not accessible ==> can not resample");
m_needProcess = false; m_needProcess = false;
#endif #endif
} }
@ -87,7 +87,7 @@ bool drain::Resampler::process(std::chrono::system_clock::time_point& _time,
_outputNbChunk = 2048; _outputNbChunk = 2048;
// chack if we need to process: // chack if we need to process:
if (m_needProcess == false) { if (m_needProcess == false) {
AIRTALGO_WARNING("no process"); DRAIN_WARNING("no process");
_output = _input; _output = _input;
_outputNbChunk = _inputNbChunk; _outputNbChunk = _inputNbChunk;
return true; return true;
@ -95,7 +95,7 @@ bool drain::Resampler::process(std::chrono::system_clock::time_point& _time,
if (_input == nullptr) { if (_input == nullptr) {
_output = &(m_outputData[0]); _output = &(m_outputData[0]);
_outputNbChunk = 0; _outputNbChunk = 0;
AIRTALGO_ERROR("null pointer input ... "); DRAIN_ERROR("null pointer input ... ");
return false; return false;
} }
#ifdef HAVE_SPEEX_DSP_RESAMPLE #ifdef HAVE_SPEEX_DSP_RESAMPLE
@ -103,38 +103,38 @@ bool drain::Resampler::process(std::chrono::system_clock::time_point& _time,
float nbOutputSample = nbInputTime*m_output.getFrequency(); float nbOutputSample = nbInputTime*m_output.getFrequency();
// we add 10% of the buffer size to have all the time enought data in the output to proceed all the input data... // we add 10% of the buffer size to have all the time enought data in the output to proceed all the input data...
_outputNbChunk = size_t(nbOutputSample*1.5f); _outputNbChunk = size_t(nbOutputSample*1.5f);
AIRTALGO_VERBOSE(" freq in=" << m_input.getFrequency() << " out=" << m_output.getFrequency()); DRAIN_VERBOSE(" freq in=" << m_input.getFrequency() << " out=" << m_output.getFrequency());
AIRTALGO_VERBOSE(" Frame duration=" << nbInputTime); DRAIN_VERBOSE(" Frame duration=" << nbInputTime);
AIRTALGO_VERBOSE(" nbInput chunk=" << _inputNbChunk << " nbOutputChunk=" << nbOutputSample); DRAIN_VERBOSE(" nbInput chunk=" << _inputNbChunk << " nbOutputChunk=" << nbOutputSample);
m_outputData.resize(_outputNbChunk*m_output.getMap().size()*m_formatSize*16); m_outputData.resize(_outputNbChunk*m_output.getMap().size()*m_formatSize*16);
_output = &(m_outputData[0]); _output = &(m_outputData[0]);
if (m_speexResampler == nullptr) { if (m_speexResampler == nullptr) {
AIRTALGO_ERROR(" No speex resampler"); DRAIN_ERROR(" No speex resampler");
return false; return false;
} }
uint32_t nbChunkInput = _inputNbChunk; uint32_t nbChunkInput = _inputNbChunk;
uint32_t nbChunkOutput = _outputNbChunk; uint32_t nbChunkOutput = _outputNbChunk;
AIRTALGO_VERBOSE(" >> input=" << nbChunkInput << " output=" << nbChunkOutput); DRAIN_VERBOSE(" >> input=" << nbChunkInput << " output=" << nbChunkOutput);
int ret = speex_resampler_process_interleaved_int(m_speexResampler, int ret = speex_resampler_process_interleaved_int(m_speexResampler,
static_cast<int16_t*>(_input), static_cast<int16_t*>(_input),
&nbChunkInput, &nbChunkInput,
static_cast<int16_t*>(_output), static_cast<int16_t*>(_output),
&nbChunkOutput); &nbChunkOutput);
AIRTALGO_VERBOSE(" << input=" << nbChunkInput << " output=" << nbChunkOutput); DRAIN_VERBOSE(" << input=" << nbChunkInput << " output=" << nbChunkOutput);
// update position of data: // update position of data:
m_positionWrite += nbChunkOutput; m_positionWrite += nbChunkOutput;
// Check all input and output ... // Check all input and output ...
if (nbChunkInput != _inputNbChunk) { if (nbChunkInput != _inputNbChunk) {
AIRTALGO_ERROR(" inputSize (not all read ...) proceed=" << nbChunkInput << " requested=" << _inputNbChunk); DRAIN_ERROR(" inputSize (not all read ...) proceed=" << nbChunkInput << " requested=" << _inputNbChunk);
// TODO : manage this case ... // TODO : manage this case ...
} }
if (nbChunkOutput == _outputNbChunk) { if (nbChunkOutput == _outputNbChunk) {
AIRTALGO_ERROR(" Might have not enought data in output... output size=" << _outputNbChunk); DRAIN_ERROR(" Might have not enought data in output... output size=" << _outputNbChunk);
// TODO : manage this case ... // TODO : manage this case ...
} }
_outputNbChunk = nbChunkOutput; _outputNbChunk = nbChunkOutput;
AIRTALGO_VERBOSE(" process chunk=" << nbChunkInput << " out=" << nbChunkOutput); DRAIN_VERBOSE(" process chunk=" << nbChunkInput << " out=" << nbChunkOutput);
return true; return true;
#else #else
_output = _input; _output = _input;

50
drain/Volume.cpp
View File

@ -57,7 +57,7 @@ static void convert__int16__to__int32(void* _input, void* _output, size_t _nbSam
for (size_t iii=0; iii<_nbSample; ++iii) { for (size_t iii=0; iii<_nbSample; ++iii) {
out[iii] = (int32_t(in[iii]) * int32_t(_volumeCoef)) >> _volumeDecalage; out[iii] = (int32_t(in[iii]) * int32_t(_volumeCoef)) >> _volumeDecalage;
} }
//AIRTALGO_INFO("plop " << in[0] << " >> " << out[0]); //DRAIN_INFO("plop " << in[0] << " >> " << out[0]);
} }
static void convert__int32__to__int16(void* _input, void* _output, size_t _nbSample, int32_t _volumeCoef, int32_t _volumeDecalage, float _volumeAppli) { static void convert__int32__to__int16(void* _input, void* _output, size_t _nbSample, int32_t _volumeCoef, int32_t _volumeDecalage, float _volumeAppli) {
@ -75,7 +75,7 @@ static void convert__int32__to__int32(void* _input, void* _output, size_t _nbSam
for (size_t iii=0; iii<_nbSample; ++iii) { for (size_t iii=0; iii<_nbSample; ++iii) {
out[iii] = int32_t((int64_t(in[iii]) * int64_t(_volumeCoef)) >> _volumeDecalage); out[iii] = int32_t((int64_t(in[iii]) * int64_t(_volumeCoef)) >> _volumeDecalage);
} }
//AIRTALGO_INFO("plop " << in[0] << " >> " << out[0]); //DRAIN_INFO("plop " << in[0] << " >> " << out[0]);
} }
static void convert__float__to__float(void* _input, void* _output, size_t _nbSample, int32_t _volumeCoef, int32_t _volumeDecalage, float _volumeAppli) { static void convert__float__to__float(void* _input, void* _output, size_t _nbSample, int32_t _volumeCoef, int32_t _volumeDecalage, float _volumeAppli) {
@ -95,15 +95,15 @@ void drain::Volume::configurationChange() {
default: default:
case audio::format_int16: case audio::format_int16:
m_functionConvert = &convert__int16__to__int16; m_functionConvert = &convert__int16__to__int16;
AIRTALGO_DEBUG("Use converter : 'convert__int16__to__int16' for " << m_input.getFormat() << " to " << m_output.getFormat()); DRAIN_DEBUG("Use converter : 'convert__int16__to__int16' for " << m_input.getFormat() << " to " << m_output.getFormat());
break; break;
case audio::format_int16_on_int32: case audio::format_int16_on_int32:
case audio::format_int32: case audio::format_int32:
m_functionConvert = &convert__int16__to__int32; m_functionConvert = &convert__int16__to__int32;
AIRTALGO_DEBUG("Use converter : 'convert__int16__to__int32' for " << m_input.getFormat() << " to " << m_output.getFormat()); DRAIN_DEBUG("Use converter : 'convert__int16__to__int32' for " << m_input.getFormat() << " to " << m_output.getFormat());
break; break;
case audio::format_float: case audio::format_float:
AIRTALGO_ERROR("Impossible case 1"); DRAIN_ERROR("Impossible case 1");
break; break;
} }
break; break;
@ -113,15 +113,15 @@ void drain::Volume::configurationChange() {
default: default:
case audio::format_int16: case audio::format_int16:
m_functionConvert = &convert__int32__to__int16; m_functionConvert = &convert__int32__to__int16;
AIRTALGO_DEBUG("Use converter : 'convert__int32__to__int16' for " << m_input.getFormat() << " to " << m_output.getFormat()); DRAIN_DEBUG("Use converter : 'convert__int32__to__int16' for " << m_input.getFormat() << " to " << m_output.getFormat());
break; break;
case audio::format_int16_on_int32: case audio::format_int16_on_int32:
case audio::format_int32: case audio::format_int32:
m_functionConvert = &convert__int32__to__int32; m_functionConvert = &convert__int32__to__int32;
AIRTALGO_DEBUG("Use converter : 'convert__int32__to__int32' for " << m_input.getFormat() << " to " << m_output.getFormat()); DRAIN_DEBUG("Use converter : 'convert__int32__to__int32' for " << m_input.getFormat() << " to " << m_output.getFormat());
break; break;
case audio::format_float: case audio::format_float:
AIRTALGO_ERROR("Impossible case 2"); DRAIN_ERROR("Impossible case 2");
break; break;
} }
break; break;
@ -131,20 +131,20 @@ void drain::Volume::configurationChange() {
case audio::format_int16: case audio::format_int16:
case audio::format_int16_on_int32: case audio::format_int16_on_int32:
case audio::format_int32: case audio::format_int32:
AIRTALGO_ERROR("Impossible case 4"); DRAIN_ERROR("Impossible case 4");
break; break;
case audio::format_float: case audio::format_float:
m_functionConvert = &convert__float__to__float; m_functionConvert = &convert__float__to__float;
AIRTALGO_DEBUG("Use converter : 'convert__float__to__float' for " << m_input.getFormat() << " to " << m_output.getFormat()); DRAIN_DEBUG("Use converter : 'convert__float__to__float' for " << m_input.getFormat() << " to " << m_output.getFormat());
break; break;
} }
break; break;
} }
if (m_input.getMap() != m_output.getMap()) { if (m_input.getMap() != m_output.getMap()) {
AIRTALGO_ERROR("Volume map change is not supported"); DRAIN_ERROR("Volume map change is not supported");
} }
if (m_input.getFrequency() != m_output.getFrequency()) { if (m_input.getFrequency() != m_output.getFrequency()) {
AIRTALGO_ERROR("Volume frequency change is not supported"); DRAIN_ERROR("Volume frequency change is not supported");
} }
// nee to process all time (the format not change (just a simple filter)) // nee to process all time (the format not change (just a simple filter))
m_needProcess = true; m_needProcess = true;
@ -159,9 +159,9 @@ void drain::Volume::volumeChange() {
continue; continue;
} }
volumedB += it->getVolume(); volumedB += it->getVolume();
AIRTALGO_VERBOSE("append volume : '" << it->getName() << " vol=" << it->getVolume() << "dB"); DRAIN_VERBOSE("append volume : '" << it->getName() << " vol=" << it->getVolume() << "dB");
} }
AIRTALGO_DEBUG(" Total volume : " << volumedB << "dB nbVolume=" << m_volumeList.size()); DRAIN_DEBUG(" Total volume : " << volumedB << "dB nbVolume=" << m_volumeList.size());
m_volumeAppli = std::pow(10.0f, volumedB/20.0f); m_volumeAppli = std::pow(10.0f, volumedB/20.0f);
switch (m_input.getFormat()) { switch (m_input.getFormat()) {
default: default:
@ -193,7 +193,7 @@ void drain::Volume::volumeChange() {
m_volumeDecalage = 0; m_volumeDecalage = 0;
break; break;
case audio::format_float: case audio::format_float:
AIRTALGO_ERROR("Impossible case 1"); DRAIN_ERROR("Impossible case 1");
break; break;
} }
break; break;
@ -225,7 +225,7 @@ void drain::Volume::volumeChange() {
m_volumeDecalage = 0; m_volumeDecalage = 0;
break; break;
case audio::format_float: case audio::format_float:
AIRTALGO_ERROR("Impossible case 2"); DRAIN_ERROR("Impossible case 2");
break; break;
} }
break; break;
@ -257,7 +257,7 @@ void drain::Volume::volumeChange() {
m_volumeDecalage = 16; m_volumeDecalage = 16;
break; break;
case audio::format_float: case audio::format_float:
AIRTALGO_ERROR("Impossible case 3"); DRAIN_ERROR("Impossible case 3");
break; break;
} }
break; break;
@ -314,17 +314,17 @@ bool drain::Volume::process(std::chrono::system_clock::time_point& _time,
if (_input == nullptr) { if (_input == nullptr) {
_output = &(m_outputData[0]); _output = &(m_outputData[0]);
_outputNbChunk = 0; _outputNbChunk = 0;
AIRTALGO_ERROR("null pointer input ... "); DRAIN_ERROR("null pointer input ... ");
return false; return false;
} }
_outputNbChunk = _inputNbChunk; _outputNbChunk = _inputNbChunk;
m_outputData.resize(_outputNbChunk*m_input.getMap().size()*m_formatSize); m_outputData.resize(_outputNbChunk*m_input.getMap().size()*m_formatSize);
_output = &(m_outputData[0]); _output = &(m_outputData[0]);
if (m_functionConvert == nullptr) { if (m_functionConvert == nullptr) {
AIRTALGO_ERROR("null function ptr"); DRAIN_ERROR("null function ptr");
return false; return false;
} }
//AIRTALGO_WARNING("Apply volume : " << m_volumedB << "dB " << m_volumeAppli << " ==> x*" << m_volumeCoef << ">>" << m_volumeDecalage << " ex:50*C>>D=" << (50*m_volumeCoef>>m_volumeDecalage) ); //DRAIN_WARNING("Apply volume : " << m_volumedB << "dB " << m_volumeAppli << " ==> x*" << m_volumeCoef << ">>" << m_volumeDecalage << " ex:50*C>>D=" << (50*m_volumeCoef>>m_volumeDecalage) );
m_functionConvert(_input, _output, _outputNbChunk*m_input.getMap().size(), m_volumeCoef, m_volumeDecalage, m_volumeAppli); m_functionConvert(_input, _output, _outputNbChunk*m_input.getMap().size(), m_volumeCoef, m_volumeDecalage, m_volumeAppli);
return true; return true;
} }
@ -363,17 +363,17 @@ bool drain::Volume::setParameter(const std::string& _parameter, const std::strin
} }
if ( value < -300 if ( value < -300
|| value > 300) { || value > 300) {
AIRTALGO_ERROR("Can not set volume ... : '" << _parameter << "' out of range : [-300..300]"); DRAIN_ERROR("Can not set volume ... : '" << _parameter << "' out of range : [-300..300]");
return false; return false;
} }
it->setVolume(value); it->setVolume(value);
AIRTALGO_DEBUG("Set volume : FLOW = " << value << " dB (from:" << _value << ")"); DRAIN_DEBUG("Set volume : FLOW = " << value << " dB (from:" << _value << ")");
volumeChange(); volumeChange();
return true; return true;
} }
} }
} }
AIRTALGO_ERROR("unknow set Parameter : '" << _parameter << "' with Value: '" << _value << "'"); DRAIN_ERROR("unknow set Parameter : '" << _parameter << "' with Value: '" << _value << "'");
return false; return false;
} }
@ -389,7 +389,7 @@ std::string drain::Volume::getParameter(const std::string& _parameter) const {
} }
} }
} }
AIRTALGO_ERROR("unknow get Parameter : '" << _parameter << "'"); DRAIN_ERROR("unknow get Parameter : '" << _parameter << "'");
return "[ERROR]"; return "[ERROR]";
} }
@ -405,7 +405,7 @@ std::string drain::Volume::getParameterProperty(const std::string& _parameter) c
} }
} }
} }
AIRTALGO_ERROR("unknow Parameter property for: '" << _parameter << "'"); DRAIN_ERROR("unknow Parameter property for: '" << _parameter << "'");
return "[ERROR]"; return "[ERROR]";
} }

32
drain/debug.h
View File

@ -4,8 +4,8 @@
* @license APACHE v2.0 (see license file) * @license APACHE v2.0 (see license file)
*/ */
#ifndef __AIRTALGO_DEBUG_H__ #ifndef __DRAIN_DEBUG_H__
#define __AIRTALGO_DEBUG_H__ #define __DRAIN_DEBUG_H__
#include <etk/log.h> #include <etk/log.h>
@ -13,7 +13,7 @@ namespace drain {
int32_t getLogId(); int32_t getLogId();
}; };
// TODO : Review this problem of multiple intanciation of "std::stringbuf sb" // TODO : Review this problem of multiple intanciation of "std::stringbuf sb"
#define AIRTALGO_BASE(info,data) \ #define DRAIN_BASE(info,data) \
do { \ do { \
if (info <= etk::log::getLevel(drain::getLogId())) { \ if (info <= etk::log::getLevel(drain::getLogId())) { \
std::stringbuf sb; \ std::stringbuf sb; \
@ -23,25 +23,25 @@ namespace drain {
} \ } \
} while(0) } while(0)
#define AIRTALGO_CRITICAL(data) AIRTALGO_BASE(1, data) #define DRAIN_CRITICAL(data) DRAIN_BASE(1, data)
#define AIRTALGO_ERROR(data) AIRTALGO_BASE(2, data) #define DRAIN_ERROR(data) DRAIN_BASE(2, data)
#define AIRTALGO_WARNING(data) AIRTALGO_BASE(3, data) #define DRAIN_WARNING(data) DRAIN_BASE(3, data)
#ifdef DEBUG #ifdef DEBUG
#define AIRTALGO_INFO(data) AIRTALGO_BASE(4, data) #define DRAIN_INFO(data) DRAIN_BASE(4, data)
#define AIRTALGO_DEBUG(data) AIRTALGO_BASE(5, data) #define DRAIN_DEBUG(data) DRAIN_BASE(5, data)
#define AIRTALGO_VERBOSE(data) AIRTALGO_BASE(6, data) #define DRAIN_VERBOSE(data) DRAIN_BASE(6, data)
#define AIRTALGO_TODO(data) AIRTALGO_BASE(4, "TODO : " << data) #define DRAIN_TODO(data) DRAIN_BASE(4, "TODO : " << data)
#else #else
#define AIRTALGO_INFO(data) do { } while(false) #define DRAIN_INFO(data) do { } while(false)
#define AIRTALGO_DEBUG(data) do { } while(false) #define DRAIN_DEBUG(data) do { } while(false)
#define AIRTALGO_VERBOSE(data) do { } while(false) #define DRAIN_VERBOSE(data) do { } while(false)
#define AIRTALGO_TODO(data) do { } while(false) #define DRAIN_TODO(data) do { } while(false)
#endif #endif
#define AIRTALGO_ASSERT(cond,data) \ #define DRAIN_ASSERT(cond,data) \
do { \ do { \
if (!(cond)) { \ if (!(cond)) { \
AIRTALGO_CRITICAL(data); \ DRAIN_CRITICAL(data); \
assert(!#cond); \ assert(!#cond); \
} \ } \
} while (0) } while (0)

22
drain/debugRemove.h
View File

@ -6,17 +6,17 @@
* @license BSD 3 clauses (see license file) * @license BSD 3 clauses (see license file)
*/ */
#ifdef __AIRTALGOO_DEBUG_H__ #ifdef __DRAINO_DEBUG_H__
#undef __AIRTALGOO_DEBUG_H__ #undef __DRAINO_DEBUG_H__
#undef AIRTALGO_BASE #undef DRAIN_BASE
#undef AIRTALGO_CRITICAL #undef DRAIN_CRITICAL
#undef AIRTALGO_ERROR #undef DRAIN_ERROR
#undef AIRTALGO_WARNING #undef DRAIN_WARNING
#undef AIRTALGO_INFO #undef DRAIN_INFO
#undef AIRTALGO_DEBUG #undef DRAIN_DEBUG
#undef AIRTALGO_VERBOSE #undef DRAIN_VERBOSE
#undef AIRTALGO_TODO #undef DRAIN_TODO
#undef AIRTALGO_ASSERT #undef DRAIN_ASSERT
#endif #endif