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

Compare commits

base: musicdsp:0.1.0
Branches Tags
musicdsp:main musicdsp:dev musicdsp:gh-pages musicdsp:dev-nao
musicdsp:v1.0.0 musicdsp:0.4.0 musicdsp:0.3.1 musicdsp:0.3.0 musicdsp:0.2.0 musicdsp:0.1.0 musicdsp:0.0.0
...
compare: musicdsp:0.2.0
Branches Tags
musicdsp:dev musicdsp:main musicdsp:gh-pages musicdsp:dev-nao
musicdsp:v1.0.0 musicdsp:0.4.0 musicdsp:0.3.1 musicdsp:0.3.0 musicdsp:0.2.0 musicdsp:0.1.0 musicdsp:0.0.0

18 Commits
0.1.0 ... 0.2.0

Author SHA1 Message Date
Edouard DUPIN
c9bb77e8d6 [DEBUG] correct set titile 2016-03-16 23:57:13 +01:00
Edouard DUPIN
ef0bda6405 [DEV] build again 2016-03-14 21:26:44 +01:00
Edouard DUPIN
e7d5b421c3 [DEV] update of external of elog and ethread 2016-03-08 21:29:34 +01:00
Edouard DUPIN
dd2e5240e3 [DEV] add basic subfolder parser request 2016-02-23 21:56:42 +01:00
Edouard DUPIN
f1643a1231 [DEV] replace 'include guard' with 'pragma once' 2016-02-02 21:18:54 +01:00
Edouard DUPIN
569d59e05a [DEV] update new lutin 0.8.0 2015-10-14 21:21:03 +02:00
Edouard DUPIN
88c8178a72 [DEV] update next lutin version and debug android play audio 2015-09-24 21:44:04 +02:00
Edouard DUPIN
dbd66a0157 [DEV] update Build interface 2015-09-14 21:11:04 +02:00
Edouard DUPIN
5cab7f39eb [CI] update travis with new interface (no sudo) 2015-08-24 23:55:27 +02:00
Edouard DUPIN
9323412a44 [DEV] update test with gale 2015-08-24 22:29:47 +02:00
Edouard DUPIN
58ceff9371 [DEV] start work on File node 2015-07-10 23:10:16 +02:00
Edouard DUPIN
c329af6863 [DEV] Add mute in volume manager 2015-07-02 21:17:24 +02:00
Edouard DUPIN
3ce856c1c6 [DEV] better viewer 2015-07-01 22:00:09 +02:00
Edouard DUPIN
0692b6f8bc [DEV] add basic input viewer widget 2015-06-30 21:29:08 +02:00
Edouard DUPIN
f791cb3613 [DEV] indent correction 2015-06-26 22:20:04 +02:00
Edouard DUPIN
972bbf60bc [CI] remove test (must have hardware) 2015-06-16 22:02:08 +02:00
Edouard DUPIN
2ed71b8c7a [CI] remove pulse from dependency (old) 2015-06-16 21:17:08 +02:00
Edouard DUPIN
10820f0c86 [DOC] Create readme 2015-06-15 22:27:39 +02:00
56 changed files with 1754 additions and 793 deletions
Expand all files Collapse all files

54
.travis.yml
View File

@@ -1,19 +1,42 @@
language: cpp
language:
- cpp
compiler:
- clang
- gcc
sudo: false
os:
- linux
- osx
branches:
only:
- master
- dev
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- g++-4.9
install:
- pip install --user lutin
env:
- CONF=debug BOARD=Linux BUILDER=clang GCOV=
- CONF=release BOARD=Linux BUILDER=clang GCOV=
- CONF=debug BOARD=Linux BUILDER=gcc GCOV=
- CONF=release BOARD=Linux BUILDER=gcc GCOV=
- CONF=debug BOARD=Linux BUILDER=gcc GCOV=--gcov
before_script:
- cd ..
- git clone https://github.com/generic-library/gtest-lutin.git --recurse-submodules
- git clone https://github.com/generic-library/speex-dsp-lutin.git --recurse-submodules
- git clone https://github.com/generic-library/z-lutin.git --recurse-submodules
- git clone https://github.com/generic-library/portaudio-lutin.git --recurse-submodules
- wget http://atria-soft.com/ci/coverage_send.py
- wget http://atria-soft.com/ci/test_send.py
- wget http://atria-soft.com/ci/warning_send.py
- git clone https://github.com/generic-library/gtest-lutin.git --recursive
- git clone https://github.com/generic-library/speex-dsp-lutin.git --recursive
- git clone https://github.com/generic-library/z-lutin.git --recursive
- git clone https://github.com/atria-soft/etk.git
- git clone https://github.com/atria-soft/ejson.git
- git clone https://github.com/musicdsp/audio.git
@@ -22,21 +45,12 @@ before_script:
- git clone https://github.com/musicdsp/audio-orchestra.git
- pwd
- ls -l
- if [ "$CXX" == "clang++" ]; then BUILDER=clang; else BUILDER=gcc; fi
- if [ "$BUILDER" == "gcc" ]; then COMPILATOR_OPTION="--compilator-version=4.9"; else COMPILATOR_OPTION=""; fi
install:
- sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
- sudo apt-get update -qq
- sudo apt-get install -qq g++-4.9
- sudo apt-get install -qq libstdc++-4.9-dev
- sudo rm /usr/bin/gcc /usr/bin/g++
- sudo ln -s /usr/bin/gcc-4.9 /usr/bin/gcc
- sudo ln -s /usr/bin/g++-4.9 /usr/bin/g++
- sudo pip install lutin
script:
- lutin -C -P -c$BUILDER -mdebug -p audio-river-test
- ./out/Linux_x86_64/debug/staging/$BUILDER/audio-river-test/usr/bin/audio-river-test -l6
- lutin -w -j4 -C -P -c $BUILDER $COMPILATOR_OPTION -m $CONF $GCOV -p audio-river-test
# - ./out/Linux_x86_64/$CONF/staging/$BUILDER/audio-river-test/usr/bin/audio-river-test -l6
notifications:
email:

4
README.md Normal file
View File

@@ -0,0 +1,4 @@
# audio-river
(APACHE v2.0) audio: virtualisation of hardware interface
[![Build Status](https://travis-ci.org/musicdsp/audio-river.svg?branch=master)](https://travis-ci.org/musicdsp/audio-river)

130
audio/river/Interface.cpp
View File

@@ -27,8 +27,8 @@ audio::river::Interface::Interface(void) :
bool audio::river::Interface::init(float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std11::shared_ptr<audio::river::io::Node>& _node,
const std11::shared_ptr<const ejson::Object>& _config) {
const std::shared_ptr<audio::river::io::Node>& _node,
const std::shared_ptr<const ejson::Object>& _config) {
std::vector<audio::channel> map(_map);
m_node = _node;
m_config = _config;
@@ -57,10 +57,10 @@ bool audio::river::Interface::init(float _freq,
&& m_mode == audio::river::modeInterface_input) {
m_process.setInputConfig(m_node->getInterfaceFormat());
// Add volume only if the Low level has a volume (otherwise it will be added by the application)
std11::shared_ptr<audio::drain::VolumeElement> tmpVolume = m_node->getVolume();
std::shared_ptr<audio::drain::VolumeElement> tmpVolume = m_node->getVolume();
if (tmpVolume != nullptr) {
// add all time the volume stage :
std11::shared_ptr<audio::drain::Volume> algo = audio::drain::Volume::create();
std::shared_ptr<audio::drain::Volume> algo = audio::drain::Volume::create();
//algo->setInputFormat(m_node->getInterfaceFormat());
algo->setName("volume");
m_process.pushBack(algo);
@@ -72,10 +72,10 @@ bool audio::river::Interface::init(float _freq,
&& m_mode == audio::river::modeInterface_output) {
m_process.setInputConfig(audio::drain::IOFormatInterface(map, _format, _freq));
// Add volume only if the Low level has a volume (otherwise it will be added by the application)
std11::shared_ptr<audio::drain::VolumeElement> tmpVolume = m_node->getVolume();
std::shared_ptr<audio::drain::VolumeElement> tmpVolume = m_node->getVolume();
if (tmpVolume != nullptr) {
// add all time the volume stage :
std11::shared_ptr<audio::drain::Volume> algo = audio::drain::Volume::create();
std::shared_ptr<audio::drain::Volume> algo = audio::drain::Volume::create();
//algo->setOutputFormat(m_node->getInterfaceFormat());
algo->setName("volume");
m_process.pushBack(algo);
@@ -95,19 +95,19 @@ bool audio::river::Interface::init(float _freq,
return true;
}
std11::shared_ptr<audio::river::Interface> audio::river::Interface::create(float _freq,
std::shared_ptr<audio::river::Interface> audio::river::Interface::create(float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std11::shared_ptr<audio::river::io::Node>& _node,
const std11::shared_ptr<const ejson::Object>& _config) {
std11::shared_ptr<audio::river::Interface> out = std11::shared_ptr<audio::river::Interface>(new audio::river::Interface());
const std::shared_ptr<audio::river::io::Node>& _node,
const std::shared_ptr<const ejson::Object>& _config) {
std::shared_ptr<audio::river::Interface> out = std::shared_ptr<audio::river::Interface>(new audio::river::Interface());
out->init(_freq, _map, _format, _node, _config);
return out;
}
audio::river::Interface::~Interface() {
//stop(true, true);
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
//m_node->interfaceRemove(shared_from_this());
}
/*
@@ -116,7 +116,7 @@ bool audio::river::Interface::hasEndPoint() {
}
*/
void audio::river::Interface::setReadwrite() {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
m_process.removeAlgoDynamic();
if (m_process.hasType<audio::drain::EndPoint>() ) {
RIVER_ERROR("Endpoint is already present ==> can not change");
@@ -124,47 +124,47 @@ void audio::river::Interface::setReadwrite() {
}
if (m_node->isInput() == true) {
m_process.removeIfLast<audio::drain::EndPoint>();
std11::shared_ptr<audio::drain::EndPointRead> algo = audio::drain::EndPointRead::create();
std::shared_ptr<audio::drain::EndPointRead> algo = audio::drain::EndPointRead::create();
m_process.pushBack(algo);
} else {
m_process.removeIfFirst<audio::drain::EndPoint>();
std11::shared_ptr<audio::drain::EndPointWrite> algo = audio::drain::EndPointWrite::create();
std::shared_ptr<audio::drain::EndPointWrite> algo = audio::drain::EndPointWrite::create();
m_process.pushFront(algo);
}
}
void audio::river::Interface::setOutputCallback(audio::drain::playbackFunction _function) {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
if (m_mode != audio::river::modeInterface_output) {
RIVER_ERROR("Can not set output endpoint on other than a output IO");
return;
}
m_process.removeAlgoDynamic();
m_process.removeIfFirst<audio::drain::EndPoint>();
std11::shared_ptr<audio::drain::Algo> algo = audio::drain::EndPointCallback::create(_function);
std::shared_ptr<audio::drain::Algo> algo = audio::drain::EndPointCallback::create(_function);
m_process.pushFront(algo);
}
void audio::river::Interface::setInputCallback(audio::drain::recordFunction _function) {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
if (m_mode == audio::river::modeInterface_output) {
RIVER_ERROR("Can not set output endpoint on other than a input or feedback IO");
return;
}
m_process.removeAlgoDynamic();
m_process.removeIfLast<audio::drain::EndPoint>();
std11::shared_ptr<audio::drain::Algo> algo = audio::drain::EndPointCallback::create(_function);
std::shared_ptr<audio::drain::Algo> algo = audio::drain::EndPointCallback::create(_function);
m_process.pushBack(algo);
}
void audio::river::Interface::setWriteCallback(audio::drain::playbackFunctionWrite _function) {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
if (m_mode != audio::river::modeInterface_output) {
RIVER_ERROR("Can not set output endpoint on other than a output IO");
return;
}
m_process.removeAlgoDynamic();
std11::shared_ptr<audio::drain::EndPointWrite> algo = m_process.get<audio::drain::EndPointWrite>(0);
std::shared_ptr<audio::drain::EndPointWrite> algo = m_process.get<audio::drain::EndPointWrite>(0);
if (algo == nullptr) {
return;
}
@@ -172,7 +172,7 @@ void audio::river::Interface::setWriteCallback(audio::drain::playbackFunctionWri
}
void audio::river::Interface::start(const audio::Time& _time) {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
RIVER_DEBUG("start [BEGIN]");
m_process.updateInterAlgo();
m_node->interfaceAdd(shared_from_this());
@@ -180,14 +180,14 @@ void audio::river::Interface::start(const audio::Time& _time) {
}
void audio::river::Interface::stop(bool _fast, bool _abort) {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
RIVER_DEBUG("stop [BEGIN]");
m_node->interfaceRemove(shared_from_this());
RIVER_DEBUG("stop [ END]");
}
void audio::river::Interface::abort() {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
RIVER_DEBUG("abort [BEGIN]");
// TODO :...
RIVER_DEBUG("abort [ END ]");
@@ -201,7 +201,7 @@ bool audio::river::Interface::setParameter(const std::string& _filter, const std
RIVER_ERROR("Interface is not allowed to modify '" << _parameter << "' Volume just allowed to modify 'FLOW' volume");
return false;
}
std11::shared_ptr<audio::drain::Algo> algo = m_process.get<audio::drain::Algo>(_filter);
std::shared_ptr<audio::drain::Algo> algo = m_process.get<audio::drain::Algo>(_filter);
if (algo == nullptr) {
RIVER_ERROR("setParameter(" << _filter << ") ==> no filter named like this ...");
return false;
@@ -213,7 +213,7 @@ bool audio::river::Interface::setParameter(const std::string& _filter, const std
std::string audio::river::Interface::getParameter(const std::string& _filter, const std::string& _parameter) const {
RIVER_DEBUG("getParameter [BEGIN] : '" << _filter << "':'" << _parameter << "'");
std::string out;
std11::shared_ptr<const audio::drain::Algo> algo = m_process.get<const audio::drain::Algo>(_filter);
std::shared_ptr<const audio::drain::Algo> algo = m_process.get<const audio::drain::Algo>(_filter);
if (algo == nullptr) {
RIVER_ERROR("setParameter(" << _filter << ") ==> no filter named like this ...");
return "[ERROR]";
@@ -225,7 +225,7 @@ std::string audio::river::Interface::getParameter(const std::string& _filter, co
std::string audio::river::Interface::getParameterProperty(const std::string& _filter, const std::string& _parameter) const {
RIVER_DEBUG("getParameterProperty [BEGIN] : '" << _filter << "':'" << _parameter << "'");
std::string out;
std11::shared_ptr<const audio::drain::Algo> algo = m_process.get<const audio::drain::Algo>(_filter);
std::shared_ptr<const audio::drain::Algo> algo = m_process.get<const audio::drain::Algo>(_filter);
if (algo == nullptr) {
RIVER_ERROR("setParameter(" << _filter << ") ==> no filter named like this ...");
return "[ERROR]";
@@ -236,9 +236,9 @@ std::string audio::river::Interface::getParameterProperty(const std::string& _fi
}
void audio::river::Interface::write(const void* _value, size_t _nbChunk) {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
m_process.updateInterAlgo();
std11::shared_ptr<audio::drain::EndPointWrite> algo = m_process.get<audio::drain::EndPointWrite>(0);
std::shared_ptr<audio::drain::EndPointWrite> algo = m_process.get<audio::drain::EndPointWrite>(0);
if (algo == nullptr) {
return;
}
@@ -271,14 +271,14 @@ std::vector<int16_t> audio::river::Interface::read(size_t _nbChunk) {
#endif
void audio::river::Interface::read(void* _value, size_t _nbChunk) {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
m_process.updateInterAlgo();
// TODO :...
}
size_t audio::river::Interface::size() const {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
// TODO :...
return 0;
}
@@ -288,9 +288,9 @@ size_t audio::river::Interface::size() const {
void audio::river::Interface::setBufferSize(size_t _nbChunk) {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
if (m_node->isInput() == true) {
std11::shared_ptr<audio::drain::EndPointRead> algo = m_process.get<audio::drain::EndPointRead>(m_process.size()-1);
std::shared_ptr<audio::drain::EndPointRead> algo = m_process.get<audio::drain::EndPointRead>(m_process.size()-1);
if (algo == nullptr) {
RIVER_ERROR("Request set buffer size for Interface that is not READ or WRITE mode ...");
return;
@@ -298,7 +298,7 @@ void audio::river::Interface::setBufferSize(size_t _nbChunk) {
algo->setBufferSize(_nbChunk);
return;
}
std11::shared_ptr<audio::drain::EndPointWrite> algo = m_process.get<audio::drain::EndPointWrite>(0);
std::shared_ptr<audio::drain::EndPointWrite> algo = m_process.get<audio::drain::EndPointWrite>(0);
if (algo == nullptr) {
RIVER_ERROR("Request set buffer size for Interface that is not READ or WRITE mode ...");
return;
@@ -306,10 +306,10 @@ void audio::river::Interface::setBufferSize(size_t _nbChunk) {
algo->setBufferSize(_nbChunk);
}
void audio::river::Interface::setBufferSize(const std11::chrono::microseconds& _time) {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
void audio::river::Interface::setBufferSize(const std::chrono::microseconds& _time) {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
if (m_node->isInput() == true) {
std11::shared_ptr<audio::drain::EndPointRead> algo = m_process.get<audio::drain::EndPointRead>(m_process.size()-1);
std::shared_ptr<audio::drain::EndPointRead> algo = m_process.get<audio::drain::EndPointRead>(m_process.size()-1);
if (algo == nullptr) {
RIVER_ERROR("Request set buffer size for Interface that is not READ or WRITE mode ...");
return;
@@ -317,7 +317,7 @@ void audio::river::Interface::setBufferSize(const std11::chrono::microseconds& _
algo->setBufferSize(_time);
return;
}
std11::shared_ptr<audio::drain::EndPointWrite> algo = m_process.get<audio::drain::EndPointWrite>(0);
std::shared_ptr<audio::drain::EndPointWrite> algo = m_process.get<audio::drain::EndPointWrite>(0);
if (algo == nullptr) {
RIVER_ERROR("Request set buffer size for Interface that is not READ or WRITE mode ...");
return;
@@ -326,16 +326,16 @@ void audio::river::Interface::setBufferSize(const std11::chrono::microseconds& _
}
size_t audio::river::Interface::getBufferSize() {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
if (m_node->isInput() == true) {
std11::shared_ptr<audio::drain::EndPointRead> algo = m_process.get<audio::drain::EndPointRead>(m_process.size()-1);
std::shared_ptr<audio::drain::EndPointRead> algo = m_process.get<audio::drain::EndPointRead>(m_process.size()-1);
if (algo == nullptr) {
RIVER_ERROR("Request get buffer size for Interface that is not READ or WRITE mode ...");
return 0;
}
return algo->getBufferSize();
}
std11::shared_ptr<audio::drain::EndPointWrite> algo = m_process.get<audio::drain::EndPointWrite>(0);
std::shared_ptr<audio::drain::EndPointWrite> algo = m_process.get<audio::drain::EndPointWrite>(0);
if (algo == nullptr) {
RIVER_ERROR("Request get buffer size for Interface that is not READ or WRITE mode ...");
return 0;
@@ -343,35 +343,35 @@ size_t audio::river::Interface::getBufferSize() {
return algo->getBufferSize();
}
std11::chrono::microseconds audio::river::Interface::getBufferSizeMicrosecond() {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::chrono::microseconds audio::river::Interface::getBufferSizeMicrosecond() {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
if (m_node->isInput() == true) {
std11::shared_ptr<audio::drain::EndPointRead> algo = m_process.get<audio::drain::EndPointRead>(m_process.size()-1);
std::shared_ptr<audio::drain::EndPointRead> algo = m_process.get<audio::drain::EndPointRead>(m_process.size()-1);
if (algo == nullptr) {
RIVER_ERROR("Request get buffer size for Interface that is not READ or WRITE mode ...");
return std11::chrono::microseconds(0);
return std::chrono::microseconds(0);
}
return algo->getBufferSizeMicrosecond();
}
std11::shared_ptr<audio::drain::EndPointWrite> algo = m_process.get<audio::drain::EndPointWrite>(0);
std::shared_ptr<audio::drain::EndPointWrite> algo = m_process.get<audio::drain::EndPointWrite>(0);
if (algo == nullptr) {
RIVER_ERROR("Request get buffer size for Interface that is not READ or WRITE mode ...");
return std11::chrono::microseconds(0);
return std::chrono::microseconds(0);
}
return algo->getBufferSizeMicrosecond();
}
size_t audio::river::Interface::getBufferFillSize() {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
if (m_node->isInput() == true) {
std11::shared_ptr<audio::drain::EndPointRead> algo = m_process.get<audio::drain::EndPointRead>(m_process.size()-1);
std::shared_ptr<audio::drain::EndPointRead> algo = m_process.get<audio::drain::EndPointRead>(m_process.size()-1);
if (algo == nullptr) {
RIVER_ERROR("Request get buffer size for Interface that is not READ or WRITE mode ...");
return 0;
}
return algo->getBufferFillSize();
}
std11::shared_ptr<audio::drain::EndPointWrite> algo = m_process.get<audio::drain::EndPointWrite>(0);
std::shared_ptr<audio::drain::EndPointWrite> algo = m_process.get<audio::drain::EndPointWrite>(0);
if (algo == nullptr) {
RIVER_ERROR("Request get buffer size for Interface that is not READ or WRITE mode ...");
return 0;
@@ -380,20 +380,20 @@ size_t audio::river::Interface::getBufferFillSize() {
}
std11::chrono::microseconds audio::river::Interface::getBufferFillSizeMicrosecond() {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::chrono::microseconds audio::river::Interface::getBufferFillSizeMicrosecond() {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
if (m_node->isInput() == true) {
std11::shared_ptr<audio::drain::EndPointRead> algo = m_process.get<audio::drain::EndPointRead>(m_process.size()-1);
std::shared_ptr<audio::drain::EndPointRead> algo = m_process.get<audio::drain::EndPointRead>(m_process.size()-1);
if (algo == nullptr) {
RIVER_ERROR("Request get buffer size for Interface that is not READ or WRITE mode ...");
return std11::chrono::microseconds(0);
return std::chrono::microseconds(0);
}
return algo->getBufferFillSizeMicrosecond();
}
std11::shared_ptr<audio::drain::EndPointWrite> algo = m_process.get<audio::drain::EndPointWrite>(0);
std::shared_ptr<audio::drain::EndPointWrite> algo = m_process.get<audio::drain::EndPointWrite>(0);
if (algo == nullptr) {
RIVER_ERROR("Request get buffer size for Interface that is not READ or WRITE mode ...");
return std11::chrono::microseconds(0);
return std::chrono::microseconds(0);
}
return algo->getBufferFillSizeMicrosecond();
}
@@ -401,23 +401,23 @@ std11::chrono::microseconds audio::river::Interface::getBufferFillSizeMicrosecon
void audio::river::Interface::clearInternalBuffer() {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
m_process.updateInterAlgo();
// TODO :...
}
audio::Time audio::river::Interface::getCurrentTime() const {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
// TODO :...
return audio::Time();
return audio::Time::now();
}
void audio::river::Interface::addVolumeGroup(const std::string& _name) {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
RIVER_DEBUG("addVolumeGroup(" << _name << ")");
std11::shared_ptr<audio::drain::Volume> algo = m_process.get<audio::drain::Volume>("volume");
std::shared_ptr<audio::drain::Volume> algo = m_process.get<audio::drain::Volume>("volume");
if (algo == nullptr) {
m_process.removeAlgoDynamic();
// add all time the volume stage :
@@ -431,29 +431,29 @@ void audio::river::Interface::addVolumeGroup(const std::string& _name) {
}
if (_name == "FLOW") {
// Local volume name
algo->addVolumeStage(std11::make_shared<audio::drain::VolumeElement>(_name));
algo->addVolumeStage(std::make_shared<audio::drain::VolumeElement>(_name));
} else {
// get manager unique instance:
std11::shared_ptr<audio::river::io::Manager> mng = audio::river::io::Manager::getInstance();
std::shared_ptr<audio::river::io::Manager> mng = audio::river::io::Manager::getInstance();
algo->addVolumeStage(mng->getVolumeGroup(_name));
}
}
void audio::river::Interface::systemNewInputData(audio::Time _time, const void* _data, size_t _nbChunk) {
std11::unique_lock<std11::recursive_mutex> lockProcess(m_mutex);
std::unique_lock<std::recursive_mutex> lockProcess(m_mutex);
void * tmpData = const_cast<void*>(_data);
m_process.push(_time, tmpData, _nbChunk);
}
void audio::river::Interface::systemNeedOutputData(audio::Time _time, void* _data, size_t _nbChunk, size_t _chunkSize) {
std11::unique_lock<std11::recursive_mutex> lockProcess(m_mutex);
std::unique_lock<std::recursive_mutex> lockProcess(m_mutex);
//RIVER_INFO("time : " << _time);
m_process.pull(_time, _data, _nbChunk, _chunkSize);
}
void audio::river::Interface::systemVolumeChange() {
std11::unique_lock<std11::recursive_mutex> lockProcess(m_mutex);
std11::shared_ptr<audio::drain::Volume> algo = m_process.get<audio::drain::Volume>("volume");
std::unique_lock<std::recursive_mutex> lockProcess(m_mutex);
std::shared_ptr<audio::drain::Volume> algo = m_process.get<audio::drain::Volume>("volume");
if (algo == nullptr) {
return;
}

39
audio/river/Interface.h
View File

@@ -3,17 +3,15 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#ifndef __AUDIO_RIVER_INTERFACE_H__
#define __AUDIO_RIVER_INTERFACE_H__
#pragma once
#include <string>
#include <vector>
#include <stdint.h>
#include <etk/mutex.h>
#include <etk/chrono.h>
#include <etk/functional.h>
#include <etk/memory.h>
#include <mutex>
#include <chrono>
#include <functional>
#include <memory>
#include <audio/format.h>
#include <audio/channel.h>
#include <audio/drain/Process.h>
@@ -41,7 +39,7 @@ namespace audio {
* @brief Interface is the basic handle to manage the input output stream
* @note To create this class see @ref audio::river::Manager class
*/
class Interface : public std11::enable_shared_from_this<Interface> {
class Interface : public std::enable_shared_from_this<Interface> {
friend class io::Node;
friend class io::NodeAirTAudio;
friend class io::NodeAEC;
@@ -67,8 +65,8 @@ namespace audio {
bool init(float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std11::shared_ptr<audio::river::io::Node>& _node,
const std11::shared_ptr<const ejson::Object>& _config);
const std::shared_ptr<audio::river::io::Node>& _node,
const std::shared_ptr<const ejson::Object>& _config);
/**
* @brief Factory of this interface (called by class audio::river::Manager)
* @param[in] _freq Frequency.
@@ -79,19 +77,19 @@ namespace audio {
* @return nullptr The configuration does not work.
* @return pointer The interface has been corectly created.
*/
static std11::shared_ptr<Interface> create(float _freq,
static std::shared_ptr<Interface> create(float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std11::shared_ptr<audio::river::io::Node>& _node,
const std11::shared_ptr<const ejson::Object>& _config);
const std::shared_ptr<audio::river::io::Node>& _node,
const std::shared_ptr<const ejson::Object>& _config);
public:
/**
* @brief Destructor
*/
virtual ~Interface();
protected:
mutable std11::recursive_mutex m_mutex; //!< Local mutex to protect data
std11::shared_ptr<const ejson::Object> m_config; //!< configuration set by the user.
mutable std::recursive_mutex m_mutex; //!< Local mutex to protect data
std::shared_ptr<const ejson::Object> m_config; //!< configuration set by the user.
protected:
enum modeInterface m_mode; //!< interface type (input/output/feedback)
public:
@@ -118,7 +116,7 @@ namespace audio {
}
}
protected:
std11::shared_ptr<audio::river::io::Node> m_node; //!< Hardware interface to/from stream audio flow.
std::shared_ptr<audio::river::io::Node> m_node; //!< Hardware interface to/from stream audio flow.
protected:
std::string m_name; //!< Name of the interface.
public:
@@ -247,7 +245,7 @@ namespace audio {
* @brief Set buffer size size of the buffer with the stored time in <20>s
* @param[in] _time Time in microsecond of the buffer
*/
virtual void setBufferSize(const std11::chrono::microseconds& _time);
virtual void setBufferSize(const std::chrono::microseconds& _time);
/**
* @brief get buffer size in chunk number
* @return Number of chunk that can be written in the buffer
@@ -257,7 +255,7 @@ namespace audio {
* @brief Set buffer size size of the buffer with the stored time in <20>s
* @return Time in microsecond that can be written in the buffer
*/
virtual std11::chrono::microseconds getBufferSizeMicrosecond();
virtual std::chrono::microseconds getBufferSizeMicrosecond();
/**
* @brief Get buffer size filled in chunk number
* @return Number of chunk in the buffer (that might be read/write)
@@ -267,7 +265,7 @@ namespace audio {
* @brief Set buffer size size of the buffer with the stored time in <20>s
* @return Time in microsecond of the buffer (that might be read/write)
*/
virtual std11::chrono::microseconds getBufferFillSizeMicrosecond();
virtual std::chrono::microseconds getBufferFillSizeMicrosecond();
/**
* @brief Remove internal Buffer
*/
@@ -330,6 +328,3 @@ namespace audio {
};
}
}
#endif

120
audio/river/Manager.cpp
View File

@@ -15,13 +15,13 @@
#undef __class__
#define __class__ "Manager"
static std11::mutex g_mutex;
static std::vector<std11::weak_ptr<audio::river::Manager> > g_listOfAllManager;
static std::mutex g_mutex;
static std::vector<std::weak_ptr<audio::river::Manager> > g_listOfAllManager;
std11::shared_ptr<audio::river::Manager> audio::river::Manager::create(const std::string& _applicationUniqueId) {
std11::unique_lock<std11::mutex> lock(g_mutex);
std::shared_ptr<audio::river::Manager> audio::river::Manager::create(const std::string& _applicationUniqueId) {
std::unique_lock<std::mutex> lock(g_mutex);
for (size_t iii=0; iii<g_listOfAllManager.size() ; ++iii) {
std11::shared_ptr<audio::river::Manager> tmp = g_listOfAllManager[iii].lock();
std::shared_ptr<audio::river::Manager> tmp = g_listOfAllManager[iii].lock();
if (tmp == nullptr) {
continue;
}
@@ -30,7 +30,7 @@ std11::shared_ptr<audio::river::Manager> audio::river::Manager::create(const std
}
}
// create a new one:
std11::shared_ptr<audio::river::Manager> out = std11::shared_ptr<audio::river::Manager>(new audio::river::Manager(_applicationUniqueId));
std::shared_ptr<audio::river::Manager> out = std::shared_ptr<audio::river::Manager>(new audio::river::Manager(_applicationUniqueId));
// add it at the list:
for (size_t iii=0; iii<g_listOfAllManager.size() ; ++iii) {
if (g_listOfAllManager[iii].expired() == true) {
@@ -55,7 +55,7 @@ audio::river::Manager::~Manager() {
std::vector<std::string> audio::river::Manager::getListStreamInput() {
std::vector<std::string> output;
std11::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
std::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
if (manager == nullptr) {
RIVER_ERROR("Unable to load harware IO manager ... ");
} else {
@@ -66,7 +66,7 @@ std::vector<std::string> audio::river::Manager::getListStreamInput() {
std::vector<std::string> audio::river::Manager::getListStreamOutput() {
std::vector<std::string> output;
std11::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
std::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
if (manager == nullptr) {
RIVER_ERROR("Unable to load harware IO manager ... ");
} else {
@@ -77,7 +77,7 @@ std::vector<std::string> audio::river::Manager::getListStreamOutput() {
std::vector<std::string> audio::river::Manager::getListStreamVirtual() {
std::vector<std::string> output;
std11::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
std::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
if (manager == nullptr) {
RIVER_ERROR("Unable to load harware IO manager ... ");
} else {
@@ -88,7 +88,7 @@ std::vector<std::string> audio::river::Manager::getListStreamVirtual() {
std::vector<std::string> audio::river::Manager::getListStream() {
std::vector<std::string> output;
std11::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
std::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
if (manager == nullptr) {
RIVER_ERROR("Unable to load harware IO manager ... ");
} else {
@@ -98,7 +98,7 @@ std::vector<std::string> audio::river::Manager::getListStream() {
}
bool audio::river::Manager::setVolume(const std::string& _volumeName, float _valuedB) {
std11::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
std::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
if (manager == nullptr) {
RIVER_ERROR("Unable to load harware IO manager ... ");
return false;
@@ -107,7 +107,7 @@ bool audio::river::Manager::setVolume(const std::string& _volumeName, float _val
}
float audio::river::Manager::getVolume(const std::string& _volumeName) const {
std11::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
std::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
if (manager == nullptr) {
RIVER_ERROR("Unable to load harware IO manager ... ");
return false;
@@ -116,7 +116,7 @@ float audio::river::Manager::getVolume(const std::string& _volumeName) const {
}
std::pair<float,float> audio::river::Manager::getVolumeRange(const std::string& _volumeName) const {
std11::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
std::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
if (manager == nullptr) {
RIVER_ERROR("Unable to load harware IO manager ... ");
return std::make_pair<float,float>(0.0f,0.0f);
@@ -124,30 +124,48 @@ std::pair<float,float> audio::river::Manager::getVolumeRange(const std::string&
return manager->getVolumeRange(_volumeName);
}
std11::shared_ptr<audio::river::Interface> audio::river::Manager::createOutput(float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std::string& _streamName,
const std::string& _options) {
// get global hardware interface:
std11::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
void audio::river::Manager::setMute(const std::string& _volumeName, bool _mute) {
std::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
if (manager == nullptr) {
RIVER_ERROR("Unable to load harware IO manager ... ");
return std11::shared_ptr<audio::river::Interface>();
return;
}
manager->setMute(_volumeName, _mute);
}
bool audio::river::Manager::getMute(const std::string& _volumeName) const {
std::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
if (manager == nullptr) {
RIVER_ERROR("Unable to load harware IO manager ... ");
return false;
}
return manager->getMute(_volumeName);
}
std::shared_ptr<audio::river::Interface> audio::river::Manager::createOutput(float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std::string& _streamName,
const std::string& _options) {
// get global hardware interface:
std::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
if (manager == nullptr) {
RIVER_ERROR("Unable to load harware IO manager ... ");
return std::shared_ptr<audio::river::Interface>();
}
// get the output or input channel :
std11::shared_ptr<audio::river::io::Node> node = manager->getNode(_streamName);
std::shared_ptr<audio::river::io::Node> node = manager->getNode(_streamName);
if (node == nullptr) {
RIVER_ERROR("Can not get the Requested stream '" << _streamName << "' ==> not listed in : " << manager->getListStream());
return std11::shared_ptr<audio::river::Interface>();
return std::shared_ptr<audio::river::Interface>();
}
if (node->isOutput() != true) {
RIVER_ERROR("Can not Connect output on other thing than output ... for stream '" << _streamName << "'");;
return std11::shared_ptr<audio::river::Interface>();
return std::shared_ptr<audio::river::Interface>();
}
// create user iterface:
std11::shared_ptr<audio::river::Interface> interface;
std11::shared_ptr<ejson::Object> tmpOption = ejson::Object::create(_options);
std::shared_ptr<audio::river::Interface> interface;
std::shared_ptr<ejson::Object> tmpOption = ejson::Object::create(_options);
tmpOption->addString("io", "output");
interface = audio::river::Interface::create(_freq, _map, _format, node, tmpOption);
// store it in a list (needed to apply some parameters).
@@ -155,30 +173,30 @@ std11::shared_ptr<audio::river::Interface> audio::river::Manager::createOutput(f
return interface;
}
std11::shared_ptr<audio::river::Interface> audio::river::Manager::createInput(float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std::string& _streamName,
const std::string& _options) {
std::shared_ptr<audio::river::Interface> audio::river::Manager::createInput(float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std::string& _streamName,
const std::string& _options) {
// get global hardware interface:
std11::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
std::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
if (manager == nullptr) {
RIVER_ERROR("Unable to load harware IO manager ... ");
return std11::shared_ptr<audio::river::Interface>();
return std::shared_ptr<audio::river::Interface>();
}
// get the output or input channel :
std11::shared_ptr<audio::river::io::Node> node = manager->getNode(_streamName);
std::shared_ptr<audio::river::io::Node> node = manager->getNode(_streamName);
if (node == nullptr) {
RIVER_ERROR("Can not get the Requested stream '" << _streamName << "' ==> not listed in : " << manager->getListStream());
return std11::shared_ptr<audio::river::Interface>();
return std::shared_ptr<audio::river::Interface>();
}
if (node->isInput() != true) {
RIVER_ERROR("Can not Connect input on other thing than input ... for stream '" << _streamName << "'");;
return std11::shared_ptr<audio::river::Interface>();
return std::shared_ptr<audio::river::Interface>();
}
// create user iterface:
std11::shared_ptr<audio::river::Interface> interface;
std11::shared_ptr<ejson::Object> tmpOption = ejson::Object::create(_options);
std::shared_ptr<audio::river::Interface> interface;
std::shared_ptr<ejson::Object> tmpOption = ejson::Object::create(_options);
tmpOption->addString("io", "input");
interface = audio::river::Interface::create(_freq, _map, _format, node, tmpOption);
// store it in a list (needed to apply some parameters).
@@ -187,30 +205,30 @@ std11::shared_ptr<audio::river::Interface> audio::river::Manager::createInput(fl
}
std11::shared_ptr<audio::river::Interface> audio::river::Manager::createFeedback(float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std::string& _streamName,
const std::string& _options) {
std::shared_ptr<audio::river::Interface> audio::river::Manager::createFeedback(float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std::string& _streamName,
const std::string& _options) {
// get global hardware interface:
std11::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
std::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
if (manager == nullptr) {
RIVER_ERROR("Unable to load harware IO manager ... ");
return std11::shared_ptr<audio::river::Interface>();
return std::shared_ptr<audio::river::Interface>();
}
// get the output or input channel :
std11::shared_ptr<audio::river::io::Node> node = manager->getNode(_streamName);
std::shared_ptr<audio::river::io::Node> node = manager->getNode(_streamName);
if (node == nullptr) {
RIVER_ERROR("Can not get the Requested stream '" << _streamName << "' ==> not listed in : " << manager->getListStream());
return std11::shared_ptr<audio::river::Interface>();
return std::shared_ptr<audio::river::Interface>();
}
if (node->isOutput() != true) {
RIVER_ERROR("Can not Connect feedback on other thing than output ... for stream '" << _streamName << "'");;
return std11::shared_ptr<audio::river::Interface>();
return std::shared_ptr<audio::river::Interface>();
}
// create user iterface:
std11::shared_ptr<audio::river::Interface> interface;
std11::shared_ptr<ejson::Object> tmpOption = ejson::Object::create(_options);
std::shared_ptr<audio::river::Interface> interface;
std::shared_ptr<ejson::Object> tmpOption = ejson::Object::create(_options);
tmpOption->addString("io", "feedback");
interface = audio::river::Interface::create(_freq, _map, _format, node, tmpOption);
// store it in a list (needed to apply some parameters).
@@ -220,7 +238,7 @@ std11::shared_ptr<audio::river::Interface> audio::river::Manager::createFeedback
void audio::river::Manager::generateDotAll(const std::string& _filename) {
// get global hardware interface:
std11::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
std::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
if (manager == nullptr) {
RIVER_ERROR("Can not get the harware manager");
return;

32
audio/river/Manager.h
View File

@@ -3,13 +3,11 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#ifndef __AUDIO_RIVER_MANAGER_H__
#define __AUDIO_RIVER_MANAGER_H__
#pragma once
#include <string>
#include <stdint.h>
#include <etk/memory.h>
#include <memory>
#include <audio/river/Interface.h>
#include <audio/format.h>
#include <audio/channel.h>
@@ -20,10 +18,10 @@ namespace audio {
/**
* @brief Audio interface manager : Single interface for every application that want to access on the Audio input/output
*/
class Manager : public std11::enable_shared_from_this<Manager> {
class Manager : public std::enable_shared_from_this<Manager> {
private:
const std::string& m_applicationUniqueId; //!< name of the application that open the Audio Interface.
std::vector<std11::weak_ptr<audio::river::Interface> > m_listOpenInterface; //!< List of all open Stream.
std::vector<std::weak_ptr<audio::river::Interface> > m_listOpenInterface; //!< List of all open Stream.
protected:
/**
* @brief Constructor
@@ -35,7 +33,7 @@ namespace audio {
* @param[in] _applicationUniqueId Unique name of the application
* @return Pointer on the manager or nullptr if an error occured
*/
static std11::shared_ptr<audio::river::Manager> create(const std::string& _applicationUniqueId);
static std::shared_ptr<audio::river::Manager> create(const std::string& _applicationUniqueId);
/**
* @brief Destructor
*/
@@ -78,6 +76,7 @@ namespace audio {
* @example ret = getVolume("MASTER"); can return something like ret = -3.0f
*/
virtual float getVolume(const std::string& _volumeName) const;
/**
* @brief Get a parameter value
* @param[in] _volumeName Name of the volume (MASTER, MATER_BT ...)
@@ -85,6 +84,18 @@ namespace audio {
* @example ret = getVolumeRange("MASTER"); can return something like ret=(-120.0f,0.0f)
*/
virtual std::pair<float,float> getVolumeRange(const std::string& _volumeName) const;
/**
* @brief Set a Mute for a specific volume group
* @param[in] _volumeName Name of the volume (MASTER, MATER_BT ...)
* @param[in] _mute Mute enable or disable.
*/
virtual void setMute(const std::string& _volumeName, bool _mute);
/**
* @brief Get a volume value
* @param[in] _volumeName Name of the volume (MASTER, MATER_BT ...)
* @return The Mute of the volume volume.
*/
virtual bool getMute(const std::string& _volumeName) const;
/**
* @brief Create output Interface
@@ -95,7 +106,7 @@ namespace audio {
* @param[in] _options Json option to configure default resampling and many other things.
* @return a pointer on the interface
*/
virtual std11::shared_ptr<Interface> createOutput(float _freq = 48000,
virtual std::shared_ptr<Interface> createOutput(float _freq = 48000,
const std::vector<audio::channel>& _map = std::vector<audio::channel>(),
audio::format _format = audio::format_int16,
const std::string& _streamName = "",
@@ -109,7 +120,7 @@ namespace audio {
* @param[in] _options Json option to configure default resampling and many other things.
* @return a pointer on the interface
*/
virtual std11::shared_ptr<Interface> createInput(float _freq = 48000,
virtual std::shared_ptr<Interface> createInput(float _freq = 48000,
const std::vector<audio::channel>& _map = std::vector<audio::channel>(),
audio::format _format = audio::format_int16,
const std::string& _streamName = "",
@@ -123,7 +134,7 @@ namespace audio {
* @param[in] _options Json option to configure default resampling and many other things.
* @return a pointer on the interface
*/
virtual std11::shared_ptr<Interface> createFeedback(float _freq = 48000,
virtual std::shared_ptr<Interface> createFeedback(float _freq = 48000,
const std::vector<audio::channel>& _map = std::vector<audio::channel>(),
audio::format _format = audio::format_int16,
const std::string& _streamName = "",
@@ -137,4 +148,3 @@ namespace audio {
}
}
#endif

2
audio/river/debug.cpp
View File

@@ -8,6 +8,6 @@
int32_t audio::river::getLogId() {
static int32_t g_val = etk::log::registerInstance("river");
static int32_t g_val = elog::registerInstance("river");
return g_val;
}

12
audio/river/debug.h
View File

@@ -3,19 +3,16 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#pragma once
#ifndef __AUDIO_RIVER_DEBUG_H__
#define __AUDIO_RIVER_DEBUG_H__
#include <etk/log.h>
#include <elog/log.h>
namespace audio {
namespace river {
int32_t getLogId();
}
}
#define RIVER_BASE(info,data) TK_LOG_BASE(audio::river::getLogId(),info,data)
#define RIVER_BASE(info,data) ELOG_BASE(audio::river::getLogId(),info,data)
#define RIVER_CRITICAL(data) RIVER_BASE(1, data)
#define RIVER_ERROR(data) RIVER_BASE(2, data)
@@ -60,6 +57,3 @@ namespace audio {
} \
}while(0)
#endif

6
audio/river/debugRemove.h
View File

@@ -3,9 +3,7 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#ifdef __AUDIO_RIVER_DEBUG_H__
#undef __AUDIO_RIVER_DEBUG_H__
#pragma once
#undef RIVER_BASE
#undef RIVER_CRITICAL
@@ -17,5 +15,3 @@
#undef RIVER_TODO
#undef RIVER_ASSERT
#endif

16
audio/river/io/Group.cpp
View File

@@ -18,7 +18,7 @@
void audio::river::io::Group::createFrom(const ejson::Document& _obj, const std::string& _name) {
RIVER_INFO("Create Group[" << _name << "] (START) ___________________________");
for (size_t iii=0; iii<_obj.size(); ++iii) {
const std11::shared_ptr<const ejson::Object> tmpObject = _obj.getObject(_obj.getKey(iii));
const std::shared_ptr<const ejson::Object> tmpObject = _obj.getObject(_obj.getKey(iii));
if (tmpObject == nullptr) {
continue;
}
@@ -30,7 +30,7 @@ void audio::river::io::Group::createFrom(const ejson::Document& _obj, const std:
#ifdef AUDIO_RIVER_BUILD_ORCHESTRA
if ( ioType == "input"
|| ioType == "output") {
std11::shared_ptr<audio::river::io::Node> tmp = audio::river::io::NodeOrchestra::create(_obj.getKey(iii), tmpObject);
std::shared_ptr<audio::river::io::Node> tmp = audio::river::io::NodeOrchestra::create(_obj.getKey(iii), tmpObject);
tmp->setGroup(shared_from_this());
m_list.push_back(tmp);
}
@@ -38,7 +38,7 @@ void audio::river::io::Group::createFrom(const ejson::Document& _obj, const std:
#ifdef AUDIO_RIVER_BUILD_PORTAUDIO
if ( ioType == "PAinput"
|| ioType == "PAoutput") {
std11::shared_ptr<audio::river::io::Node> tmp = audio::river::io::NodePortAudio::create(_obj.getKey(iii), tmpObject);
std::shared_ptr<audio::river::io::Node> tmp = audio::river::io::NodePortAudio::create(_obj.getKey(iii), tmpObject);
tmp->setGroup(shared_from_this());
m_list.push_back(tmp);
}
@@ -49,10 +49,10 @@ void audio::river::io::Group::createFrom(const ejson::Document& _obj, const std:
// Note : The interlink work only for alsa (NOW) and with AirTAudio...
if(m_list.size() > 1) {
#ifdef AUDIO_RIVER_BUILD_ORCHESTRA
std11::shared_ptr<audio::river::io::NodeOrchestra> linkRef = std11::dynamic_pointer_cast<audio::river::io::NodeOrchestra>(m_list[0]);
std::shared_ptr<audio::river::io::NodeOrchestra> linkRef = std::dynamic_pointer_cast<audio::river::io::NodeOrchestra>(m_list[0]);
for (size_t iii=1; iii<m_list.size(); ++iii) {
if (m_list[iii] != nullptr) {
std11::shared_ptr<audio::river::io::NodeOrchestra> link = std11::dynamic_pointer_cast<audio::river::io::NodeOrchestra>(m_list[iii]);
std::shared_ptr<audio::river::io::NodeOrchestra> link = std::dynamic_pointer_cast<audio::river::io::NodeOrchestra>(m_list[iii]);
linkRef->m_interface.isMasterOf(link->m_interface);
}
}
@@ -62,7 +62,7 @@ void audio::river::io::Group::createFrom(const ejson::Document& _obj, const std:
// manage Link Between Nodes :
if (m_link != nullptr) {
RIVER_INFO("******** START LINK ************");
std11::shared_ptr<audio::river::io::NodeOrchestra> link = std11::dynamic_pointer_cast<audio::river::io::NodeOrchestra>(m_link);
std::shared_ptr<audio::river::io::NodeOrchestra> link = std::dynamic_pointer_cast<audio::river::io::NodeOrchestra>(m_link);
if (link == nullptr) {
RIVER_ERROR("Can not link 2 Interface with not the same type (reserved for HW interface)");
return;
@@ -82,7 +82,7 @@ void audio::river::io::Group::createFrom(const ejson::Document& _obj, const std:
}
std11::shared_ptr<audio::river::io::Node> audio::river::io::Group::getNode(const std::string& _name) {
std::shared_ptr<audio::river::io::Node> audio::river::io::Group::getNode(const std::string& _name) {
for (size_t iii=0; iii<m_list.size(); ++iii) {
if (m_list[iii] != nullptr) {
if (m_list[iii]->getName() == _name) {
@@ -90,7 +90,7 @@ std11::shared_ptr<audio::river::io::Node> audio::river::io::Group::getNode(const
}
}
}
return std11::shared_ptr<audio::river::io::Node>();
return std::shared_ptr<audio::river::io::Node>();
}
void audio::river::io::Group::start() {

11
audio/river/io/Group.h
View File

@@ -4,8 +4,7 @@
* @license APACHE v2.0 (see license file)
*/
#ifndef __AUDIO_RIVER_IO_GROUP_H__
#define __AUDIO_RIVER_IO_GROUP_H__
#pragma once
#include <string>
#include <vector>
@@ -24,7 +23,7 @@ namespace audio {
* is stopped.
* @note For the Alsa interface a low level link is availlable with AirTAudio for Alsa (One thread)
*/
class Group : public std11::enable_shared_from_this<Group> {
class Group : public std::enable_shared_from_this<Group> {
public:
/**
* @brief Contructor. No special thing to do.
@@ -37,7 +36,7 @@ namespace audio {
// TODO : ...
}
private:
std::vector< std11::shared_ptr<Node> > m_list; //!< List of all node in the group
std::vector< std::shared_ptr<Node> > m_list; //!< List of all node in the group
public:
/**
* @brief Create a group with all node needed to syncronize together
@@ -51,7 +50,7 @@ namespace audio {
* @return nullptr The node named _name was not found.
* @return pointer The node was find in this group.
*/
std11::shared_ptr<audio::river::io::Node> getNode(const std::string& _name);
std::shared_ptr<audio::river::io::Node> getNode(const std::string& _name);
/**
* @brief Start the group.
* @note all sub-node will be started.
@@ -74,5 +73,3 @@ namespace audio {
}
}
#endif

124
audio/river/io/Manager.cpp
View File

@@ -13,7 +13,7 @@
#include <audio/river/io/NodeOrchestra.h>
#include <audio/river/io/NodePortAudio.h>
#include <etk/os/FSNode.h>
#include <etk/memory.h>
#include <memory>
#include <etk/types.h>
#include <utility>
@@ -21,7 +21,7 @@
#define __class__ "io::Manager"
#ifdef AUDIO_RIVER_BUILD_PORTAUDIO
#include <portaudio.h>
#include <portaudio/portaudio.h>
#endif
static std::string basicAutoConfig =
@@ -67,7 +67,7 @@ audio::river::io::Manager::Manager() {
}
void audio::river::io::Manager::init(const std::string& _filename) {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
if (_filename == "") {
RIVER_INFO("Load default config");
m_config.parse(basicAutoConfig);
@@ -77,12 +77,12 @@ void audio::river::io::Manager::init(const std::string& _filename) {
}
void audio::river::io::Manager::initString(const std::string& _data) {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
m_config.parse(_data);
}
void audio::river::io::Manager::unInit() {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
// TODO : ...
}
@@ -95,21 +95,21 @@ audio::river::io::Manager::~Manager() {
#endif
};
std11::shared_ptr<audio::river::io::Manager> audio::river::io::Manager::getInstance() {
std::shared_ptr<audio::river::io::Manager> audio::river::io::Manager::getInstance() {
if (audio::river::isInit() == false) {
return std11::shared_ptr<audio::river::io::Manager>();
return std::shared_ptr<audio::river::io::Manager>();
}
static std11::shared_ptr<audio::river::io::Manager> manager(new Manager());
static std::shared_ptr<audio::river::io::Manager> manager(new Manager());
return manager;
}
std::vector<std::string> audio::river::io::Manager::getListStreamInput() {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
std::vector<std::string> output;
std::vector<std::string> keys = m_config.getKeys();
for (size_t iii=0; iii<keys.size(); ++iii) {
const std11::shared_ptr<const ejson::Object> tmppp = m_config.getObject(keys[iii]);
const std::shared_ptr<const ejson::Object> tmppp = m_config.getObject(keys[iii]);
if (tmppp != nullptr) {
std::string type = tmppp->getStringValue("io", "error");
if ( type == "input"
@@ -122,11 +122,11 @@ std::vector<std::string> audio::river::io::Manager::getListStreamInput() {
}
std::vector<std::string> audio::river::io::Manager::getListStreamOutput() {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
std::vector<std::string> output;
std::vector<std::string> keys = m_config.getKeys();
for (size_t iii=0; iii<keys.size(); ++iii) {
const std11::shared_ptr<const ejson::Object> tmppp = m_config.getObject(keys[iii]);
const std::shared_ptr<const ejson::Object> tmppp = m_config.getObject(keys[iii]);
if (tmppp != nullptr) {
std::string type = tmppp->getStringValue("io", "error");
if ( type == "output"
@@ -139,11 +139,11 @@ std::vector<std::string> audio::river::io::Manager::getListStreamOutput() {
}
std::vector<std::string> audio::river::io::Manager::getListStreamVirtual() {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
std::vector<std::string> output;
std::vector<std::string> keys = m_config.getKeys();
for (size_t iii=0; iii<keys.size(); ++iii) {
const std11::shared_ptr<const ejson::Object> tmppp = m_config.getObject(keys[iii]);
const std::shared_ptr<const ejson::Object> tmppp = m_config.getObject(keys[iii]);
if (tmppp != nullptr) {
std::string type = tmppp->getStringValue("io", "error");
if ( type != "input"
@@ -159,11 +159,11 @@ std::vector<std::string> audio::river::io::Manager::getListStreamVirtual() {
}
std::vector<std::string> audio::river::io::Manager::getListStream() {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
std::vector<std::string> output;
std::vector<std::string> keys = m_config.getKeys();
for (size_t iii=0; iii<keys.size(); ++iii) {
const std11::shared_ptr<const ejson::Object> tmppp = m_config.getObject(keys[iii]);
const std::shared_ptr<const ejson::Object> tmppp = m_config.getObject(keys[iii]);
if (tmppp != nullptr) {
std::string type = tmppp->getStringValue("io", "error");
if (type != "error") {
@@ -174,12 +174,12 @@ std::vector<std::string> audio::river::io::Manager::getListStream() {
return output;
}
std11::shared_ptr<audio::river::io::Node> audio::river::io::Manager::getNode(const std::string& _name) {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::shared_ptr<audio::river::io::Node> audio::river::io::Manager::getNode(const std::string& _name) {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
RIVER_WARNING("Get node : " << _name);
// search in the standalone list :
for (size_t iii=0; iii<m_list.size(); ++iii) {
std11::shared_ptr<audio::river::io::Node> tmppp = m_list[iii].lock();
std::shared_ptr<audio::river::io::Node> tmppp = m_list[iii].lock();
if ( tmppp != nullptr
&& _name == tmppp->getName()) {
RIVER_WARNING(" find it ... in standalone");
@@ -188,11 +188,11 @@ std11::shared_ptr<audio::river::io::Node> audio::river::io::Manager::getNode(con
}
// search in the group list:
{
for (std::map<std::string, std11::shared_ptr<audio::river::io::Group> >::iterator it(m_listGroup.begin());
for (std::map<std::string, std::shared_ptr<audio::river::io::Group> >::iterator it(m_listGroup.begin());
it != m_listGroup.end();
++it) {
if (it->second != nullptr) {
std11::shared_ptr<audio::river::io::Node> node = it->second->getNode(_name);
std::shared_ptr<audio::river::io::Node> node = it->second->getNode(_name);
if (node != nullptr) {
RIVER_WARNING(" find it ... in group: " << it->first);
return node;
@@ -202,7 +202,7 @@ std11::shared_ptr<audio::river::io::Node> audio::river::io::Manager::getNode(con
}
RIVER_WARNING("Try create a new one : " << _name);
// check if the node can be open :
const std11::shared_ptr<const ejson::Object> tmpObject = m_config.getObject(_name);
const std::shared_ptr<const ejson::Object> tmpObject = m_config.getObject(_name);
if (tmpObject != nullptr) {
//Check if it is in a group:
std::string groupName = tmpObject->getStringValue("group", "");
@@ -213,10 +213,10 @@ std11::shared_ptr<audio::river::io::Node> audio::river::io::Manager::getNode(con
|| ioType == "output"
|| ioType == "PAinput"
|| ioType == "PAoutput") ) {
std11::shared_ptr<audio::river::io::Group> tmpGroup = getGroup(groupName);
std::shared_ptr<audio::river::io::Group> tmpGroup = getGroup(groupName);
if (tmpGroup == nullptr) {
RIVER_WARNING("Can not get group ... '" << groupName << "'");
return std11::shared_ptr<audio::river::io::Node>();
return std::shared_ptr<audio::river::io::Node>();
}
return tmpGroup->getNode(_name);
} else {
@@ -228,7 +228,7 @@ std11::shared_ptr<audio::river::io::Node> audio::river::io::Manager::getNode(con
if ( ioType == "input"
|| ioType == "output") {
#ifdef AUDIO_RIVER_BUILD_ORCHESTRA
std11::shared_ptr<audio::river::io::Node> tmp = audio::river::io::NodeOrchestra::create(_name, tmpObject);
std::shared_ptr<audio::river::io::Node> tmp = audio::river::io::NodeOrchestra::create(_name, tmpObject);
m_list.push_back(tmp);
return tmp;
#else
@@ -238,7 +238,7 @@ std11::shared_ptr<audio::river::io::Node> audio::river::io::Manager::getNode(con
if ( ioType == "PAinput"
|| ioType == "PAoutput") {
#ifdef AUDIO_RIVER_BUILD_PORTAUDIO
std11::shared_ptr<audio::river::io::Node> tmp = audio::river::io::NodePortAudio::create(_name, tmpObject);
std::shared_ptr<audio::river::io::Node> tmp = audio::river::io::NodePortAudio::create(_name, tmpObject);
m_list.push_back(tmp);
return tmp;
#else
@@ -246,26 +246,26 @@ std11::shared_ptr<audio::river::io::Node> audio::river::io::Manager::getNode(con
#endif
}
if (ioType == "aec") {
std11::shared_ptr<audio::river::io::Node> tmp = audio::river::io::NodeAEC::create(_name, tmpObject);
std::shared_ptr<audio::river::io::Node> tmp = audio::river::io::NodeAEC::create(_name, tmpObject);
m_list.push_back(tmp);
return tmp;
}
if (ioType == "muxer") {
std11::shared_ptr<audio::river::io::Node> tmp = audio::river::io::NodeMuxer::create(_name, tmpObject);
std::shared_ptr<audio::river::io::Node> tmp = audio::river::io::NodeMuxer::create(_name, tmpObject);
m_list.push_back(tmp);
return tmp;
}
}
}
RIVER_ERROR("Can not create the interface : '" << _name << "' the node is not DEFINED in the configuration file availlable : " << m_config.getKeys());
return std11::shared_ptr<audio::river::io::Node>();
return std::shared_ptr<audio::river::io::Node>();
}
std11::shared_ptr<audio::drain::VolumeElement> audio::river::io::Manager::getVolumeGroup(const std::string& _name) {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::shared_ptr<audio::drain::VolumeElement> audio::river::io::Manager::getVolumeGroup(const std::string& _name) {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
if (_name == "") {
RIVER_ERROR("Try to create an audio group with no name ...");
return std11::shared_ptr<audio::drain::VolumeElement>();
return std::shared_ptr<audio::drain::VolumeElement>();
}
for (size_t iii=0; iii<m_volumeGroup.size(); ++iii) {
if (m_volumeGroup[iii] == nullptr) {
@@ -276,14 +276,14 @@ std11::shared_ptr<audio::drain::VolumeElement> audio::river::io::Manager::getVol
}
}
RIVER_DEBUG("Add a new volume group : '" << _name << "'");
std11::shared_ptr<audio::drain::VolumeElement> tmpVolume = std11::make_shared<audio::drain::VolumeElement>(_name);
std::shared_ptr<audio::drain::VolumeElement> tmpVolume = std::make_shared<audio::drain::VolumeElement>(_name);
m_volumeGroup.push_back(tmpVolume);
return tmpVolume;
}
bool audio::river::io::Manager::setVolume(const std::string& _volumeName, float _valuedB) {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std11::shared_ptr<audio::drain::VolumeElement> volume = getVolumeGroup(_volumeName);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
std::shared_ptr<audio::drain::VolumeElement> volume = getVolumeGroup(_volumeName);
if (volume == nullptr) {
RIVER_ERROR("Can not set volume ... : '" << _volumeName << "'");
return false;
@@ -295,7 +295,7 @@ bool audio::river::io::Manager::setVolume(const std::string& _volumeName, float
}
volume->setVolume(_valuedB);
for (size_t iii=0; iii<m_list.size(); ++iii) {
std11::shared_ptr<audio::river::io::Node> val = m_list[iii].lock();
std::shared_ptr<audio::river::io::Node> val = m_list[iii].lock();
if (val != nullptr) {
val->volumeChange();
}
@@ -304,8 +304,8 @@ bool audio::river::io::Manager::setVolume(const std::string& _volumeName, float
}
float audio::river::io::Manager::getVolume(const std::string& _volumeName) {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std11::shared_ptr<audio::drain::VolumeElement> volume = getVolumeGroup(_volumeName);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
std::shared_ptr<audio::drain::VolumeElement> volume = getVolumeGroup(_volumeName);
if (volume == nullptr) {
RIVER_ERROR("Can not get volume ... : '" << _volumeName << "'");
return 0.0f;
@@ -317,8 +317,34 @@ std::pair<float,float> audio::river::io::Manager::getVolumeRange(const std::stri
return std::make_pair<float,float>(-300, 300);
}
void audio::river::io::Manager::setMute(const std::string& _volumeName, bool _mute) {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
std::shared_ptr<audio::drain::VolumeElement> volume = getVolumeGroup(_volumeName);
if (volume == nullptr) {
RIVER_ERROR("Can not set volume ... : '" << _volumeName << "'");
return;
}
volume->setMute(_mute);
for (size_t iii=0; iii<m_list.size(); ++iii) {
std::shared_ptr<audio::river::io::Node> val = m_list[iii].lock();
if (val != nullptr) {
val->volumeChange();
}
}
}
bool audio::river::io::Manager::getMute(const std::string& _volumeName) {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
std::shared_ptr<audio::drain::VolumeElement> volume = getVolumeGroup(_volumeName);
if (volume == nullptr) {
RIVER_ERROR("Can not get volume ... : '" << _volumeName << "'");
return false;
}
return volume->getMute();
}
void audio::river::io::Manager::generateDot(const std::string& _filename) {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
etk::FSNode node(_filename);
RIVER_INFO("Generate the DOT files: " << node);
if (node.fileOpenWrite() == false) {
@@ -331,14 +357,14 @@ void audio::river::io::Manager::generateDot(const std::string& _filename) {
{
// standalone
for (size_t iii=0; iii<m_list.size(); ++iii) {
std11::shared_ptr<audio::river::io::Node> val = m_list[iii].lock();
std::shared_ptr<audio::river::io::Node> val = m_list[iii].lock();
if (val != nullptr) {
if (val->isHarwareNode() == true) {
val->generateDot(node);
}
}
}
for (std::map<std::string, std11::shared_ptr<audio::river::io::Group> >::iterator it(m_listGroup.begin());
for (std::map<std::string, std::shared_ptr<audio::river::io::Group> >::iterator it(m_listGroup.begin());
it != m_listGroup.end();
++it) {
if (it->second != nullptr) {
@@ -350,14 +376,14 @@ void audio::river::io::Manager::generateDot(const std::string& _filename) {
{
// standalone
for (size_t iii=0; iii<m_list.size(); ++iii) {
std11::shared_ptr<audio::river::io::Node> val = m_list[iii].lock();
std::shared_ptr<audio::river::io::Node> val = m_list[iii].lock();
if (val != nullptr) {
if (val->isHarwareNode() == false) {
val->generateDot(node);
}
}
}
for (std::map<std::string, std11::shared_ptr<audio::river::io::Group> >::iterator it(m_listGroup.begin());
for (std::map<std::string, std::shared_ptr<audio::river::io::Group> >::iterator it(m_listGroup.begin());
it != m_listGroup.end();
++it) {
if (it->second != nullptr) {
@@ -371,16 +397,16 @@ void audio::river::io::Manager::generateDot(const std::string& _filename) {
RIVER_INFO("Generate the DOT files: " << node << " (DONE)");
}
std11::shared_ptr<audio::river::io::Group> audio::river::io::Manager::getGroup(const std::string& _name) {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
std11::shared_ptr<audio::river::io::Group> out;
std::map<std::string, std11::shared_ptr<audio::river::io::Group> >::iterator it = m_listGroup.find(_name);
std::shared_ptr<audio::river::io::Group> audio::river::io::Manager::getGroup(const std::string& _name) {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
std::shared_ptr<audio::river::io::Group> out;
std::map<std::string, std::shared_ptr<audio::river::io::Group> >::iterator it = m_listGroup.find(_name);
if (it == m_listGroup.end()) {
RIVER_INFO("Create a new group: " << _name << " (START)");
out = std11::make_shared<audio::river::io::Group>();
out = std::make_shared<audio::river::io::Group>();
if (out != nullptr) {
out->createFrom(m_config, _name);
std::pair<std::string, std11::shared_ptr<audio::river::io::Group> > plop(std::string(_name), out);
std::pair<std::string, std::shared_ptr<audio::river::io::Group> > plop(std::string(_name), out);
m_listGroup.insert(plop);
RIVER_INFO("Create a new group: " << _name << " ( END )");
} else {

46
audio/river/io/Manager.h
View File

@@ -3,19 +3,17 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#ifndef __AUDIO_RIVER_IO_MANAGER_H__
#define __AUDIO_RIVER_IO_MANAGER_H__
#pragma once
#include <string>
#include <vector>
#include <map>
#include <list>
#include <stdint.h>
#include <etk/mutex.h>
#include <etk/chrono.h>
#include <etk/functional.h>
#include <etk/memory.h>
#include <mutex>
#include <chrono>
#include <functional>
#include <memory>
#include <audio/format.h>
#include <audio/channel.h>
#include <ejson/ejson.h>
@@ -30,16 +28,16 @@ namespace audio {
* @brief Internal sigleton of all Flow hadware and virtuals.
* @note this class will be initialize by the audio::river::init() function at the start of the application.
*/
class Manager : public std11::enable_shared_from_this<Manager> {
class Manager : public std::enable_shared_from_this<Manager> {
private:
mutable std11::recursive_mutex m_mutex; //!< prevent multiple access
mutable std::recursive_mutex m_mutex; //!< prevent multiple access
private:
/**
* @brief Constructor
*/
Manager();
public:
static std11::shared_ptr<Manager> getInstance();
static std::shared_ptr<Manager> getInstance();
/**
* @brief Destructor
*/
@@ -60,24 +58,24 @@ namespace audio {
void unInit();
private:
ejson::Document m_config; //!< harware configuration
std::vector<std11::shared_ptr<audio::river::io::Node> > m_listKeepAlive; //!< list of all Node that might be keep alive sone/all time
std::vector<std11::weak_ptr<audio::river::io::Node> > m_list; //!< List of all IO node
std::vector<std::shared_ptr<audio::river::io::Node> > m_listKeepAlive; //!< list of all Node that might be keep alive sone/all time
std::vector<std::weak_ptr<audio::river::io::Node> > m_list; //!< List of all IO node
public:
/**
* @brief Get a node with his name (the name is set in the description file.
* @param[in] _name Name of the node
* @return Pointer on the noe or a nullptr if the node does not exist in the file or an error occured.
*/
std11::shared_ptr<audio::river::io::Node> getNode(const std::string& _name);
std::shared_ptr<audio::river::io::Node> getNode(const std::string& _name);
private:
std::vector<std11::shared_ptr<audio::drain::VolumeElement> > m_volumeGroup; //!< List of All global volume in the Low level interface.
std::vector<std::shared_ptr<audio::drain::VolumeElement> > m_volumeGroup; //!< List of All global volume in the Low level interface.
public:
/**
* @brief Get a volume in the global list of vilume
* @param[in] _name Name of the volume.
* @return pointer on the requested volume (create it if does not exist). nullptr if the name is empty.
*/
std11::shared_ptr<audio::drain::VolumeElement> getVolumeGroup(const std::string& _name);
std::shared_ptr<audio::drain::VolumeElement> getVolumeGroup(const std::string& _name);
/**
* @brief Get all input audio stream.
* @return a list of all availlables input stream name
@@ -122,24 +120,34 @@ namespace audio {
* @example ret = getVolumeRange("MASTER"); can return something like ret=(-120.0f,0.0f)
*/
std::pair<float,float> getVolumeRange(const std::string& _volumeName) const;
/**
* @brief Set a Mute for a specific volume group
* @param[in] _volumeName Name of the volume (MASTER, MATER_BT ...)
* @param[in] _mute Mute enable or disable.
*/
void setMute(const std::string& _volumeName, bool _mute);
/**
* @brief Get a volume value
* @param[in] _volumeName Name of the volume (MASTER, MATER_BT ...)
* @return The Mute of the volume volume.
*/
bool getMute(const std::string& _volumeName);
/**
* @brief Generate the dot file corresponding at the actif nodes.
* @param[in] _filename Name of the file to write data.
*/
void generateDot(const std::string& _filename);
private:
std::map<std::string, std11::shared_ptr<audio::river::io::Group> > m_listGroup; //!< List of all groups
std::map<std::string, std::shared_ptr<audio::river::io::Group> > m_listGroup; //!< List of all groups
/**
* @brief get a low level interface group.
* @param[in] _name Name of the group.
* @return Pointer on the requested group or nullptr if the group does not existed.
*/
std11::shared_ptr<audio::river::io::Group> getGroup(const std::string& _name);
std::shared_ptr<audio::river::io::Group> getGroup(const std::string& _name);
};
}
}
}
#endif

30
audio/river/io/Node.cpp
View File

@@ -11,7 +11,7 @@
#define __class__ "io::Node"
audio::river::io::Node::Node(const std::string& _name, const std11::shared_ptr<const ejson::Object>& _config) :
audio::river::io::Node::Node(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config) :
m_config(_config),
m_name(_name),
m_isInput(false) {
@@ -58,7 +58,7 @@ audio::river::io::Node::Node(const std::string& _name, const std11::shared_ptr<c
}
// Get map type :
std::vector<audio::channel> map;
const std11::shared_ptr<const ejson::Array> listChannelMap = m_config->getArray("channel-map");
const std::shared_ptr<const ejson::Array> listChannelMap = m_config->getArray("channel-map");
if ( listChannelMap == nullptr
|| listChannelMap->size() == 0) {
// set default channel property:
@@ -123,7 +123,7 @@ size_t audio::river::io::Node::getNumberOfInterface(enum audio::river::modeInter
size_t audio::river::io::Node::getNumberOfInterfaceAvaillable(enum audio::river::modeInterface _interfaceType) {
size_t out = 0;
for (size_t iii=0; iii<m_listAvaillable.size(); ++iii) {
std11::shared_ptr<audio::river::Interface> element = m_listAvaillable[iii].lock();
std::shared_ptr<audio::river::Interface> element = m_listAvaillable[iii].lock();
if (element == nullptr) {
continue;
}
@@ -134,8 +134,8 @@ size_t audio::river::io::Node::getNumberOfInterfaceAvaillable(enum audio::river:
return out;
}
void audio::river::io::Node::registerAsRemote(const std11::shared_ptr<audio::river::Interface>& _interface) {
std::vector<std11::weak_ptr<audio::river::Interface> >::iterator it = m_listAvaillable.begin();
void audio::river::io::Node::registerAsRemote(const std::shared_ptr<audio::river::Interface>& _interface) {
std::vector<std::weak_ptr<audio::river::Interface> >::iterator it = m_listAvaillable.begin();
while (it != m_listAvaillable.end()) {
if (it->expired() == true) {
it = m_listAvaillable.erase(it);
@@ -146,9 +146,9 @@ void audio::river::io::Node::registerAsRemote(const std11::shared_ptr<audio::riv
m_listAvaillable.push_back(_interface);
}
void audio::river::io::Node::interfaceAdd(const std11::shared_ptr<audio::river::Interface>& _interface) {
void audio::river::io::Node::interfaceAdd(const std::shared_ptr<audio::river::Interface>& _interface) {
{
std11::unique_lock<std11::mutex> lock(m_mutex);
std::unique_lock<std::mutex> lock(m_mutex);
for (size_t iii=0; iii<m_list.size(); ++iii) {
if (_interface == m_list[iii]) {
return;
@@ -162,9 +162,9 @@ void audio::river::io::Node::interfaceAdd(const std11::shared_ptr<audio::river::
}
}
void audio::river::io::Node::interfaceRemove(const std11::shared_ptr<audio::river::Interface>& _interface) {
void audio::river::io::Node::interfaceRemove(const std::shared_ptr<audio::river::Interface>& _interface) {
{
std11::unique_lock<std11::mutex> lock(m_mutex);
std::unique_lock<std::mutex> lock(m_mutex);
for (size_t iii=0; iii< m_list.size(); ++iii) {
if (_interface == m_list[iii]) {
m_list.erase(m_list.begin()+iii);
@@ -182,7 +182,7 @@ void audio::river::io::Node::interfaceRemove(const std11::shared_ptr<audio::rive
void audio::river::io::Node::volumeChange() {
for (size_t iii=0; iii< m_listAvaillable.size(); ++iii) {
std11::shared_ptr<audio::river::Interface> node = m_listAvaillable[iii].lock();
std::shared_ptr<audio::river::Interface> node = m_listAvaillable[iii].lock();
if (node != nullptr) {
node->systemVolumeChange();
}
@@ -211,8 +211,8 @@ void audio::river::io::Node::newInput(const void* _inputBuffer,
}
void audio::river::io::Node::newOutput(void* _outputBuffer,
uint32_t _nbChunk,
const audio::Time& _time) {
uint32_t _nbChunk,
const audio::Time& _time) {
if (_outputBuffer == nullptr) {
return;
}
@@ -324,7 +324,7 @@ void audio::river::io::Node::generateDot(etk::FSNode& _node) {
if (m_listAvaillable[iii].expired() == true) {
continue;
}
std11::shared_ptr<audio::river::Interface> element = m_listAvaillable[iii].lock();
std::shared_ptr<audio::river::Interface> element = m_listAvaillable[iii].lock();
if (element == nullptr) {
continue;
}
@@ -350,7 +350,7 @@ void audio::river::io::Node::generateDot(etk::FSNode& _node) {
void audio::river::io::Node::startInGroup() {
std11::shared_ptr<audio::river::io::Group> group = m_group.lock();
std::shared_ptr<audio::river::io::Group> group = m_group.lock();
if (group != nullptr) {
group->start();
} else {
@@ -359,7 +359,7 @@ void audio::river::io::Node::startInGroup() {
}
void audio::river::io::Node::stopInGroup() {
std11::shared_ptr<audio::river::io::Group> group = m_group.lock();
std::shared_ptr<audio::river::io::Group> group = m_group.lock();
if (group != nullptr) {
group->stop();
} else {

38
audio/river/io/Node.h
View File

@@ -3,17 +3,15 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#ifndef __AUDIO_RIVER_IO_NODE_H__
#define __AUDIO_RIVER_IO_NODE_H__
#pragma once
#include <string>
#include <vector>
#include <list>
#include <stdint.h>
#include <etk/chrono.h>
#include <etk/functional.h>
#include <etk/memory.h>
#include <chrono>
#include <functional>
#include <memory>
#include <audio/format.h>
#include <audio/channel.h>
#include "Manager.h"
@@ -31,7 +29,7 @@ namespace audio {
* @brief A node is the base for input/output interface. When a output id declared, we automaticly have a feedback associated.
* this manage the muxing of data for output an the demuxing for input.
*/
class Node : public std11::enable_shared_from_this<Node> {
class Node : public std::enable_shared_from_this<Node> {
friend class audio::river::io::Group;
protected:
uint32_t m_uid; //!< uniqueNodeID use for debug an dot generation.
@@ -41,7 +39,7 @@ namespace audio {
* @param[in] _name Name of the node.
* @param[in] _config Configuration of the node.
*/
Node(const std::string& _name, const std11::shared_ptr<const ejson::Object>& _config);
Node(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config);
public:
/**
* @brief Destructor
@@ -56,8 +54,8 @@ namespace audio {
return false;
};
protected:
mutable std11::mutex m_mutex; //!< prevent open/close/write/read access that is multi-threaded.
std11::shared_ptr<const ejson::Object> m_config; //!< configuration description.
mutable std::mutex m_mutex; //!< prevent open/close/write/read access that is multi-threaded.
std::shared_ptr<const ejson::Object> m_config; //!< configuration description.
protected:
audio::drain::Process m_process; //!< Low level algorithms
public:
@@ -84,10 +82,10 @@ namespace audio {
}
}
protected:
std11::shared_ptr<audio::drain::VolumeElement> m_volume; //!< if a volume is set it is set here ... for hardware interface only.
std::shared_ptr<audio::drain::VolumeElement> m_volume; //!< if a volume is set it is set here ... for hardware interface only.
protected:
std::vector<std11::weak_ptr<audio::river::Interface> > m_listAvaillable; //!< List of all interface that exist on this Node
std::vector<std11::shared_ptr<audio::river::Interface> > m_list; //!< List of all connected interface at this node.
std::vector<std::weak_ptr<audio::river::Interface> > m_listAvaillable; //!< List of all interface that exist on this Node
std::vector<std::shared_ptr<audio::river::Interface> > m_list; //!< List of all connected interface at this node.
/**
* @brief Get the number of interface with a specific type.
* @param[in] _interfaceType Type of the interface.
@@ -114,17 +112,17 @@ namespace audio {
* @note We keep a std::weak_ptr. this is the reason why we do not have a remove.
* @param[in] _interface Pointer on the interface to register.
*/
void registerAsRemote(const std11::shared_ptr<audio::river::Interface>& _interface);
void registerAsRemote(const std::shared_ptr<audio::river::Interface>& _interface);
/**
* @brief Request this interface might receve/send dat on the flow. (start/resume)
* @param[in] _interface Pointer on the interface to register.
*/
void interfaceAdd(const std11::shared_ptr<audio::river::Interface>& _interface);
void interfaceAdd(const std::shared_ptr<audio::river::Interface>& _interface);
/**
* @brief Un-register the interface as an availlable read/write interface. (suspend/stop)
* @param[in] _interface Pointer on the interface to register.
*/
void interfaceRemove(const std11::shared_ptr<audio::river::Interface>& _interface);
void interfaceRemove(const std::shared_ptr<audio::river::Interface>& _interface);
protected:
std::string m_name; //!< Name of the interface
public:
@@ -153,13 +151,13 @@ namespace audio {
return !m_isInput;
}
protected:
std11::weak_ptr<audio::river::io::Group> m_group; //!< reference on the group. If available.
std::weak_ptr<audio::river::io::Group> m_group; //!< reference on the group. If available.
public:
/**
* @brief Set this node in a low level group.
* @param[in] _group Group reference.
*/
void setGroup(std11::shared_ptr<audio::river::io::Group> _group) {
void setGroup(std::shared_ptr<audio::river::io::Group> _group) {
m_group = _group;
}
protected:
@@ -184,7 +182,7 @@ namespace audio {
* @brief If this iss an hardware interface we can have a resuest of the volume stage:
* @return pointer on the requested volume.
*/
const std11::shared_ptr<audio::drain::VolumeElement>& getVolume() {
const std::shared_ptr<audio::drain::VolumeElement>& getVolume() {
return m_volume;
}
public:
@@ -222,5 +220,3 @@ namespace audio {
}
}
#endif

66
audio/river/io/NodeAEC.cpp
View File

@@ -7,26 +7,26 @@
#include <audio/river/io/NodeAEC.h>
#include <audio/river/debug.h>
#include <etk/types.h>
#include <etk/memory.h>
#include <etk/functional.h>
#include <memory>
#include <functional>
#undef __class__
#define __class__ "io::NodeAEC"
std11::shared_ptr<audio::river::io::NodeAEC> audio::river::io::NodeAEC::create(const std::string& _name, const std11::shared_ptr<const ejson::Object>& _config) {
return std11::shared_ptr<audio::river::io::NodeAEC>(new audio::river::io::NodeAEC(_name, _config));
std::shared_ptr<audio::river::io::NodeAEC> audio::river::io::NodeAEC::create(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config) {
return std::shared_ptr<audio::river::io::NodeAEC>(new audio::river::io::NodeAEC(_name, _config));
}
std11::shared_ptr<audio::river::Interface> audio::river::io::NodeAEC::createInput(float _freq,
std::shared_ptr<audio::river::Interface> audio::river::io::NodeAEC::createInput(float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std::string& _objectName,
const std::string& _name) {
// check if the output exist
const std11::shared_ptr<const ejson::Object> tmppp = m_config->getObject(_objectName);
const std::shared_ptr<const ejson::Object> tmppp = m_config->getObject(_objectName);
if (tmppp == nullptr) {
RIVER_ERROR("can not open a non existance virtual interface: '" << _objectName << "' not present in : " << m_config->getKeys());
return std11::shared_ptr<audio::river::Interface>();
return std::shared_ptr<audio::river::Interface>();
}
std::string streamName = tmppp->getStringValue("map-on", "error");
@@ -36,14 +36,14 @@ std11::shared_ptr<audio::river::Interface> audio::river::io::NodeAEC::createInpu
if ( type != "input"
&& type != "feedback") {
RIVER_ERROR("can not open in output a virtual interface: '" << streamName << "' configured has : " << type);
return std11::shared_ptr<audio::river::Interface>();
return std::shared_ptr<audio::river::Interface>();
}
// get global hardware interface:
std11::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
std::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
// get the output or input channel :
std11::shared_ptr<audio::river::io::Node> node = manager->getNode(streamName);
std::shared_ptr<audio::river::io::Node> node = manager->getNode(streamName);
// create user iterface:
std11::shared_ptr<audio::river::Interface> interface;
std::shared_ptr<audio::river::Interface> interface;
interface = audio::river::Interface::create(_freq, _map, _format, node, tmppp);
if (interface != nullptr) {
interface->setName(_name);
@@ -52,7 +52,7 @@ std11::shared_ptr<audio::river::Interface> audio::river::io::NodeAEC::createInpu
}
audio::river::io::NodeAEC::NodeAEC(const std::string& _name, const std11::shared_ptr<const ejson::Object>& _config) :
audio::river::io::NodeAEC::NodeAEC(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config) :
Node(_name, _config),
m_P_attaqueTime(1),
m_P_releaseTime(100),
@@ -106,28 +106,28 @@ audio::river::io::NodeAEC::NodeAEC(const std::string& _name, const std11::shared
}
// set callback mode ...
m_interfaceFeedBack->setInputCallback(std11::bind(&audio::river::io::NodeAEC::onDataReceivedFeedBack,
m_interfaceFeedBack->setInputCallback(std::bind(&audio::river::io::NodeAEC::onDataReceivedFeedBack,
this,
std11::placeholders::_1,
std11::placeholders::_2,
std11::placeholders::_3,
std11::placeholders::_4,
std11::placeholders::_5,
std11::placeholders::_6));
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6));
// set callback mode ...
m_interfaceMicrophone->setInputCallback(std11::bind(&audio::river::io::NodeAEC::onDataReceivedMicrophone,
m_interfaceMicrophone->setInputCallback(std::bind(&audio::river::io::NodeAEC::onDataReceivedMicrophone,
this,
std11::placeholders::_1,
std11::placeholders::_2,
std11::placeholders::_3,
std11::placeholders::_4,
std11::placeholders::_5,
std11::placeholders::_6));
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6));
m_bufferMicrophone.setCapacity(std11::chrono::milliseconds(1000),
m_bufferMicrophone.setCapacity(std::chrono::milliseconds(1000),
audio::getFormatBytes(hardwareFormat.getFormat())*hardwareFormat.getMap().size(),
hardwareFormat.getFrequency());
m_bufferFeedBack.setCapacity(std11::chrono::milliseconds(1000),
m_bufferFeedBack.setCapacity(std::chrono::milliseconds(1000),
audio::getFormatBytes(hardwareFormat.getFormat()), // only one channel ...
hardwareFormat.getFrequency());
@@ -142,7 +142,7 @@ audio::river::io::NodeAEC::~NodeAEC() {
};
void audio::river::io::NodeAEC::start() {
std11::unique_lock<std11::mutex> lock(m_mutex);
std::unique_lock<std::mutex> lock(m_mutex);
RIVER_INFO("Start stream : '" << m_name << "' mode=" << (m_isInput?"input":"output") );
if (m_interfaceFeedBack != nullptr) {
RIVER_INFO("Start FEEDBACK : ");
@@ -155,7 +155,7 @@ void audio::river::io::NodeAEC::start() {
}
void audio::river::io::NodeAEC::stop() {
std11::unique_lock<std11::mutex> lock(m_mutex);
std::unique_lock<std::mutex> lock(m_mutex);
if (m_interfaceFeedBack != nullptr) {
m_interfaceFeedBack->stop();
}
@@ -177,7 +177,7 @@ void audio::river::io::NodeAEC::onDataReceivedMicrophone(const void* _data,
RIVER_ERROR("call wrong type ... (need int16_t)");
}
// push data synchronize
std11::unique_lock<std11::mutex> lock(m_mutex);
std::unique_lock<std::mutex> lock(m_mutex);
m_bufferMicrophone.write(_data, _nbChunk, _time);
//RIVER_SAVE_FILE_MACRO(int16_t, "REC_Microphone.raw", _data, _nbChunk*_map.size());
process();
@@ -195,7 +195,7 @@ void audio::river::io::NodeAEC::onDataReceivedFeedBack(const void* _data,
RIVER_ERROR("call wrong type ... (need int16_t)");
}
// push data synchronize
std11::unique_lock<std11::mutex> lock(m_mutex);
std::unique_lock<std::mutex> lock(m_mutex);
m_bufferFeedBack.write(_data, _nbChunk, _time);
//RIVER_SAVE_FILE_MACRO(int16_t, "REC_FeedBack.raw", _data, _nbChunk*_map.size());
process();
@@ -346,7 +346,7 @@ void audio::river::io::NodeAEC::generateDot(etk::FSNode& _node) {
if (m_listAvaillable[iii].expired() == true) {
continue;
}
std11::shared_ptr<audio::river::Interface> element = m_listAvaillable[iii].lock();
std::shared_ptr<audio::river::Interface> element = m_listAvaillable[iii].lock();
if (element == nullptr) {
continue;
}

16
audio/river/io/NodeAEC.h
View File

@@ -3,9 +3,7 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#ifndef __AUDIO_RIVER_IO_NODE_AEC_H__
#define __AUDIO_RIVER_IO_NODE_AEC_H__
#pragma once
#include <audio/river/io/Node.h>
#include <audio/river/Interface.h>
@@ -20,14 +18,14 @@ namespace audio {
/**
* @brief Constructor
*/
NodeAEC(const std::string& _name, const std11::shared_ptr<const ejson::Object>& _config);
NodeAEC(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config);
public:
/**
* @brief Factory of this Virtual Node.
* @param[in] _name Name of the node.
* @param[in] _config Configuration of the node.
*/
static std11::shared_ptr<NodeAEC> create(const std::string& _name, const std11::shared_ptr<const ejson::Object>& _config);
static std::shared_ptr<NodeAEC> create(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config);
/**
* @brief Destructor
*/
@@ -35,8 +33,8 @@ namespace audio {
protected:
virtual void start();
virtual void stop();
std11::shared_ptr<audio::river::Interface> m_interfaceMicrophone; //!< Interface on the Microphone.
std11::shared_ptr<audio::river::Interface> m_interfaceFeedBack; //!< Interface on the feedback of speaker.
std::shared_ptr<audio::river::Interface> m_interfaceMicrophone; //!< Interface on the Microphone.
std::shared_ptr<audio::river::Interface> m_interfaceFeedBack; //!< Interface on the feedback of speaker.
/**
* @brief Internal: create an input with the specific parameter:
* @param[in] _freq Frequency.
@@ -46,7 +44,7 @@ namespace audio {
* @param[in] _name
* @return Interfae Pointer.
*/
std11::shared_ptr<audio::river::Interface> createInput(float _freq,
std::shared_ptr<audio::river::Interface> createInput(float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std::string& _streamName,
@@ -106,5 +104,3 @@ namespace audio {
}
}
#endif

272
audio/river/io/NodeFile.cpp Normal file
View File

@@ -0,0 +1,272 @@
/** @file
* @author Edouard DUPIN
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#ifdef AUDIO_RIVER_BUILD_FILE
#include <audio/river/io/NodeFile.h>
#include <audio/river/debug.h>
#include <memory>
#undef __class__
#define __class__ "io::NodeFile"
int32_t audio::river::io::NodeFile::recordCallback(const void* _inputBuffer,
const audio::Time& _timeInput,
uint32_t _nbChunk,
const std::vector<audio::orchestra::status>& _status) {
std::unique_lock<std::mutex> lock(m_mutex);
// TODO : Manage status ...
RIVER_VERBOSE("data Input size request :" << _nbChunk << " [BEGIN] status=" << _status << " nbIO=" << m_list.size());
newInput(_inputBuffer, _nbChunk, _timeInput);
return 0;
}
int32_t audio::river::io::NodeFile::playbackCallback(void* _outputBuffer,
const audio::Time& _timeOutput,
uint32_t _nbChunk,
const std::vector<audio::orchestra::status>& _status) {
std::unique_lock<std::mutex> lock(m_mutex);
// TODO : Manage status ...
RIVER_VERBOSE("data Output size request :" << _nbChunk << " [BEGIN] status=" << _status << " nbIO=" << m_list.size());
newOutput(_outputBuffer, _nbChunk, _timeOutput);
return 0;
}
std::shared_ptr<audio::river::io::NodeFile> audio::river::io::NodeFile::create(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config) {
return std::shared_ptr<audio::river::io::NodeFile>(new audio::river::io::NodeFile(_name, _config));
}
audio::river::io::NodeFile::NodeFile(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config) :
Node(_name, _config) {
audio::drain::IOFormatInterface interfaceFormat = getInterfaceFormat();
audio::drain::IOFormatInterface hardwareFormat = getHarwareFormat();
/**
map-on:{ # select hardware interface and name
interface:"alsa", # interface : "alsa", "pulse", "core", ...
name:"default", # name of the interface
},
nb-chunk:1024 # number of chunk to open device (create the latency anf the frequency to call user)
*/
std::string typeInterface = audio::orchestra::type_undefined;
std::string streamName = "default";
const std::shared_ptr<const ejson::Object> tmpObject = m_config->getObject("map-on");
if (tmpObject == nullptr) {
RIVER_WARNING("missing node : 'map-on' ==> auto map : 'auto:default'");
} else {
typeInterface = tmpObject->getStringValue("interface", audio::orchestra::type_undefined);
if (typeInterface == "auto") {
typeInterface = audio::orchestra::type_undefined;
}
streamName = tmpObject->getStringValue("name", "default");
}
int32_t nbChunk = m_config->getNumberValue("nb-chunk", 1024);
// intanciate specific API ...
m_interface.instanciate(typeInterface);
m_interface.setName(_name);
// TODO : Check return ...
std::string type = m_config->getStringValue("type", "int16");
if (streamName == "") {
streamName = "default";
}
// search device ID :
RIVER_INFO("Open :");
RIVER_INFO(" m_streamName=" << streamName);
RIVER_INFO(" m_freq=" << hardwareFormat.getFrequency());
RIVER_INFO(" m_map=" << hardwareFormat.getMap());
RIVER_INFO(" m_format=" << hardwareFormat.getFormat());
RIVER_INFO(" m_isInput=" << m_isInput);
int32_t deviceId = -1;
/*
// TODO : Remove this from here (create an extern interface ...)
RIVER_INFO("Device list:");
for (int32_t iii=0; iii<m_interface.getDeviceCount(); ++iii) {
m_info = m_interface.getDeviceInfo(iii);
RIVER_INFO(" " << iii << " name :" << m_info.name);
m_info.display(2);
}
*/
// special case for default IO:
if (streamName == "default") {
if (m_isInput == true) {
deviceId = m_interface.getDefaultInputDevice();
} else {
deviceId = m_interface.getDefaultOutputDevice();
}
} else {
for (int32_t iii=0; iii<m_interface.getDeviceCount(); ++iii) {
m_info = m_interface.getDeviceInfo(iii);
if (m_info.name == streamName) {
RIVER_INFO(" Select ... id =" << iii);
deviceId = iii;
}
}
}
// TODO : Check if the devace with the specific name exist ...
/*
if (deviceId == -1) {
RIVER_ERROR("Can not find the " << streamName << " audio interface ... (use O default ...)");
deviceId = 0;
}
*/
// Open specific ID :
if (deviceId == -1) {
m_info = m_interface.getDeviceInfo(streamName);
} else {
m_info = m_interface.getDeviceInfo(deviceId);
}
// display property :
{
RIVER_INFO("Device " << deviceId << " - '" << streamName << "' property :");
m_info.display();
if (etk::isIn(hardwareFormat.getFormat(), m_info.nativeFormats) == false) {
if (type == "auto") {
if (etk::isIn(audio::format_int16, m_info.nativeFormats) == true) {
hardwareFormat.setFormat(audio::format_int16);
RIVER_INFO("auto set format: " << hardwareFormat.getFormat());
} else if (etk::isIn(audio::format_float, m_info.nativeFormats) == true) {
hardwareFormat.setFormat(audio::format_float);
RIVER_INFO("auto set format: " << hardwareFormat.getFormat());
} else if (etk::isIn(audio::format_int16_on_int32, m_info.nativeFormats) == true) {
hardwareFormat.setFormat(audio::format_int16_on_int32);
RIVER_INFO("auto set format: " << hardwareFormat.getFormat());
} else if (etk::isIn(audio::format_int24, m_info.nativeFormats) == true) {
hardwareFormat.setFormat(audio::format_int24);
RIVER_INFO("auto set format: " << hardwareFormat.getFormat());
} else if (m_info.nativeFormats.size() != 0) {
hardwareFormat.setFormat(m_info.nativeFormats[0]);
RIVER_INFO("auto set format: " << hardwareFormat.getFormat());
} else {
RIVER_CRITICAL("auto set format no element in the configuration: " << m_info.nativeFormats);
}
} else {
RIVER_CRITICAL("Can not manage input transforamtion: " << hardwareFormat.getFormat() << " not in " << m_info.nativeFormats);
}
}
if (etk::isIn(hardwareFormat.getFrequency(), m_info.sampleRates) == false) {
if (etk::isIn(48000, m_info.sampleRates) == true) {
hardwareFormat.setFrequency(48000);
RIVER_INFO("auto set frequency: " << hardwareFormat.getFrequency());
} else if (etk::isIn(44100, m_info.sampleRates) == true) {
hardwareFormat.setFrequency(44100);
RIVER_INFO("auto set frequency: " << hardwareFormat.getFrequency());
} else if (etk::isIn(32000, m_info.sampleRates) == true) {
hardwareFormat.setFrequency(32000);
RIVER_INFO("auto set frequency: " << hardwareFormat.getFrequency());
} else if (etk::isIn(16000, m_info.sampleRates) == true) {
hardwareFormat.setFrequency(16000);
RIVER_INFO("auto set frequency: " << hardwareFormat.getFrequency());
} else if (etk::isIn(8000, m_info.sampleRates) == true) {
hardwareFormat.setFrequency(8000);
RIVER_INFO("auto set frequency: " << hardwareFormat.getFrequency());
} else if (etk::isIn(96000, m_info.sampleRates) == true) {
hardwareFormat.setFrequency(96000);
RIVER_INFO("auto set frequency: " << hardwareFormat.getFrequency());
} else if (m_info.sampleRates.size() != 0) {
hardwareFormat.setFrequency(m_info.sampleRates[0]);
RIVER_INFO("auto set frequency: " << hardwareFormat.getFrequency() << "(first element in list) in " << m_info.sampleRates);
} else {
RIVER_CRITICAL("Can not manage input transforamtion:" << hardwareFormat.getFrequency() << " not in " << m_info.sampleRates);
}
interfaceFormat.setFrequency(hardwareFormat.getFrequency());
}
}
// open Audio device:
audio::orchestra::StreamParameters params;
params.deviceId = deviceId;
params.deviceName = streamName;
params.nChannels = hardwareFormat.getMap().size();
if (m_info.channels.size() < params.nChannels) {
RIVER_CRITICAL("Can not open hardware device with more channel (" << params.nChannels << ") that is autorized by hardware (" << m_info.channels.size() << ").");
}
audio::orchestra::StreamOptions option;
etk::from_string(option.mode, tmpObject->getStringValue("timestamp-mode", "soft"));
RIVER_DEBUG("interfaceFormat=" << interfaceFormat);
RIVER_DEBUG("hardwareFormat=" << hardwareFormat);
m_rtaudioFrameSize = nbChunk;
RIVER_INFO("Open output stream nbChannels=" << params.nChannels);
enum audio::orchestra::error err = audio::orchestra::error_none;
if (m_isInput == true) {
m_process.setInputConfig(hardwareFormat);
m_process.setOutputConfig(interfaceFormat);
err = m_interface.openStream(nullptr, &params,
hardwareFormat.getFormat(), hardwareFormat.getFrequency(), &m_rtaudioFrameSize,
std::bind(&audio::river::io::NodeFile::recordCallback,
this,
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_5,
std::placeholders::_6),
option
);
} else {
m_process.setInputConfig(interfaceFormat);
m_process.setOutputConfig(hardwareFormat);
err = m_interface.openStream(&params, nullptr,
hardwareFormat.getFormat(), hardwareFormat.getFrequency(), &m_rtaudioFrameSize,
std::bind(&audio::river::io::NodeFile::playbackCallback,
this,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6),
option
);
}
if (err != audio::orchestra::error_none) {
RIVER_ERROR("Create stream : '" << m_name << "' mode=" << (m_isInput?"input":"output") << " can not create stream " << err);
}
m_process.updateInterAlgo();
}
audio::river::io::NodeFile::~NodeFile() {
std::unique_lock<std::mutex> lock(m_mutex);
RIVER_INFO("close input stream");
if (m_interface.isStreamOpen() ) {
m_interface.closeStream();
}
};
void audio::river::io::NodeFile::threadCallback() {
etk::thread::setName("RIVER file-IO");
// open the file
while (m_alive == true) {
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
void audio::river::io::NodeFile::start() {
std::unique_lock<std::mutex> lock(m_mutex);
if (m_thread != nullptr) {
RIVER_ERROR("Start stream : '" << m_name << "' mode=" << (m_isInput?"read":"write") << " ==> already started ..." );
return;
}
m_alive = true;
RIVER_INFO("Start stream : '" << m_name << "' mode=" << (m_isInput?"read":"write") );
m_thread = std::make_shared<std::thread>(&audio::river::io::NodeFile::threadCallback2, this);
m_time = audio::Time::now();
}
void audio::river::io::NodeFile::stop() {
std::unique_lock<std::mutex> lock(m_mutex);
m_alive = false;
RIVER_INFO("Stop stream : '" << m_name << "' mode=" << (m_isInput?"read":"write") );
// TODO : Need join ...
m_thread->join();
m_thread.reset();
}
#endif

54
audio/river/io/NodeFile.h Normal file
View File

@@ -0,0 +1,54 @@
/** @file
* @author Edouard DUPIN
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#pragma once
#ifdef AUDIO_RIVER_BUILD_FILE
#include <audio/river/io/Node.h>
#include <audio/orchestra/Interface.h>
namespace audio {
namespace river {
namespace io {
class Manager;
class Group;
/**
* @brief Low level node that is manage on the interface with the extern lib airtaudio
*/
class NodeFile : public audio::river::io::Node {
friend class audio::river::io::Group;
protected:
/**
* @brief Constructor
*/
NodeFile(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config);
public:
static std::shared_ptr<NodeFile> create(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config);
/**
* @brief Destructor
*/
virtual ~NodeFile();
virtual bool isHarwareNode() {
return true;
};
protected:
audio::Time m_time; //!< time of the flow
etk::FSNode m_file; //!< File interface
bool m_restartAtEnd; //!< The read is done in loop
uint32_t m_sampleRate; //!< Sample Rate of the Raw file
audio::format m_format; //!< Format of the file
std::vector<audio::channel> m_map; //!< Map of the file
std::shared_ptr<std::thread> m_thread; //!< playing thread of the flow
std::atomic<bool> m_alive; //!< thread is active
protected:
virtual void start();
virtual void stop();
virtual void threadCallback():
};
}
}
}
#endif

68
audio/river/io/NodeMuxer.cpp
View File

@@ -7,26 +7,26 @@
#include <audio/river/io/NodeMuxer.h>
#include <audio/river/debug.h>
#include <etk/types.h>
#include <etk/memory.h>
#include <etk/functional.h>
#include <memory>
#include <functional>
#undef __class__
#define __class__ "io::NodeMuxer"
std11::shared_ptr<audio::river::io::NodeMuxer> audio::river::io::NodeMuxer::create(const std::string& _name, const std11::shared_ptr<const ejson::Object>& _config) {
return std11::shared_ptr<audio::river::io::NodeMuxer>(new audio::river::io::NodeMuxer(_name, _config));
std::shared_ptr<audio::river::io::NodeMuxer> audio::river::io::NodeMuxer::create(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config) {
return std::shared_ptr<audio::river::io::NodeMuxer>(new audio::river::io::NodeMuxer(_name, _config));
}
std11::shared_ptr<audio::river::Interface> audio::river::io::NodeMuxer::createInput(float _freq,
std::shared_ptr<audio::river::Interface> audio::river::io::NodeMuxer::createInput(float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std::string& _objectName,
const std::string& _name) {
// check if the output exist
const std11::shared_ptr<const ejson::Object> tmppp = m_config->getObject(_objectName);
const std::shared_ptr<const ejson::Object> tmppp = m_config->getObject(_objectName);
if (tmppp == nullptr) {
RIVER_ERROR("can not open a non existance virtual interface: '" << _objectName << "' not present in : " << m_config->getKeys());
return std11::shared_ptr<audio::river::Interface>();
return std::shared_ptr<audio::river::Interface>();
}
std::string streamName = tmppp->getStringValue("map-on", "error");
@@ -36,14 +36,14 @@ std11::shared_ptr<audio::river::Interface> audio::river::io::NodeMuxer::createIn
if ( type != "input"
&& type != "feedback") {
RIVER_ERROR("can not open in output a virtual interface: '" << streamName << "' configured has : " << type);
return std11::shared_ptr<audio::river::Interface>();
return std::shared_ptr<audio::river::Interface>();
}
// get global hardware interface:
std11::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
std::shared_ptr<audio::river::io::Manager> manager = audio::river::io::Manager::getInstance();
// get the output or input channel :
std11::shared_ptr<audio::river::io::Node> node = manager->getNode(streamName);
std::shared_ptr<audio::river::io::Node> node = manager->getNode(streamName);
// create user iterface:
std11::shared_ptr<audio::river::Interface> interface;
std::shared_ptr<audio::river::Interface> interface;
interface = audio::river::Interface::create(_freq, _map, _format, node, tmppp);
if (interface != nullptr) {
interface->setName(_name);
@@ -52,7 +52,7 @@ std11::shared_ptr<audio::river::Interface> audio::river::io::NodeMuxer::createIn
}
audio::river::io::NodeMuxer::NodeMuxer(const std::string& _name, const std11::shared_ptr<const ejson::Object>& _config) :
audio::river::io::NodeMuxer::NodeMuxer(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config) :
Node(_name, _config) {
audio::drain::IOFormatInterface interfaceFormat = getInterfaceFormat();
audio::drain::IOFormatInterface hardwareFormat = getHarwareFormat();
@@ -88,7 +88,7 @@ audio::river::io::NodeMuxer::NodeMuxer(const std::string& _name, const std11::sh
RIVER_ERROR("Can not opne virtual device ... map-on-input-1 in " << _name);
return;
}
std11::shared_ptr<const ejson::Array> listChannelMap = m_config->getArray("input-1-remap");
std::shared_ptr<const ejson::Array> listChannelMap = m_config->getArray("input-1-remap");
if ( listChannelMap == nullptr
|| listChannelMap->size() == 0) {
m_mapInput1 = m_interfaceInput1->getInterfaceFormat().getMap();
@@ -131,28 +131,28 @@ audio::river::io::NodeMuxer::NodeMuxer(const std::string& _name, const std11::sh
}
// set callback mode ...
m_interfaceInput1->setInputCallback(std11::bind(&audio::river::io::NodeMuxer::onDataReceivedInput1,
m_interfaceInput1->setInputCallback(std::bind(&audio::river::io::NodeMuxer::onDataReceivedInput1,
this,
std11::placeholders::_1,
std11::placeholders::_2,
std11::placeholders::_3,
std11::placeholders::_4,
std11::placeholders::_5,
std11::placeholders::_6));
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6));
// set callback mode ...
m_interfaceInput2->setInputCallback(std11::bind(&audio::river::io::NodeMuxer::onDataReceivedInput2,
m_interfaceInput2->setInputCallback(std::bind(&audio::river::io::NodeMuxer::onDataReceivedInput2,
this,
std11::placeholders::_1,
std11::placeholders::_2,
std11::placeholders::_3,
std11::placeholders::_4,
std11::placeholders::_5,
std11::placeholders::_6));
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6));
m_bufferInput1.setCapacity(std11::chrono::milliseconds(1000),
m_bufferInput1.setCapacity(std::chrono::milliseconds(1000),
audio::getFormatBytes(hardwareFormat.getFormat())*m_mapInput1.size(),
hardwareFormat.getFrequency());
m_bufferInput2.setCapacity(std11::chrono::milliseconds(1000),
m_bufferInput2.setCapacity(std::chrono::milliseconds(1000),
audio::getFormatBytes(hardwareFormat.getFormat())*m_mapInput2.size(),
hardwareFormat.getFrequency());
@@ -167,7 +167,7 @@ audio::river::io::NodeMuxer::~NodeMuxer() {
};
void audio::river::io::NodeMuxer::start() {
std11::unique_lock<std11::mutex> lock(m_mutex);
std::unique_lock<std::mutex> lock(m_mutex);
RIVER_INFO("Start stream : '" << m_name << "' mode=" << (m_isInput?"input":"output") );
if (m_interfaceInput1 != nullptr) {
RIVER_INFO("Start FEEDBACK : ");
@@ -180,7 +180,7 @@ void audio::river::io::NodeMuxer::start() {
}
void audio::river::io::NodeMuxer::stop() {
std11::unique_lock<std11::mutex> lock(m_mutex);
std::unique_lock<std::mutex> lock(m_mutex);
if (m_interfaceInput1 != nullptr) {
m_interfaceInput1->stop();
}
@@ -202,7 +202,7 @@ void audio::river::io::NodeMuxer::onDataReceivedInput1(const void* _data,
RIVER_ERROR("call wrong type ... (need int16_t)");
}
// push data synchronize
std11::unique_lock<std11::mutex> lock(m_mutex);
std::unique_lock<std::mutex> lock(m_mutex);
m_bufferInput1.write(_data, _nbChunk, _time);
//RIVER_SAVE_FILE_MACRO(int16_t, "REC_Microphone.raw", _data, _nbChunk*_map.size());
process();
@@ -220,7 +220,7 @@ void audio::river::io::NodeMuxer::onDataReceivedInput2(const void* _data,
RIVER_ERROR("call wrong type ... (need int16_t)");
}
// push data synchronize
std11::unique_lock<std11::mutex> lock(m_mutex);
std::unique_lock<std::mutex> lock(m_mutex);
m_bufferInput2.write(_data, _nbChunk, _time);
//RIVER_SAVE_FILE_MACRO(int16_t, "REC_FeedBack.raw", _data, _nbChunk*_map.size());
process();
@@ -460,7 +460,7 @@ void audio::river::io::NodeMuxer::generateDot(etk::FSNode& _node) {
if (m_listAvaillable[iii].expired() == true) {
continue;
}
std11::shared_ptr<audio::river::Interface> element = m_listAvaillable[iii].lock();
std::shared_ptr<audio::river::Interface> element = m_listAvaillable[iii].lock();
if (element == nullptr) {
continue;
}

16
audio/river/io/NodeMuxer.h
View File

@@ -3,9 +3,7 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#ifndef __AUDIO_RIVER_IO_NODE_MUXER_H__
#define __AUDIO_RIVER_IO_NODE_MUXER_H__
#pragma once
#include <audio/river/io/Node.h>
#include <audio/river/Interface.h>
@@ -20,9 +18,9 @@ namespace audio {
/**
* @brief Constructor
*/
NodeMuxer(const std::string& _name, const std11::shared_ptr<const ejson::Object>& _config);
NodeMuxer(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config);
public:
static std11::shared_ptr<NodeMuxer> create(const std::string& _name, const std11::shared_ptr<const ejson::Object>& _config);
static std::shared_ptr<NodeMuxer> create(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config);
/**
* @brief Destructor
*/
@@ -30,9 +28,9 @@ namespace audio {
protected:
virtual void start();
virtual void stop();
std11::shared_ptr<audio::river::Interface> m_interfaceInput1;
std11::shared_ptr<audio::river::Interface> m_interfaceInput2;
std11::shared_ptr<audio::river::Interface> createInput(float _freq,
std::shared_ptr<audio::river::Interface> m_interfaceInput1;
std::shared_ptr<audio::river::Interface> m_interfaceInput2;
std::shared_ptr<audio::river::Interface> createInput(float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std::string& _streamName,
@@ -66,5 +64,3 @@ namespace audio {
}
}
#endif

40
audio/river/io/NodeOrchestra.cpp
View File

@@ -8,7 +8,7 @@
#include <audio/river/io/NodeOrchestra.h>
#include <audio/river/debug.h>
#include <etk/memory.h>
#include <memory>
#undef __class__
#define __class__ "io::NodeOrchestra"
@@ -17,7 +17,7 @@ int32_t audio::river::io::NodeOrchestra::recordCallback(const void* _inputBuffer
const audio::Time& _timeInput,
uint32_t _nbChunk,
const std::vector<audio::orchestra::status>& _status) {
std11::unique_lock<std11::mutex> lock(m_mutex);
std::unique_lock<std::mutex> lock(m_mutex);
// TODO : Manage status ...
RIVER_VERBOSE("data Input size request :" << _nbChunk << " [BEGIN] status=" << _status << " nbIO=" << m_list.size());
newInput(_inputBuffer, _nbChunk, _timeInput);
@@ -28,7 +28,7 @@ int32_t audio::river::io::NodeOrchestra::playbackCallback(void* _outputBuffer,
const audio::Time& _timeOutput,
uint32_t _nbChunk,
const std::vector<audio::orchestra::status>& _status) {
std11::unique_lock<std11::mutex> lock(m_mutex);
std::unique_lock<std::mutex> lock(m_mutex);
// TODO : Manage status ...
RIVER_VERBOSE("data Output size request :" << _nbChunk << " [BEGIN] status=" << _status << " nbIO=" << m_list.size());
newOutput(_outputBuffer, _nbChunk, _timeOutput);
@@ -37,11 +37,11 @@ int32_t audio::river::io::NodeOrchestra::playbackCallback(void* _outputBuffer,
std11::shared_ptr<audio::river::io::NodeOrchestra> audio::river::io::NodeOrchestra::create(const std::string& _name, const std11::shared_ptr<const ejson::Object>& _config) {
return std11::shared_ptr<audio::river::io::NodeOrchestra>(new audio::river::io::NodeOrchestra(_name, _config));
std::shared_ptr<audio::river::io::NodeOrchestra> audio::river::io::NodeOrchestra::create(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config) {
return std::shared_ptr<audio::river::io::NodeOrchestra>(new audio::river::io::NodeOrchestra(_name, _config));
}
audio::river::io::NodeOrchestra::NodeOrchestra(const std::string& _name, const std11::shared_ptr<const ejson::Object>& _config) :
audio::river::io::NodeOrchestra::NodeOrchestra(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config) :
Node(_name, _config) {
audio::drain::IOFormatInterface interfaceFormat = getInterfaceFormat();
audio::drain::IOFormatInterface hardwareFormat = getHarwareFormat();
@@ -54,7 +54,7 @@ audio::river::io::NodeOrchestra::NodeOrchestra(const std::string& _name, const s
*/
std::string typeInterface = audio::orchestra::type_undefined;
std::string streamName = "default";
const std11::shared_ptr<const ejson::Object> tmpObject = m_config->getObject("map-on");
const std::shared_ptr<const ejson::Object> tmpObject = m_config->getObject("map-on");
if (tmpObject == nullptr) {
RIVER_WARNING("missing node : 'map-on' ==> auto map : 'auto:default'");
} else {
@@ -202,12 +202,12 @@ audio::river::io::NodeOrchestra::NodeOrchestra(const std::string& _name, const s
m_process.setOutputConfig(interfaceFormat);
err = m_interface.openStream(nullptr, &params,
hardwareFormat.getFormat(), hardwareFormat.getFrequency(), &m_rtaudioFrameSize,
std11::bind(&audio::river::io::NodeOrchestra::recordCallback,
std::bind(&audio::river::io::NodeOrchestra::recordCallback,
this,
std11::placeholders::_1,
std11::placeholders::_2,
std11::placeholders::_5,
std11::placeholders::_6),
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_5,
std::placeholders::_6),
option
);
} else {
@@ -215,12 +215,12 @@ audio::river::io::NodeOrchestra::NodeOrchestra(const std::string& _name, const s
m_process.setOutputConfig(hardwareFormat);
err = m_interface.openStream(&params, nullptr,
hardwareFormat.getFormat(), hardwareFormat.getFrequency(), &m_rtaudioFrameSize,
std11::bind(&audio::river::io::NodeOrchestra::playbackCallback,
std::bind(&audio::river::io::NodeOrchestra::playbackCallback,
this,
std11::placeholders::_3,
std11::placeholders::_4,
std11::placeholders::_5,
std11::placeholders::_6),
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6),
option
);
}
@@ -231,7 +231,7 @@ audio::river::io::NodeOrchestra::NodeOrchestra(const std::string& _name, const s
}
audio::river::io::NodeOrchestra::~NodeOrchestra() {
std11::unique_lock<std11::mutex> lock(m_mutex);
std::unique_lock<std::mutex> lock(m_mutex);
RIVER_INFO("close input stream");
if (m_interface.isStreamOpen() ) {
m_interface.closeStream();
@@ -239,7 +239,7 @@ audio::river::io::NodeOrchestra::~NodeOrchestra() {
};
void audio::river::io::NodeOrchestra::start() {
std11::unique_lock<std11::mutex> lock(m_mutex);
std::unique_lock<std::mutex> lock(m_mutex);
RIVER_INFO("Start stream : '" << m_name << "' mode=" << (m_isInput?"input":"output") );
enum audio::orchestra::error err = m_interface.startStream();
if (err != audio::orchestra::error_none) {
@@ -248,7 +248,7 @@ void audio::river::io::NodeOrchestra::start() {
}
void audio::river::io::NodeOrchestra::stop() {
std11::unique_lock<std11::mutex> lock(m_mutex);
std::unique_lock<std::mutex> lock(m_mutex);
RIVER_INFO("Stop stream : '" << m_name << "' mode=" << (m_isInput?"input":"output") );
enum audio::orchestra::error err = m_interface.stopStream();
if (err != audio::orchestra::error_none) {

11
audio/river/io/NodeOrchestra.h
View File

@@ -3,9 +3,7 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#ifndef __AUDIO_RIVER_IO_NODE_AIRTAUDIO_H__
#define __AUDIO_RIVER_IO_NODE_AIRTAUDIO_H__
#pragma once
#ifdef AUDIO_RIVER_BUILD_ORCHESTRA
@@ -26,9 +24,9 @@ namespace audio {
/**
* @brief Constructor
*/
NodeOrchestra(const std::string& _name, const std11::shared_ptr<const ejson::Object>& _config);
NodeOrchestra(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config);
public:
static std11::shared_ptr<NodeOrchestra> create(const std::string& _name, const std11::shared_ptr<const ejson::Object>& _config);
static std::shared_ptr<NodeOrchestra> create(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config);
/**
* @brief Destructor
*/
@@ -73,6 +71,3 @@ namespace audio {
}
}
#endif
#endif

18
audio/river/io/NodePortAudio.cpp
View File

@@ -8,7 +8,7 @@
#include <audio/river/io/NodePortAudio.h>
#include <audio/river/debug.h>
#include <etk/memory.h>
#include <memory>
#include <audio/Time.h>
#include <audio/Duration.h>
@@ -42,7 +42,7 @@ int32_t audio::river::io::NodePortAudio::duplexCallback(const void* _inputBuffer
const audio::Time& _timeOutput,
uint32_t _nbChunk,
PaStreamCallbackFlags _status) {
std11::unique_lock<std11::mutex> lock(m_mutex);
std::unique_lock<std::mutex> lock(m_mutex);
// TODO : Manage status ...
if (_inputBuffer != nullptr) {
RIVER_VERBOSE("data Input size request :" << _nbChunk << " [BEGIN] status=" << _status << " nbIO=" << m_list.size());
@@ -56,11 +56,11 @@ int32_t audio::river::io::NodePortAudio::duplexCallback(const void* _inputBuffer
}
std11::shared_ptr<audio::river::io::NodePortAudio> audio::river::io::NodePortAudio::create(const std::string& _name, const std11::shared_ptr<const ejson::Object>& _config) {
return std11::shared_ptr<audio::river::io::NodePortAudio>(new audio::river::io::NodePortAudio(_name, _config));
std::shared_ptr<audio::river::io::NodePortAudio> audio::river::io::NodePortAudio::create(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config) {
return std::shared_ptr<audio::river::io::NodePortAudio>(new audio::river::io::NodePortAudio(_name, _config));
}
audio::river::io::NodePortAudio::NodePortAudio(const std::string& _name, const std11::shared_ptr<const ejson::Object>& _config) :
audio::river::io::NodePortAudio::NodePortAudio(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config) :
Node(_name, _config) {
audio::drain::IOFormatInterface interfaceFormat = getInterfaceFormat();
audio::drain::IOFormatInterface hardwareFormat = getHarwareFormat();
@@ -72,7 +72,7 @@ audio::river::io::NodePortAudio::NodePortAudio(const std::string& _name, const s
nb-chunk:1024 # number of chunk to open device (create the latency anf the frequency to call user)
*/
std::string streamName = "default";
const std11::shared_ptr<const ejson::Object> tmpObject = m_config->getObject("map-on");
const std::shared_ptr<const ejson::Object> tmpObject = m_config->getObject("map-on");
if (tmpObject == nullptr) {
RIVER_WARNING("missing node : 'map-on' ==> auto map : 'auto:default'");
} else {
@@ -108,7 +108,7 @@ audio::river::io::NodePortAudio::NodePortAudio(const std::string& _name, const s
}
audio::river::io::NodePortAudio::~NodePortAudio() {
std11::unique_lock<std11::mutex> lock(m_mutex);
std::unique_lock<std::mutex> lock(m_mutex);
RIVER_INFO("close input stream");
PaError err = Pa_CloseStream( m_stream );
if( err != paNoError ) {
@@ -117,7 +117,7 @@ audio::river::io::NodePortAudio::~NodePortAudio() {
};
void audio::river::io::NodePortAudio::start() {
std11::unique_lock<std11::mutex> lock(m_mutex);
std::unique_lock<std::mutex> lock(m_mutex);
RIVER_INFO("Start stream : '" << m_name << "' mode=" << (m_isInput?"input":"output") );
PaError err = Pa_StartStream(m_stream);
if( err != paNoError ) {
@@ -126,7 +126,7 @@ void audio::river::io::NodePortAudio::start() {
}
void audio::river::io::NodePortAudio::stop() {
std11::unique_lock<std11::mutex> lock(m_mutex);
std::unique_lock<std::mutex> lock(m_mutex);
RIVER_INFO("Stop stream : '" << m_name << "' mode=" << (m_isInput?"input":"output") );
PaError err = Pa_StopStream(m_stream);
if( err != paNoError ) {

12
audio/river/io/NodePortAudio.h
View File

@@ -3,15 +3,13 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#ifndef __AUDIO_RIVER_IO_NODE_PORTAUDIO_H__
#define __AUDIO_RIVER_IO_NODE_PORTAUDIO_H__
#pragma once
#ifdef AUDIO_RIVER_BUILD_PORTAUDIO
#include <audio/river/Interface.h>
#include <audio/river/io/Node.h>
#include <portaudio.h>
#include <portaudio/portaudio.h>
namespace audio {
namespace river {
@@ -23,9 +21,9 @@ namespace audio {
/**
* @brief Constructor
*/
NodePortAudio(const std::string& _name, const std11::shared_ptr<const ejson::Object>& _config);
NodePortAudio(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config);
public:
static std11::shared_ptr<NodePortAudio> create(const std::string& _name, const std11::shared_ptr<const ejson::Object>& _config);
static std::shared_ptr<NodePortAudio> create(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config);
/**
* @brief Destructor
*/
@@ -51,5 +49,3 @@ namespace audio {
}
#endif
#endif

6
audio/river/river.cpp
View File

@@ -18,7 +18,7 @@ void audio::river::init(const std::string& _filename) {
river_isInit = true;
river_configFile = _filename;
RIVER_DEBUG("init RIVER :" << river_configFile);
std11::shared_ptr<audio::river::io::Manager> mng = audio::river::io::Manager::getInstance();
std::shared_ptr<audio::river::io::Manager> mng = audio::river::io::Manager::getInstance();
if (mng != nullptr) {
mng->init(river_configFile);
}
@@ -32,7 +32,7 @@ void audio::river::initString(const std::string& _config) {
river_isInit = true;
river_configFile = _config;
RIVER_DEBUG("init RIVER with config.");
std11::shared_ptr<audio::river::io::Manager> mng = audio::river::io::Manager::getInstance();
std::shared_ptr<audio::river::io::Manager> mng = audio::river::io::Manager::getInstance();
if (mng != nullptr) {
mng->initString(river_configFile);
}
@@ -45,7 +45,7 @@ void audio::river::unInit() {
if (river_isInit == true) {
river_isInit = false;
RIVER_DEBUG("un-init RIVER.");
std11::shared_ptr<audio::river::io::Manager> mng = audio::river::io::Manager::getInstance();
std::shared_ptr<audio::river::io::Manager> mng = audio::river::io::Manager::getInstance();
if (mng != nullptr) {
RIVER_ERROR("Can not get on the RIVER hardware manager !!!");
mng->unInit();

6
audio/river/river.h
View File

@@ -3,9 +3,7 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#ifndef __AUDIO_RIVER_H__
#define __AUDIO_RIVER_H__
#pragma once
#include <etk/types.h>
@@ -36,5 +34,3 @@ namespace audio {
}
}
#endif

0
lutinParseSubFolders.txt Normal file
View File

31
lutin_audio-river-test.py
View File

@@ -2,17 +2,34 @@
import lutin.module as module
import lutin.tools as tools
def get_type():
return "BINARY"
def get_sub_type():
return "TEST"
def get_desc():
return "Multi-nodal audio interface test"
def get_licence():
return "APACHE-2"
def create(target):
myModule = module.Module(__file__, 'audio-river-test', 'BINARY')
myModule.add_src_file([
'test/main.cpp',
'test/debug.cpp'
def get_compagny_type():
return "com"
def get_compagny_name():
return "atria-soft"
def get_maintainer():
return ["Mr DUPIN Edouard <yui.heero@gmail.com>"]
def create(target, module_name):
my_module = module.Module(__file__, module_name, get_type())
my_module.add_src_file([
'test/main.cpp'
])
myModule.add_module_depend(['audio-river', 'gtest', 'etk'])
return myModule
my_module.add_module_depend(['audio-river', 'gtest', 'etk', 'test-debug'])
return my_module

43
lutin_audio-river.py
View File

@@ -2,14 +2,31 @@
import lutin.module as module
import lutin.tools as tools
def get_type():
return "LIBRARY"
def get_desc():
return "Multi-nodal audio interface"
def get_licence():
return "APACHE-2"
def create(target):
myModule = module.Module(__file__, 'audio-river', 'LIBRARY')
def get_compagny_type():
return "com"
myModule.add_src_file([
def get_compagny_name():
return "atria-soft"
def get_maintainer():
return ["Mr DUPIN Edouard <yui.heero@gmail.com>"]
def get_version():
return [0,0,0]
def create(target, module_name):
my_module = module.Module(__file__, module_name, get_type())
my_module.add_src_file([
'audio/river/debug.cpp',
'audio/river/river.cpp',
'audio/river/Manager.cpp',
@@ -22,13 +39,19 @@ def create(target):
'audio/river/io/NodeMuxer.cpp',
'audio/river/io/Manager.cpp'
])
myModule.add_optionnal_module_depend('audio-orchestra', ["c++", "-DAUDIO_RIVER_BUILD_ORCHESTRA"])
myModule.add_optionnal_module_depend('portaudio', ["c++", "-DAUDIO_RIVER_BUILD_PORTAUDIO"])
myModule.add_module_depend(['audio', 'audio-drain', 'ejson'])
myModule.add_export_path(tools.get_current_path(__file__))
# add the currrent module at the
return myModule
my_module.add_header_file([
'audio/river/river.h',
'audio/river/Manager.h',
'audio/river/Interface.h',
'audio/river/io/Group.h',
'audio/river/io/Node.h',
'audio/river/io/Manager.h'
])
my_module.add_optionnal_module_depend('audio-orchestra', ["c++", "-DAUDIO_RIVER_BUILD_ORCHESTRA"])
my_module.add_optionnal_module_depend('portaudio', ["c++", "-DAUDIO_RIVER_BUILD_PORTAUDIO"])
my_module.add_module_depend(['audio', 'audio-drain', 'ejson'])
my_module.add_path(tools.get_current_path(__file__))
return my_module

69
sample/ioViewer/appl/Windows.cpp Normal file
View File

@@ -0,0 +1,69 @@
/**
* @author Edouard DUPIN
*
* @copyright 2010, Edouard DUPIN, all right reserved
*
* @license BSD 3 clauses (see license file)
*/
#include <ewol/ewol.h>
#include <appl/debug.h>
#include <appl/Windows.h>
#include <ewol/widget/Label.h>
#include <ewol/widget/Button.h>
#include <audio/river/widget/TemporalViewer.h>
#include <etk/tool.h>
#undef __class__
#define __class__ "Windows"
appl::Windows::Windows() :
m_composer(nullptr) {
addObjectType("appl::Windows");
propertyTitle.setDirectCheck("River IO viewer");
}
void appl::Windows::init() {
ewol::widget::Windows::init();
std::string composition = std::string("");
composition += "<sizer mode='vert'>\n";
composition += " <sizer mode='hori' lock='true' min-size='10,10%'>\n";
composition += " <button name='bt-record' expend='true' fill='true'>\n";
composition += " <label>\n";
composition += " Start/Stop record\n";
composition += " </label>\n";
composition += " </button>\n";
composition += " <button name='bt-generate' expend='true' fill='true'>\n";
composition += " <label>\n";
composition += " Start/Stop Generate\n";
composition += " </label>\n";
composition += " </button>\n";
composition += " </sizer>\n";
composition += " <TemporalViewer name='displayer' expand='true' fill='true'/>\n";
composition += "</sizer>\n";
m_composer = ewol::widget::Composer::create();
if (m_composer == nullptr) {
APPL_CRITICAL(" An error occured ... in the windows creatrion ...");
return;
}
m_composer->loadFromString(composition);
setSubWidget(m_composer);
subBind(ewol::widget::Button, "bt-record", signalPressed, shared_from_this(), &appl::Windows::onCallbackRecord);
subBind(ewol::widget::Button, "bt-generate", signalPressed, shared_from_this(), &appl::Windows::onCallbackGenerate);
}
void appl::Windows::onCallbackRecord() {
std::shared_ptr<audio::river::widget::TemporalViewer> tmpDisp = std::dynamic_pointer_cast<audio::river::widget::TemporalViewer>(getSubObjectNamed("displayer"));
if (tmpDisp != nullptr) {
tmpDisp->recordToggle();
}
}
void appl::Windows::onCallbackGenerate() {
std::shared_ptr<audio::river::widget::TemporalViewer> tmpDisp = std::dynamic_pointer_cast<audio::river::widget::TemporalViewer>(getSubObjectNamed("displayer"));
if (tmpDisp != nullptr) {
tmpDisp->generateToggle();
}
}

27
sample/ioViewer/appl/Windows.h Normal file
View File

@@ -0,0 +1,27 @@
/**
* @author Edouard DUPIN
*
* @copyright 2010, Edouard DUPIN, all right reserved
*
* @license BSD 3 clauses (see license file)
*/
#pragma once
#include <ewol/widget/Windows.h>
#include <ewol/widget/Composer.h>
namespace appl {
class Windows : public ewol::widget::Windows {
private:
std::shared_ptr<ewol::widget::Composer> m_composer;
protected:
Windows();
void init();
public:
DECLARE_FACTORY(Windows);
public: // callback functions
void onCallbackRecord();
void onCallbackGenerate();
};
}

13
sample/ioViewer/appl/debug.cpp Normal file
View File

@@ -0,0 +1,13 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#include <appl/debug.h>
int32_t appl::getLogId() {
static int32_t g_val = elog::registerInstance("ioViewer");
return g_val;
}

20
test/debug.h → sample/ioViewer/appl/debug.h
View File

@@ -1,20 +1,17 @@
/**
/** @file
* @author Edouard DUPIN
*
* @copyright 2010, Edouard DUPIN, all right reserved
*
* @license GPL v3 (see license file)
* @copyright 2011, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#pragma once
#ifndef __APPL_DEBUG_H__
#define __APPL_DEBUG_H__
#include <etk/log.h>
#include <elog/log.h>
namespace appl {
int32_t getLogId();
};
#define APPL_BASE(info,data) TK_LOG_BASE(appl::getLogId(),info,data)
}
#define APPL_BASE(info,data) ELOG_BASE(appl::getLogId(),info,data)
#define APPL_PRINT(data) APPL_BASE(-1, data)
#define APPL_CRITICAL(data) APPL_BASE(1, data)
@@ -40,4 +37,3 @@ namespace appl {
} \
} while (0)
#endif

73
sample/ioViewer/appl/main.cpp Normal file
View File

@@ -0,0 +1,73 @@
/**
* @author Edouard DUPIN
*
* @copyright 2010, Edouard DUPIN, all right reserved
*
* @license BSD 3 clauses (see license file)
*/
#include <etk/types.h>
#include <ewol/ewol.h>
#include <gale/context/commandLine.h>
#include <appl/debug.h>
#include <appl/Windows.h>
#include <ewol/object/Object.h>
#include <ewol/widget/Manager.h>
#include <ewol/context/Context.h>
#include <audio/river/widget/TemporalViewer.h>
static const std::string configurationRiver =
"{\n"
" microphone:{\n"
" io:'input',\n"
" map-on:{\n"
" interface:'auto',\n"
" name:'default',\n"
" },\n"
" frequency:0,\n"
" channel-map:['front-left', 'front-right'],\n"
" type:'auto',\n"
" nb-chunk:1024\n"
" }\n"
"}\n";
class MainApplication : public ewol::context::Application {
public:
bool init(ewol::Context& _context, size_t _initId) {
APPL_INFO("==> Init APPL (START) [" << ewol::getBoardType() << "] (" << ewol::getCompilationMode() << ")");
audio::river::initString(configurationRiver);
_context.setSize(vec2(800, 600));
// select internal data for font ...
_context.getFontDefault().setUseExternal(true);
_context.getFontDefault().setSize(19);
audio::river::widget::TemporalViewer::createManagerWidget(_context.getWidgetManager());
std::shared_ptr<ewol::widget::Windows> basicWindows = appl::Windows::create();
// create the specific windows
_context.setWindows(basicWindows);
APPL_INFO("==> Init APPL (END)");
return true;
}
void unInit(ewol::Context& _context) {
APPL_INFO("==> Un-Init APPL (START)");
// nothing to do...
APPL_INFO("==> Un-Init APPL (END)");
}
};
/**
* @brief Main of the program (This can be set in every case, but it is not used in Andoid...).
* @param std IO
* @return std IO
*/
int main(int _argc, const char *_argv[]) {
// second possibility
return ewol::run(new MainApplication(), _argc, _argv);
}

48
sample/ioViewer/lutin_ioViewer.py Normal file
View File

@@ -0,0 +1,48 @@
#!/usr/bin/python
import lutin.module as module
import lutin.tools as tools
import datetime
import os
def get_type():
return "BINARY"
def get_desc():
return "Simpleaudio IO viewer and test ..."
def get_licence():
return "APACHE-2"
def get_compagny_type():
return "com"
def get_compagny_name():
return "atria-soft"
def get_maintainer():
return ["Mr DUPIN Edouard <yui.heero@gmail.com>"]
def create(target, module_name):
my_module = module.Module(__file__, module_name, get_type())
my_module.add_extra_compile_flags()
my_module.add_src_file([
'appl/debug.cpp',
'appl/main.cpp',
'appl/Windows.cpp'])
my_module.add_module_depend(['ewol', 'audio-river', 'audio-river-widget'])
my_module.add_path(tools.get_current_path(__file__))
# set the package properties :
my_module.pkg_set("VERSION", "1.0.0")
my_module.pkg_set("VERSION_CODE", "1")
my_module.pkg_set("COMPAGNY_TYPE", "org")
my_module.pkg_set("COMPAGNY_NAME", "Edouard DUPIN")
my_module.pkg_set("MAINTAINER", ["Mr DUPIN Edouard <yui.heero@gmail.com>"])
my_module.pkg_set("SECTION", ["Development"])
my_module.pkg_set("PRIORITY", "optional")
my_module.pkg_set("DESCRIPTION", "Simple wiewer")
my_module.pkg_set("NAME", "ioViewer")
my_module.pkg_add("RIGHT", "RECORD_AUDIO")
return my_module

28
sample/read/lutin_river-sample-read.py
View File

@@ -2,17 +2,35 @@
import lutin.module as module
import lutin.tools as tools
def get_type():
return "BINARY"
def get_sub_type():
return "SAMPLE"
def get_desc():
return "Read some data"
def get_licence():
return "APACHE-2"
def create(target):
myModule = module.Module(__file__, 'river-sample-read', 'BINARY')
myModule.add_src_file([
def get_compagny_type():
return "com"
def get_compagny_name():
return "atria-soft"
def get_maintainer():
return ["Mr DUPIN Edouard <yui.heero@gmail.com>"]
def create(target, module_name):
my_module = module.Module(__file__, module_name, get_type())
my_module.add_src_file([
'main.cpp',
])
myModule.add_module_depend(['audio-river', 'etk'])
return myModule
my_module.add_module_depend(['audio-river', 'etk'])
return my_module

18
sample/read/main.cpp
View File

@@ -88,9 +88,9 @@ int main(int _argc, const char **_argv) {
audio::river::init(configFile);
}
// Create the River manager for tha application or part of the application.
std11::shared_ptr<audio::river::Manager> manager = audio::river::Manager::create("river_sample_read");
std::shared_ptr<audio::river::Manager> manager = audio::river::Manager::create("river_sample_read");
// create interface:
std11::shared_ptr<audio::river::Interface> interface;
std::shared_ptr<audio::river::Interface> interface;
//Get the generic input:
interface = manager->createInput(48000,
std::vector<audio::channel>(),
@@ -107,13 +107,13 @@ int main(int _argc, const char **_argv) {
outputNode.fileOpenWrite();
}
// set callback mode ...
interface->setInputCallback(std11::bind(&onDataReceived,
std11::placeholders::_1,
std11::placeholders::_2,
std11::placeholders::_3,
std11::placeholders::_4,
std11::placeholders::_5,
std11::placeholders::_6,
interface->setInputCallback(std::bind(&onDataReceived,
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6,
&outputNode));
// start the stream
interface->start();

28
sample/write/lutin_river-sample-write.py
View File

@@ -2,17 +2,35 @@
import lutin.module as module
import lutin.tools as tools
def get_type():
return "BINARY"
def get_sub_type():
return "SAMPLE"
def get_desc():
return "Write some data"
def get_licence():
return "APACHE-2"
def create(target):
myModule = module.Module(__file__, 'river-sample-write', 'BINARY')
myModule.add_src_file([
def get_compagny_type():
return "com"
def get_compagny_name():
return "atria-soft"
def get_maintainer():
return ["Mr DUPIN Edouard <yui.heero@gmail.com>"]
def create(target, module_name):
my_module = module.Module(__file__, module_name, get_type())
my_module.add_src_file([
'main.cpp',
])
myModule.add_module_depend(['audio-river', 'etk'])
return myModule
my_module.add_module_depend(['audio-river', 'etk'])
return my_module

18
sample/write/main.cpp
View File

@@ -65,9 +65,9 @@ int main(int _argc, const char **_argv) {
// initialize river interface
audio::river::initString(configurationRiver);
// Create the River manager for tha application or part of the application.
std11::shared_ptr<audio::river::Manager> manager = audio::river::Manager::create("river_sample_read");
std::shared_ptr<audio::river::Manager> manager = audio::river::Manager::create("river_sample_read");
// create interface:
std11::shared_ptr<audio::river::Interface> interface;
std::shared_ptr<audio::river::Interface> interface;
//Get the generic input:
interface = manager->createOutput(48000,
std::vector<audio::channel>(),
@@ -78,13 +78,13 @@ int main(int _argc, const char **_argv) {
return -1;
}
// set callback mode ...
interface->setOutputCallback(std11::bind(&onDataNeeded,
std11::placeholders::_1,
std11::placeholders::_2,
std11::placeholders::_3,
std11::placeholders::_4,
std11::placeholders::_5,
std11::placeholders::_6));
interface->setOutputCallback(std::bind(&onDataNeeded,
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6));
// start the stream
interface->start();
// wait 10 second ...

15
test/debug.cpp
View File

@@ -1,15 +0,0 @@
/**
* @author Edouard DUPIN
*
* @copyright 2010, Edouard DUPIN, all right reserved
*
* @license GPL v3 (see license file)
*/
#include "debug.h"
int32_t appl::getLogId() {
static int32_t g_val = etk::log::registerInstance("test");
return g_val;
}

30
test/main.cpp
View File

@@ -4,7 +4,29 @@
* @license APACHE v2.0 (see license file)
*/
#include "debug.h"
#include <test-debug/debug.h>
#define TEST_SAVE_FILE_MACRO(type,fileName,dataPointer,nbElement) \
do { \
static FILE *pointerOnFile = nullptr; \
static bool errorOpen = false; \
if (pointerOnFile == nullptr) { \
TEST_WARNING("open file '" << fileName << "' type=" << #type); \
pointerOnFile = fopen(fileName,"w"); \
if ( errorOpen == false \
&& pointerOnFile == nullptr) { \
TEST_ERROR("ERROR OPEN file ... '" << fileName << "' type=" << #type); \
errorOpen=true; \
} \
} \
if (pointerOnFile != nullptr) { \
fwrite((dataPointer), sizeof(type), (nbElement), pointerOnFile); \
/* fflush(pointerOnFile);*/ \
} \
}while(0)
#include <audio/river/river.h>
#include <audio/river/Manager.h>
#include <audio/river/Interface.h>
@@ -14,7 +36,7 @@
#include <math.h>
#include <sstream>
#include <unistd.h>
#include <etk/thread.h>
#include <thread>
#include "testAEC.h"
#include "testEchoDelay.h"
#include "testFormat.h"
@@ -38,8 +60,8 @@ int main(int _argc, const char** _argv) {
std::string data = _argv[iii];
if ( data == "-h"
|| data == "--help") {
APPL_PRINT("Help : ");
APPL_PRINT(" ./xxx ---");
TEST_PRINT("Help : ");
TEST_PRINT(" ./xxx ---");
exit(0);
}
}

65
test/testAEC.h
View File

@@ -3,9 +3,7 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#ifndef __RIVER_TEST_AEC_H__
#define __RIVER_TEST_AEC_H__
#pragma once
#undef __class__
#define __class__ "test_aec"
@@ -14,12 +12,12 @@ namespace river_test_aec {
class Linker {
private:
std11::shared_ptr<audio::river::Manager> m_manager;
std11::shared_ptr<audio::river::Interface> m_interfaceOut;
std11::shared_ptr<audio::river::Interface> m_interfaceIn;
std::shared_ptr<audio::river::Manager> m_manager;
std::shared_ptr<audio::river::Interface> m_interfaceOut;
std::shared_ptr<audio::river::Interface> m_interfaceIn;
audio::drain::CircularBuffer m_buffer;
public:
Linker(std11::shared_ptr<audio::river::Manager> _manager, const std::string& _input, const std::string& _output) :
Linker(std::shared_ptr<audio::river::Manager> _manager, const std::string& _input, const std::string& _output) :
m_manager(_manager) {
//Set stereo output:
std::vector<audio::channel> channelMap;
@@ -29,25 +27,25 @@ namespace river_test_aec {
channelMap.push_back(audio::channel_frontLeft);
channelMap.push_back(audio::channel_frontRight);
}
m_buffer.setCapacity(std11::chrono::milliseconds(2000), sizeof(int16_t)*channelMap.size(), 48000);
m_buffer.setCapacity(std::chrono::milliseconds(2000), sizeof(int16_t)*channelMap.size(), 48000);
m_interfaceOut = m_manager->createOutput(48000,
channelMap,
audio::format_int16,
_output);
if(m_interfaceOut == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
// set callback mode ...
m_interfaceOut->setOutputCallback(std11::bind(&Linker::onDataNeeded,
m_interfaceOut->setOutputCallback(std::bind(&Linker::onDataNeeded,
this,
std11::placeholders::_1,
std11::placeholders::_2,
std11::placeholders::_3,
std11::placeholders::_4,
std11::placeholders::_5,
std11::placeholders::_6));
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6));
m_interfaceOut->addVolumeGroup("FLOW");
if ("speaker" == _output) {
m_interfaceOut->setParameter("volume", "FLOW", "0dB");
@@ -58,18 +56,18 @@ namespace river_test_aec {
audio::format_int16,
_input);
if(m_interfaceIn == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
// set callback mode ...
m_interfaceIn->setInputCallback(std11::bind(&Linker::onDataReceived,
m_interfaceIn->setInputCallback(std::bind(&Linker::onDataReceived,
this,
std11::placeholders::_1,
std11::placeholders::_2,
std11::placeholders::_3,
std11::placeholders::_4,
std11::placeholders::_5,
std11::placeholders::_6));
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6));
}
void onDataNeeded(void* _data,
@@ -79,7 +77,7 @@ namespace river_test_aec {
uint32_t _frequency,
const std::vector<audio::channel>& _map) {
if (_format != audio::format_int16) {
APPL_ERROR("call wrong type ... (need int16_t)");
TEST_ERROR("call wrong type ... (need int16_t)");
}
m_buffer.read(_data, _nbChunk);
}
@@ -90,17 +88,17 @@ namespace river_test_aec {
uint32_t _frequency,
const std::vector<audio::channel>& _map) {
if (_format != audio::format_int16) {
APPL_ERROR("call wrong type ... (need int16_t)");
TEST_ERROR("call wrong type ... (need int16_t)");
}
m_buffer.write(_data, _nbChunk);
}
void start() {
if(m_interfaceIn == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
if(m_interfaceOut == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
m_interfaceOut->start();
@@ -108,11 +106,11 @@ namespace river_test_aec {
}
void stop() {
if(m_interfaceIn == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
if(m_interfaceOut == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
m_manager->generateDotAll("activeProcess.dot");
@@ -200,10 +198,10 @@ namespace river_test_aec {
TEST(TestUser, testAECManually) {
audio::river::initString(configurationRiver);
std11::shared_ptr<audio::river::Manager> manager;
std::shared_ptr<audio::river::Manager> manager;
manager = audio::river::Manager::create("testApplication");
std11::shared_ptr<Linker> processLink1 = std11::make_shared<Linker>(manager, "microphone-clean", "speaker");
std11::shared_ptr<Linker> processLink2 = std11::make_shared<Linker>(manager, "microphone", "speaker-test");
std::shared_ptr<Linker> processLink1 = std::make_shared<Linker>(manager, "microphone-clean", "speaker");
std::shared_ptr<Linker> processLink2 = std::make_shared<Linker>(manager, "microphone", "speaker-test");
processLink1->start();
processLink2->start();
sleep(30);
@@ -220,4 +218,3 @@ namespace river_test_aec {
#undef __class__
#define __class__ nullptr
#endif

133
test/testEchoDelay.h
View File

@@ -3,11 +3,9 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#pragma once
#ifndef __RIVER_TEST_ECHO_DELAY_H__
#define __RIVER_TEST_ECHO_DELAY_H__
#include <audio/river/debug.h>
#include <test-debug/debug.h>
#undef __class__
#define __class__ "test_echo_delay"
@@ -15,14 +13,14 @@
namespace river_test_echo_delay {
class TestClass {
private:
std11::shared_ptr<audio::river::Manager> m_manager;
std11::shared_ptr<audio::river::Interface> m_interfaceOut;
std11::shared_ptr<audio::river::Interface> m_interfaceIn;
std11::shared_ptr<audio::river::Interface> m_interfaceFB;
std::shared_ptr<audio::river::Manager> m_manager;
std::shared_ptr<audio::river::Interface> m_interfaceOut;
std::shared_ptr<audio::river::Interface> m_interfaceIn;
std::shared_ptr<audio::river::Interface> m_interfaceFB;
double m_phase;
double m_freq;
int32_t m_nextSampleCount;
std11::chrono::milliseconds m_delayBetweenEvent;
std::chrono::milliseconds m_delayBetweenEvent;
audio::Time m_nextTick;
audio::Time m_currentTick;
int32_t m_stateFB;
@@ -33,7 +31,7 @@ namespace river_test_echo_delay {
int16_t m_volumeInputMin;
float m_gain;
public:
TestClass(std11::shared_ptr<audio::river::Manager> _manager) :
TestClass(std::shared_ptr<audio::river::Manager> _manager) :
m_manager(_manager),
m_phase(0),
m_freq(400),
@@ -50,18 +48,18 @@ namespace river_test_echo_delay {
audio::format_int16,
"speaker");
if(m_interfaceOut == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
// set callback mode ...
m_interfaceOut->setOutputCallback(std11::bind(&TestClass::onDataNeeded,
m_interfaceOut->setOutputCallback(std::bind(&TestClass::onDataNeeded,
this,
std11::placeholders::_1,
std11::placeholders::_2,
std11::placeholders::_3,
std11::placeholders::_4,
std11::placeholders::_5,
std11::placeholders::_6));
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6));
m_interfaceOut->addVolumeGroup("FLOW");
m_interfaceOut->setParameter("volume", "FLOW", etk::to_string(m_gain) + "dB");
@@ -70,36 +68,36 @@ namespace river_test_echo_delay {
audio::format_int16,
"microphone");
if(m_interfaceIn == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
// set callback mode ...
m_interfaceIn->setInputCallback(std11::bind(&TestClass::onDataReceived,
m_interfaceIn->setInputCallback(std::bind(&TestClass::onDataReceived,
this,
std11::placeholders::_1,
std11::placeholders::_2,
std11::placeholders::_3,
std11::placeholders::_4,
std11::placeholders::_5,
std11::placeholders::_6));
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6));
m_interfaceFB = m_manager->createFeedback(48000,
channelMap,
audio::format_int16,
"speaker");
if(m_interfaceFB == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
// set callback mode ...
m_interfaceFB->setInputCallback(std11::bind(&TestClass::onDataReceivedFeedBack,
m_interfaceFB->setInputCallback(std::bind(&TestClass::onDataReceivedFeedBack,
this,
std11::placeholders::_1,
std11::placeholders::_2,
std11::placeholders::_3,
std11::placeholders::_4,
std11::placeholders::_5,
std11::placeholders::_6));
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6));
m_manager->generateDotAll("activeProcess.dot");
}
@@ -135,7 +133,7 @@ namespace river_test_echo_delay {
m_nextSampleCount = m_delayBetweenEvent.count()*int64_t(_frequency)/1000;
m_phase = -1;
}
//APPL_INFO("sample : " << m_nextSampleCount);
//TEST_INFO("sample : " << m_nextSampleCount);
for (int32_t iii=0; iii<_nbChunk; iii++) {
if (m_nextSampleCount > 0) {
m_nextSampleCount--;
@@ -157,7 +155,7 @@ namespace river_test_echo_delay {
// start detection ...
m_stateFB = 0;
m_stateMic = 0;
APPL_WARNING("Time Pulse zero crossing: " << m_currentTick << " id=" << iii);
TEST_WARNING("Time Pulse zero crossing: " << m_currentTick << " id=" << iii);
}
m_phase = newPhase;
if (m_phase >= 2*M_PI) {
@@ -182,7 +180,7 @@ namespace river_test_echo_delay {
return _time + audio::Duration(0, int64_t(_pos+1)*1000000000LL/int64_t(_frequency));
}
double xxx = double(-_val1) / double(_val2 - _val1);
APPL_VERBOSE("deltaPos:" << xxx);
TEST_VERBOSE("deltaPos:" << xxx);
return _time + audio::Duration(0, int64_t((double(_pos)+xxx)*1000000000.0)/int64_t(_frequency));
}
@@ -193,9 +191,9 @@ namespace river_test_echo_delay {
uint32_t _frequency,
const std::vector<audio::channel>& _map) {
if (_format != audio::format_int16) {
APPL_ERROR("call wrong type ... (need int16_t)");
TEST_ERROR("call wrong type ... (need int16_t)");
}
RIVER_SAVE_FILE_MACRO(int16_t, "REC_FeedBack.raw", _data, _nbChunk*_map.size());
TEST_SAVE_FILE_MACRO(int16_t, "REC_FeedBack.raw", _data, _nbChunk*_map.size());
if (m_estimateVolumeInput == true) {
// nothing to do ...
} else {
@@ -207,10 +205,10 @@ namespace river_test_echo_delay {
if (m_stateFB == 0) {
if (data[iii*_map.size() + jjj] > INT16_MAX/5) {
m_stateFB = 1;
APPL_VERBOSE("FB: detect Normal " << iii);
TEST_VERBOSE("FB: detect Normal " << iii);
} else if (data[iii*_map.size() + jjj] < -INT16_MAX/5) {
m_stateFB = 2;
APPL_VERBOSE("FB: detect inverse " << iii);
TEST_VERBOSE("FB: detect inverse " << iii);
}
} else if (m_stateFB == 1) {
// normale phase
@@ -218,10 +216,10 @@ namespace river_test_echo_delay {
// detect inversion of signe ...
m_stateFB = 3;
audio::Time time = getInterpolateTime(_time, iii-1, data[(iii-1)*_map.size() + jjj], data[iii*_map.size() + jjj], _frequency);
APPL_VERBOSE("FB: 1 position -1: " << iii-1 << " " << data[(iii-1)*_map.size() + jjj]);
APPL_VERBOSE("FB: 1 position 0: " << iii << " " << data[iii*_map.size() + jjj]);
TEST_VERBOSE("FB: 1 position -1: " << iii-1 << " " << data[(iii-1)*_map.size() + jjj]);
TEST_VERBOSE("FB: 1 position 0: " << iii << " " << data[iii*_map.size() + jjj]);
APPL_WARNING("FB: 1 time detected: " << time << " delay = " << float((time-m_currentTick).count())/1000.0f << "µs");
TEST_WARNING("FB: 1 time detected: " << time << " delay = " << float((time-m_currentTick).count())/1000.0f << "µs");
}
} else if (m_stateFB == 2) {
// inverse phase
@@ -229,9 +227,9 @@ namespace river_test_echo_delay {
// detect inversion of signe ...
m_stateFB = 3;
audio::Time time = getInterpolateTime(_time, iii-1, data[(iii-1)*_map.size() + jjj], data[iii*_map.size() + jjj], _frequency);
APPL_VERBOSE("FB: 2 position -1: " << iii-1 << " " << data[(iii-1)*_map.size() + jjj]);
APPL_VERBOSE("FB: 2 position 0: " << iii << " " << data[iii*_map.size() + jjj]);
APPL_WARNING("FB: 2 time detected: " << time << " delay = " << float((time-m_currentTick).count())/1000.0f << "µs");
TEST_VERBOSE("FB: 2 position -1: " << iii-1 << " " << data[(iii-1)*_map.size() + jjj]);
TEST_VERBOSE("FB: 2 position 0: " << iii << " " << data[iii*_map.size() + jjj]);
TEST_WARNING("FB: 2 time detected: " << time << " delay = " << float((time-m_currentTick).count())/1000.0f << "µs");
}
} else if (m_stateFB == 3) {
// TODO : Detect the pic ...
@@ -248,16 +246,16 @@ namespace river_test_echo_delay {
uint32_t _frequency,
const std::vector<audio::channel>& _map) {
if (_format != audio::format_int16) {
APPL_ERROR("call wrong type ... (need int16_t)");
TEST_ERROR("call wrong type ... (need int16_t)");
}
RIVER_SAVE_FILE_MACRO(int16_t, "REC_Microphone.raw", _data, _nbChunk*_map.size());
TEST_SAVE_FILE_MACRO(int16_t, "REC_Microphone.raw", _data, _nbChunk*_map.size());
const int16_t* data = static_cast<const int16_t*>(_data);
if (m_estimateVolumeInput == true) {
m_stateMic ++;
const int16_t* data = static_cast<const int16_t*>(_data);
if (m_stateMic <= 40) {
for (size_t iii=0; iii<_nbChunk*_map.size(); ++iii) {
//APPL_INFO("value=" << data[iii]);
//TEST_INFO("value=" << data[iii]);
m_volumeInputMax = std::max(int16_t(data[iii]), m_volumeInputMax);
m_volumeInputMin = std::min(int16_t(data[iii]), m_volumeInputMin);
}
@@ -269,7 +267,7 @@ namespace river_test_echo_delay {
int16_t valueMax = 0;
int16_t valueMin = 0;
for (size_t iii=0; iii<_nbChunk*_map.size(); ++iii) {
//APPL_INFO("value=" << data[iii]);
//TEST_INFO("value=" << data[iii]);
valueMax = std::max(int16_t(data[iii]), valueMax);
valueMin = std::min(int16_t(data[iii]), valueMin);
}
@@ -284,7 +282,7 @@ namespace river_test_echo_delay {
m_gain += 3.0f;
m_gain = std::min(m_gain, 0.0f);
m_interfaceOut->setParameter("volume", "FLOW", etk::to_string(m_gain) + "dB");
APPL_INFO("Set detection volume : " << m_gain << " m_stateMic=" << m_stateMic);
TEST_INFO("Set detection volume : " << m_gain << " m_stateMic=" << m_stateMic);
m_stateMic = 3;
m_phase = -1;
m_estimateVolumeInput = false;
@@ -292,7 +290,7 @@ namespace river_test_echo_delay {
} else {
if (m_stateMic%2 == 0) {
if (m_gain == 0.0f) {
APPL_CRITICAL("Can not find the basicVolume ...");
TEST_CRITICAL("Can not find the basicVolume ...");
}
// just update volume
m_gain += 1.0f;
@@ -309,10 +307,10 @@ namespace river_test_echo_delay {
if (m_stateMic == 0) {
if (data[iii*_map.size() + jjj] > m_volumeInputMax) {
m_stateMic = 1;
APPL_VERBOSE("Mic: detect Normal " << iii);
TEST_VERBOSE("Mic: detect Normal " << iii);
} else if (data[iii*_map.size() + jjj] < m_volumeInputMin) {
m_stateMic = 2;
APPL_VERBOSE("Mic: detect inverse " << iii);
TEST_VERBOSE("Mic: detect inverse " << iii);
}
} else if (m_stateMic == 1) {
// normale phase
@@ -320,11 +318,11 @@ namespace river_test_echo_delay {
// detect inversion of signe ...
m_stateMic = 3;
audio::Time time = getInterpolateTime(_time, iii-1, data[(iii-1)*_map.size() + jjj], data[iii*_map.size() + jjj], _frequency);
APPL_VERBOSE("MIC: 1 position -1: " << iii-1 << " " << data[(iii-1)*_map.size() + jjj]);
APPL_VERBOSE("MIC: 1 position 0: " << iii << " " << data[iii*_map.size() + jjj]);
TEST_VERBOSE("MIC: 1 position -1: " << iii-1 << " " << data[(iii-1)*_map.size() + jjj]);
TEST_VERBOSE("MIC: 1 position 0: " << iii << " " << data[iii*_map.size() + jjj]);
audio::Duration delay = time-m_currentTick;
int32_t sampleDalay = (delay.count()*_frequency)/1000000000LL;
APPL_WARNING("MIC: 1 time detected: " << time << " delay = " << float(delay.count())/1000.0f << "µs samples=" << sampleDalay);
TEST_WARNING("MIC: 1 time detected: " << time << " delay = " << float(delay.count())/1000.0f << "µs samples=" << sampleDalay);
m_delayListMic.push_back(delay.count());
}
} else if (m_stateMic == 2) {
@@ -333,11 +331,11 @@ namespace river_test_echo_delay {
// detect inversion of signe ...
m_stateMic = 3;
audio::Time time = getInterpolateTime(_time, iii-1, data[(iii-1)*_map.size() + jjj], data[iii*_map.size() + jjj], _frequency);
APPL_VERBOSE("MIC: 2 position -1: " << iii-1 << " " << data[(iii-1)*_map.size() + jjj]);
APPL_VERBOSE("MIC: 2 position 0: " << iii << " " << data[iii*_map.size() + jjj]);
TEST_VERBOSE("MIC: 2 position -1: " << iii-1 << " " << data[(iii-1)*_map.size() + jjj]);
TEST_VERBOSE("MIC: 2 position 0: " << iii << " " << data[iii*_map.size() + jjj]);
audio::Duration delay = time-m_currentTick;
int32_t sampleDalay = (delay.count()*_frequency)/1000000000LL;
APPL_WARNING("MIC: 2 time detected: " << time << " delay = " << float(delay.count())/1000.0f << "µs samples=" << sampleDalay);
TEST_WARNING("MIC: 2 time detected: " << time << " delay = " << float(delay.count())/1000.0f << "µs samples=" << sampleDalay);
m_delayListMic.push_back(delay.count());
}
} else if (m_stateMic == 3) {
@@ -350,15 +348,15 @@ namespace river_test_echo_delay {
}
void run() {
if(m_interfaceIn == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
if(m_interfaceOut == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
if(m_interfaceFB == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
m_interfaceOut->start();
@@ -380,7 +378,7 @@ namespace river_test_echo_delay {
delayAverage /= m_delayListMic.size();
}
int32_t sampleDalay = (delayAverage*48000)/1000000000LL;
APPL_ERROR("Average delay in ns : " << delayAverage << " nbSample=" << sampleDalay);
TEST_ERROR("Average delay in ns : " << delayAverage << " nbSample=" << sampleDalay);
}
};
@@ -418,9 +416,9 @@ namespace river_test_echo_delay {
TEST(TestTime, testDelay) {
audio::river::initString(configurationRiver);
std11::shared_ptr<audio::river::Manager> manager;
std::shared_ptr<audio::river::Manager> manager;
manager = audio::river::Manager::create("testApplication");
std11::shared_ptr<TestClass> process = std11::make_shared<TestClass>(manager);
std::shared_ptr<TestClass> process = std::make_shared<TestClass>(manager);
process->run();
process.reset();
usleep(500000);
@@ -431,4 +429,3 @@ namespace river_test_echo_delay {
#undef __class__
#define __class__ nullptr
#endif

53
test/testFormat.h
View File

@@ -3,9 +3,7 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#ifndef __RIVER_TEST_FORMAT_H__
#define __RIVER_TEST_FORMAT_H__
#pragma once
#undef __class__
#define __class__ "test_format"
@@ -28,15 +26,15 @@ namespace river_test_format {
"}\n";
class testOutCallbackType {
private:
std11::shared_ptr<audio::river::Manager> m_manager;
std11::shared_ptr<audio::river::Interface> m_interface;
std::shared_ptr<audio::river::Manager> m_manager;
std::shared_ptr<audio::river::Interface> m_interface;
double m_phase;
float m_freq;
int32_t m_nbChannels;
float m_generateFreq;
public:
testOutCallbackType(const std11::shared_ptr<audio::river::Manager>& _manager,
testOutCallbackType(const std::shared_ptr<audio::river::Manager>& _manager,
float _freq=48000.0f,
int32_t _nbChannels=2,
audio::format _format=audio::format_int16) :
@@ -58,7 +56,7 @@ namespace river_test_format {
channelMap.push_back(audio::channel_rearLeft);
channelMap.push_back(audio::channel_rearRight);
} else {
APPL_ERROR("Can not generate with channel != 1,2,4");
TEST_ERROR("Can not generate with channel != 1,2,4");
return;
}
m_interface = m_manager->createOutput(m_freq,
@@ -67,18 +65,18 @@ namespace river_test_format {
"speaker",
"WriteModeCallbackType");
if(m_interface == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
// set callback mode ...
m_interface->setOutputCallback(std11::bind(&testOutCallbackType::onDataNeeded,
m_interface->setOutputCallback(std::bind(&testOutCallbackType::onDataNeeded,
this,
std11::placeholders::_1,
std11::placeholders::_2,
std11::placeholders::_3,
std11::placeholders::_4,
std11::placeholders::_5,
std11::placeholders::_6));
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6));
}
void onDataNeeded(void* _data,
const audio::Time& _time,
@@ -86,7 +84,7 @@ namespace river_test_format {
enum audio::format _format,
uint32_t _frequency,
const std::vector<audio::channel>& _map) {
//APPL_DEBUG("Get data ... " << _format << " map=" << _map << " chunk=" << _nbChunk);
//TEST_DEBUG("Get data ... " << _format << " map=" << _map << " chunk=" << _nbChunk);
double baseCycle = 2.0*M_PI/double(m_freq) * double(m_generateFreq);
if (_format == audio::format_int16) {
int16_t* data = static_cast<int16_t*>(_data);
@@ -136,7 +134,7 @@ namespace river_test_format {
}
void run() {
if(m_interface == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
m_interface->start();
@@ -151,9 +149,9 @@ namespace river_test_format {
class testResampling : public ::testing::TestWithParam<float> {};
TEST_P(testResampling, base) {
audio::river::initString(configurationRiver);
std11::shared_ptr<audio::river::Manager> manager;
std::shared_ptr<audio::river::Manager> manager;
manager = audio::river::Manager::create("testApplication");
std11::shared_ptr<testOutCallbackType> process = std11::make_shared<testOutCallbackType>(manager, GetParam(), 2, audio::format_int16);
std::shared_ptr<testOutCallbackType> process = std::make_shared<testOutCallbackType>(manager, GetParam(), 2, audio::format_int16);
process->run();
process.reset();
usleep(500000);
@@ -168,9 +166,9 @@ namespace river_test_format {
class testFormat : public ::testing::TestWithParam<audio::format> {};
TEST_P(testFormat, base) {
audio::river::initString(configurationRiver);
std11::shared_ptr<audio::river::Manager> manager;
std::shared_ptr<audio::river::Manager> manager;
manager = audio::river::Manager::create("testApplication");
std11::shared_ptr<testOutCallbackType> process = std11::make_shared<testOutCallbackType>(manager, 48000, 2, GetParam());
std::shared_ptr<testOutCallbackType> process = std::make_shared<testOutCallbackType>(manager, 48000, 2, GetParam());
process->run();
process.reset();
usleep(500000);
@@ -184,9 +182,9 @@ namespace river_test_format {
class testChannels : public ::testing::TestWithParam<int32_t> {};
TEST_P(testChannels, base) {
audio::river::initString(configurationRiver);
std11::shared_ptr<audio::river::Manager> manager;
std::shared_ptr<audio::river::Manager> manager;
manager = audio::river::Manager::create("testApplication");
std11::shared_ptr<testOutCallbackType> process = std11::make_shared<testOutCallbackType>(manager, 48000, GetParam(), audio::format_int16);
std::shared_ptr<testOutCallbackType> process = std::make_shared<testOutCallbackType>(manager, 48000, GetParam(), audio::format_int16);
process->run();
process.reset();
usleep(500000);
@@ -199,9 +197,9 @@ namespace river_test_format {
TEST(TestALL, testChannelsFormatResampling) {
audio::river::initString(configurationRiver);
std11::shared_ptr<audio::river::Manager> manager;
std::shared_ptr<audio::river::Manager> manager;
manager = audio::river::Manager::create("testApplication");
APPL_INFO("test convert flaot to output (callback mode)");
TEST_INFO("test convert flaot to output (callback mode)");
std::vector<float> listFreq;
listFreq.push_back(4000);
listFreq.push_back(8000);
@@ -227,8 +225,8 @@ namespace river_test_format {
for (size_t fff=0; fff<listFreq.size(); ++fff) {
for (size_t ccc=0; ccc<listChannel.size(); ++ccc) {
for (size_t iii=0; iii<listFormat.size(); ++iii) {
APPL_INFO("freq=" << listFreq[fff] << " channel=" << listChannel[ccc] << " format=" << getFormatString(listFormat[iii]));
std11::shared_ptr<testOutCallbackType> process = std11::make_shared<testOutCallbackType>(manager, listFreq[fff], listChannel[ccc], listFormat[iii]);
TEST_INFO("freq=" << listFreq[fff] << " channel=" << listChannel[ccc] << " format=" << getFormatString(listFormat[iii]));
std::shared_ptr<testOutCallbackType> process = std::make_shared<testOutCallbackType>(manager, listFreq[fff], listChannel[ccc], listFormat[iii]);
process->run();
process.reset();
usleep(500000);
@@ -244,4 +242,3 @@ namespace river_test_format {
#undef __class__
#define __class__ nullptr
#endif

61
test/testMuxer.h
View File

@@ -3,11 +3,9 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#pragma once
#ifndef __RIVER_TEST_MUXER_H__
#define __RIVER_TEST_MUXER_H__
#include <audio/river/debug.h>
#include <test-debug/debug.h>
#undef __class__
#define __class__ "test_muxer"
@@ -15,12 +13,12 @@
namespace river_test_muxer {
class TestClass {
private:
std11::shared_ptr<audio::river::Manager> m_manager;
std11::shared_ptr<audio::river::Interface> m_interfaceIn;
std11::shared_ptr<audio::river::Interface> m_interfaceOut;
std::shared_ptr<audio::river::Manager> m_manager;
std::shared_ptr<audio::river::Interface> m_interfaceIn;
std::shared_ptr<audio::river::Interface> m_interfaceOut;
double m_phase;
public:
TestClass(std11::shared_ptr<audio::river::Manager> _manager) :
TestClass(std::shared_ptr<audio::river::Manager> _manager) :
m_manager(_manager),
m_phase(0) {
std::vector<audio::channel> channelMap;
@@ -31,18 +29,18 @@ namespace river_test_muxer {
audio::format_int16,
"speaker");
if(m_interfaceOut == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
// set callback mode ...
m_interfaceOut->setOutputCallback(std11::bind(&TestClass::onDataNeeded,
m_interfaceOut->setOutputCallback(std::bind(&TestClass::onDataNeeded,
this,
std11::placeholders::_1,
std11::placeholders::_2,
std11::placeholders::_3,
std11::placeholders::_4,
std11::placeholders::_5,
std11::placeholders::_6));
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6));
m_interfaceOut->addVolumeGroup("FLOW");
//m_interfaceOut->setParameter("volume", "FLOW", "-6dB");
@@ -52,18 +50,18 @@ namespace river_test_muxer {
audio::format_int16,
"microphone-muxed");
if(m_interfaceIn == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
// set callback mode ...
m_interfaceIn->setInputCallback(std11::bind(&TestClass::onDataReceived,
m_interfaceIn->setInputCallback(std::bind(&TestClass::onDataReceived,
this,
std11::placeholders::_1,
std11::placeholders::_2,
std11::placeholders::_3,
std11::placeholders::_4,
std11::placeholders::_5,
std11::placeholders::_6));
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6));
m_manager->generateDotAll("activeProcess.dot");
}
@@ -92,18 +90,18 @@ namespace river_test_muxer {
uint32_t _frequency,
const std::vector<audio::channel>& _map) {
if (_format != audio::format_int16) {
APPL_ERROR("call wrong type ... (need int16_t)");
TEST_ERROR("call wrong type ... (need int16_t)");
}
RIVER_SAVE_FILE_MACRO(int16_t, "REC_MicrophoneMuxed.raw", _data, _nbChunk*_map.size());
APPL_ERROR("Receive data ... " << _nbChunk << " map=" << _map);
TEST_SAVE_FILE_MACRO(int16_t, "REC_MicrophoneMuxed.raw", _data, _nbChunk*_map.size());
TEST_ERROR("Receive data ... " << _nbChunk << " map=" << _map);
}
void run() {
if(m_interfaceIn == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
if(m_interfaceOut == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
m_interfaceOut->start();
@@ -168,9 +166,9 @@ namespace river_test_muxer {
TEST(TestMuxer, testMuxing) {
audio::river::initString(configurationRiver);
std11::shared_ptr<audio::river::Manager> manager;
std::shared_ptr<audio::river::Manager> manager;
manager = audio::river::Manager::create("testApplication");
std11::shared_ptr<TestClass> process = std11::make_shared<TestClass>(manager);
std::shared_ptr<TestClass> process = std::make_shared<TestClass>(manager);
process->run();
process.reset();
usleep(500000);
@@ -181,4 +179,3 @@ namespace river_test_muxer {
#undef __class__
#define __class__ nullptr
#endif

49
test/testPlaybackCallback.h
View File

@@ -3,9 +3,7 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#ifndef __RIVER_TEST_PLAYBACK_CALLBACK_H__
#define __RIVER_TEST_PLAYBACK_CALLBACK_H__
#pragma once
#undef __class__
#define __class__ "test_playback_callback"
@@ -14,11 +12,11 @@ namespace river_test_playback_callback {
class testOutCallback {
public:
std11::shared_ptr<audio::river::Manager> m_manager;
std11::shared_ptr<audio::river::Interface> m_interface;
std::shared_ptr<audio::river::Manager> m_manager;
std::shared_ptr<audio::river::Interface> m_interface;
double m_phase;
public:
testOutCallback(std11::shared_ptr<audio::river::Manager> _manager, const std::string& _io="speaker") :
testOutCallback(std::shared_ptr<audio::river::Manager> _manager, const std::string& _io="speaker") :
m_manager(_manager),
m_phase(0) {
//Set stereo output:
@@ -30,18 +28,18 @@ namespace river_test_playback_callback {
audio::format_int16,
_io);
if(m_interface == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
// set callback mode ...
m_interface->setOutputCallback(std11::bind(&testOutCallback::onDataNeeded,
m_interface->setOutputCallback(std::bind(&testOutCallback::onDataNeeded,
this,
std11::placeholders::_1,
std11::placeholders::_2,
std11::placeholders::_3,
std11::placeholders::_4,
std11::placeholders::_5,
std11::placeholders::_6));
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6));
}
void onDataNeeded(void* _data,
const audio::Time& _time,
@@ -50,7 +48,7 @@ namespace river_test_playback_callback {
uint32_t _frequency,
const std::vector<audio::channel>& _map) {
if (_format != audio::format_int16) {
APPL_ERROR("call wrong type ... (need int16_t)");
TEST_ERROR("call wrong type ... (need int16_t)");
}
int16_t* data = static_cast<int16_t*>(_data);
double baseCycle = 2.0*M_PI/(double)48000 * (double)550;
@@ -66,7 +64,7 @@ namespace river_test_playback_callback {
}
void run() {
if(m_interface == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
m_interface->start();
@@ -94,11 +92,11 @@ namespace river_test_playback_callback {
TEST(TestALL, testOutputCallBack) {
audio::river::initString(configurationRiver);
std11::shared_ptr<audio::river::Manager> manager;
std::shared_ptr<audio::river::Manager> manager;
manager = audio::river::Manager::create("testApplication");
APPL_INFO("test output (callback mode)");
std11::shared_ptr<testOutCallback> process = std11::make_shared<testOutCallback>(manager, "speaker");
TEST_INFO("test output (callback mode)");
std::shared_ptr<testOutCallback> process = std::make_shared<testOutCallback>(manager, "speaker");
ASSERT_NE(process, nullptr);
process->run();
process.reset();
@@ -108,11 +106,11 @@ namespace river_test_playback_callback {
TEST(TestALL, testOutputCallBackPulse) {
audio::river::initString(configurationRiver);
std11::shared_ptr<audio::river::Manager> manager;
std::shared_ptr<audio::river::Manager> manager;
manager = audio::river::Manager::create("testApplication");
APPL_INFO("test output (callback mode)");
std11::shared_ptr<testOutCallback> process = std11::make_shared<testOutCallback>(manager, "speaker-pulse");
TEST_INFO("test output (callback mode)");
std::shared_ptr<testOutCallback> process = std::make_shared<testOutCallback>(manager, "speaker-pulse");
process->run();
process.reset();
usleep(500000);
@@ -121,11 +119,11 @@ namespace river_test_playback_callback {
TEST(TestALL, testOutputCallBackJack) {
audio::river::initString(configurationRiver);
std11::shared_ptr<audio::river::Manager> manager;
std::shared_ptr<audio::river::Manager> manager;
manager = audio::river::Manager::create("testApplication");
APPL_INFO("test output (callback mode)");
std11::shared_ptr<testOutCallback> process = std11::make_shared<testOutCallback>(manager, "speaker-jack");
TEST_INFO("test output (callback mode)");
std::shared_ptr<testOutCallback> process = std::make_shared<testOutCallback>(manager, "speaker-jack");
process->run();
process.reset();
usleep(500000);
@@ -138,4 +136,3 @@ namespace river_test_playback_callback {
#undef __class__
#define __class__ nullptr
#endif

51
test/testPlaybackWrite.h
View File

@@ -3,9 +3,7 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#ifndef __RIVER_TEST_PLAYBACK_WRITE_H__
#define __RIVER_TEST_PLAYBACK_WRITE_H__
#pragma once
#undef __class__
#define __class__ "test_playback_write"
@@ -30,10 +28,10 @@ namespace river_test_playback_write {
class testOutWrite {
public:
std::vector<audio::channel> m_channelMap;
std11::shared_ptr<audio::river::Manager> m_manager;
std11::shared_ptr<audio::river::Interface> m_interface;
std::shared_ptr<audio::river::Manager> m_manager;
std::shared_ptr<audio::river::Interface> m_interface;
public:
testOutWrite(std11::shared_ptr<audio::river::Manager> _manager) :
testOutWrite(std::shared_ptr<audio::river::Manager> _manager) :
m_manager(_manager) {
//Set stereo output:
m_channelMap.push_back(audio::channel_frontLeft);
@@ -43,14 +41,14 @@ namespace river_test_playback_write {
audio::format_int16,
"speaker");
if(m_interface == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
m_interface->setReadwrite();
}
void run() {
if(m_interface == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
double phase=0;
@@ -91,11 +89,11 @@ namespace river_test_playback_write {
TEST(TestALL, testOutputWrite) {
audio::river::initString(configurationRiver);
std11::shared_ptr<audio::river::Manager> manager;
std::shared_ptr<audio::river::Manager> manager;
manager = audio::river::Manager::create("testApplication");
APPL_INFO("test output (write mode)");
std11::shared_ptr<testOutWrite> process = std11::make_shared<testOutWrite>(manager);
TEST_INFO("test output (write mode)");
std::shared_ptr<testOutWrite> process = std::make_shared<testOutWrite>(manager);
process->run();
process.reset();
usleep(500000);
@@ -104,11 +102,11 @@ namespace river_test_playback_write {
class testOutWriteCallback {
public:
std11::shared_ptr<audio::river::Manager> m_manager;
std11::shared_ptr<audio::river::Interface> m_interface;
std::shared_ptr<audio::river::Manager> m_manager;
std::shared_ptr<audio::river::Interface> m_interface;
double m_phase;
public:
testOutWriteCallback(std11::shared_ptr<audio::river::Manager> _manager) :
testOutWriteCallback(std::shared_ptr<audio::river::Manager> _manager) :
m_manager(_manager),
m_phase(0) {
std::vector<audio::channel> channelMap;
@@ -120,17 +118,17 @@ namespace river_test_playback_write {
audio::format_int16,
"speaker");
if(m_interface == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
m_interface->setReadwrite();
m_interface->setWriteCallback(std11::bind(&testOutWriteCallback::onDataNeeded,
m_interface->setWriteCallback(std::bind(&testOutWriteCallback::onDataNeeded,
this,
std11::placeholders::_1,
std11::placeholders::_2,
std11::placeholders::_3,
std11::placeholders::_4,
std11::placeholders::_5));
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5));
}
void onDataNeeded(const audio::Time& _time,
size_t _nbChunk,
@@ -138,7 +136,7 @@ namespace river_test_playback_write {
uint32_t _frequency,
const std::vector<audio::channel>& _map) {
if (_format != audio::format_int16) {
APPL_ERROR("call wrong type ... (need int16_t)");
TEST_ERROR("call wrong type ... (need int16_t)");
}
std::vector<int16_t> data;
data.resize(1024*_map.size());
@@ -157,7 +155,7 @@ namespace river_test_playback_write {
}
void run() {
if(m_interface == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
m_interface->start();
@@ -168,11 +166,11 @@ namespace river_test_playback_write {
TEST(TestALL, testOutputWriteWithCallback) {
audio::river::initString(configurationRiver);
std11::shared_ptr<audio::river::Manager> manager;
std::shared_ptr<audio::river::Manager> manager;
manager = audio::river::Manager::create("testApplication");
APPL_INFO("test output (write with callback event mode)");
std11::shared_ptr<testOutWriteCallback> process = std11::make_shared<testOutWriteCallback>(manager);
TEST_INFO("test output (write with callback event mode)");
std::shared_ptr<testOutWriteCallback> process = std::make_shared<testOutWriteCallback>(manager);
process->run();
process.reset();
usleep(500000);
@@ -184,4 +182,3 @@ namespace river_test_playback_write {
#undef __class__
#define __class__ nullptr
#endif

43
test/testRecordCallback.h
View File

@@ -3,11 +3,9 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#pragma once
#ifndef __RIVER_TEST_RECORD_CALLBACK_H__
#define __RIVER_TEST_RECORD_CALLBACK_H__
#include <audio/river/debug.h>
#include <test-debug/debug.h>
#undef __class__
#define __class__ "test_record_callback"
@@ -30,10 +28,10 @@ namespace river_test_record_callback {
class testInCallback {
public:
std11::shared_ptr<audio::river::Manager> m_manager;
std11::shared_ptr<audio::river::Interface> m_interface;
std::shared_ptr<audio::river::Manager> m_manager;
std::shared_ptr<audio::river::Interface> m_interface;
public:
testInCallback(std11::shared_ptr<audio::river::Manager> _manager, const std::string& _input="microphone") :
testInCallback(std::shared_ptr<audio::river::Manager> _manager, const std::string& _input="microphone") :
m_manager(_manager) {
//Set stereo output:
std::vector<audio::channel> channelMap;
@@ -42,18 +40,18 @@ namespace river_test_record_callback {
audio::format_int16,
_input);
if(m_interface == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
// set callback mode ...
m_interface->setInputCallback(std11::bind(&testInCallback::onDataReceived,
m_interface->setInputCallback(std::bind(&testInCallback::onDataReceived,
this,
std11::placeholders::_1,
std11::placeholders::_2,
std11::placeholders::_3,
std11::placeholders::_4,
std11::placeholders::_5,
std11::placeholders::_6));
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6));
}
void onDataReceived(const void* _data,
const audio::Time& _time,
@@ -62,20 +60,20 @@ namespace river_test_record_callback {
uint32_t _frequency,
const std::vector<audio::channel>& _map) {
if (_format != audio::format_int16) {
APPL_ERROR("call wrong type ... (need int16_t)");
TEST_ERROR("call wrong type ... (need int16_t)");
}
RIVER_SAVE_FILE_MACRO(int16_t, "REC_INPUT.raw", _data, _nbChunk * _map.size());
TEST_SAVE_FILE_MACRO(int16_t, "REC_INPUT.raw", _data, _nbChunk * _map.size());
const int16_t* data = static_cast<const int16_t*>(_data);
int64_t value = 0;
for (size_t iii=0; iii<_nbChunk*_map.size(); ++iii) {
value += std::abs(data[iii]);
}
value /= (_nbChunk*_map.size());
APPL_INFO("Get data ... average=" << int32_t(value));
TEST_INFO("Get data ... average=" << int32_t(value));
}
void run() {
if(m_interface == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
m_interface->start();
@@ -87,10 +85,10 @@ namespace river_test_record_callback {
TEST(TestALL, testInputCallBack) {
audio::river::initString(configurationRiver);
std11::shared_ptr<audio::river::Manager> manager;
std::shared_ptr<audio::river::Manager> manager;
manager = audio::river::Manager::create("testApplication");
APPL_INFO("test input (callback mode)");
std11::shared_ptr<testInCallback> process = std11::make_shared<testInCallback>(manager);
TEST_INFO("test input (callback mode)");
std::shared_ptr<testInCallback> process = std::make_shared<testInCallback>(manager);
process->run();
process.reset();
usleep(500000);
@@ -102,4 +100,3 @@ namespace river_test_record_callback {
#undef __class__
#define __class__ nullptr
#endif

5
test/testRecordRead.h
View File

@@ -3,9 +3,7 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#ifndef __RIVER_TEST_RECORD_READ_H__
#define __RIVER_TEST_RECORD_READ_H__
#pragma once
#undef __class__
#define __class__ "test_record_read"
@@ -17,4 +15,3 @@ namespace river_test_record_read {
#undef __class__
#define __class__ nullptr
#endif

55
test/testVolume.h
View File

@@ -3,9 +3,7 @@
* @copyright 2015, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#ifndef __RIVER_TEST_VOLUME_H__
#define __RIVER_TEST_VOLUME_H__
#pragma once
#undef __class__
#define __class__ "test_volume"
@@ -29,11 +27,11 @@ namespace river_test_volume {
class testCallbackVolume {
private:
std11::shared_ptr<audio::river::Manager> m_manager;
std11::shared_ptr<audio::river::Interface> m_interface;
std::shared_ptr<audio::river::Manager> m_manager;
std::shared_ptr<audio::river::Interface> m_interface;
double m_phase;
public:
testCallbackVolume(std11::shared_ptr<audio::river::Manager> _manager) :
testCallbackVolume(std::shared_ptr<audio::river::Manager> _manager) :
m_manager(_manager),
m_phase(0) {
//Set stereo output:
@@ -45,18 +43,18 @@ namespace river_test_volume {
audio::format_int16,
"speaker");
if(m_interface == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
// set callback mode ...
m_interface->setOutputCallback(std11::bind(&testCallbackVolume::onDataNeeded,
m_interface->setOutputCallback(std::bind(&testCallbackVolume::onDataNeeded,
this,
std11::placeholders::_1,
std11::placeholders::_2,
std11::placeholders::_3,
std11::placeholders::_4,
std11::placeholders::_5,
std11::placeholders::_6));
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6));
m_interface->addVolumeGroup("MEDIA");
m_interface->addVolumeGroup("FLOW");
}
@@ -80,43 +78,43 @@ namespace river_test_volume {
}
void run() {
if(m_interface == nullptr) {
APPL_ERROR("nullptr interface");
TEST_ERROR("nullptr interface");
return;
}
m_interface->start();
usleep(1000000);
m_interface->setParameter("volume", "FLOW", "-3dB");
APPL_INFO(" get volume : " << m_interface->getParameter("volume", "FLOW") );
TEST_INFO(" get volume : " << m_interface->getParameter("volume", "FLOW") );
usleep(500000);
m_interface->setParameter("volume", "FLOW", "-6dB");
APPL_INFO(" get volume : " << m_interface->getParameter("volume", "FLOW") );
TEST_INFO(" get volume : " << m_interface->getParameter("volume", "FLOW") );
usleep(500000);
m_interface->setParameter("volume", "FLOW", "-9dB");
APPL_INFO(" get volume : " << m_interface->getParameter("volume", "FLOW") );
TEST_INFO(" get volume : " << m_interface->getParameter("volume", "FLOW") );
usleep(500000);
m_interface->setParameter("volume", "FLOW", "-12dB");
APPL_INFO(" get volume : " << m_interface->getParameter("volume", "FLOW") );
TEST_INFO(" get volume : " << m_interface->getParameter("volume", "FLOW") );
usleep(500000);
m_interface->setParameter("volume", "FLOW", "-3dB");
APPL_INFO(" get volume : " << m_interface->getParameter("volume", "FLOW") );
TEST_INFO(" get volume : " << m_interface->getParameter("volume", "FLOW") );
usleep(500000);
m_interface->setParameter("volume", "FLOW", "3dB");
APPL_INFO(" get volume : " << m_interface->getParameter("volume", "FLOW") );
TEST_INFO(" get volume : " << m_interface->getParameter("volume", "FLOW") );
usleep(500000);
m_interface->setParameter("volume", "FLOW", "6dB");
APPL_INFO(" get volume : " << m_interface->getParameter("volume", "FLOW") );
TEST_INFO(" get volume : " << m_interface->getParameter("volume", "FLOW") );
usleep(500000);
m_interface->setParameter("volume", "FLOW", "9dB");
APPL_INFO(" get volume : " << m_interface->getParameter("volume", "FLOW") );
TEST_INFO(" get volume : " << m_interface->getParameter("volume", "FLOW") );
usleep(500000);
m_interface->setParameter("volume", "FLOW", "0dB");
APPL_INFO(" get volume : " << m_interface->getParameter("volume", "FLOW") );
TEST_INFO(" get volume : " << m_interface->getParameter("volume", "FLOW") );
usleep(500000);
m_manager->setVolume("MASTER", -3.0f);
APPL_INFO("get volume MASTER: " << m_manager->getVolume("MASTER") );
TEST_INFO("get volume MASTER: " << m_manager->getVolume("MASTER") );
usleep(500000);
m_manager->setVolume("MEDIA", -3.0f);
APPL_INFO("get volume MEDIA: " << m_manager->getVolume("MEDIA") );
TEST_INFO("get volume MEDIA: " << m_manager->getVolume("MEDIA") );
usleep(1000000);
m_interface->stop();
}
@@ -124,9 +122,9 @@ namespace river_test_volume {
TEST(TestALL, testVolume) {
audio::river::initString(configurationRiver);
std11::shared_ptr<audio::river::Manager> manager;
std::shared_ptr<audio::river::Manager> manager;
manager = audio::river::Manager::create("testApplication");
std11::shared_ptr<testCallbackVolume> process = std11::make_shared<testCallbackVolume>(manager);
std::shared_ptr<testCallbackVolume> process = std::make_shared<testCallbackVolume>(manager);
process->run();
process.reset();
usleep(500000);
@@ -138,4 +136,3 @@ namespace river_test_volume {
#undef __class__
#define __class__ nullptr
#endif

159
widget/audio/river/widget/TemporalViewer.cpp Normal file
View File

@@ -0,0 +1,159 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#include <audio/river/widget/debug.h>
#include <audio/river/widget/TemporalViewer.h>
#include <etk/tool.h>
#undef __class__
#define __class__ "TemporalViewer"
static const int32_t nbSecond = 3;
audio::river::widget::TemporalViewer::TemporalViewer() :
m_minVal(-1.0f),
m_maxVal(1.0f),
m_sampleRate(48000) {
addObjectType("audio::river::widget::TemporalViewer");
}
void audio::river::widget::TemporalViewer::init() {
ewol::Widget::init();
m_manager = audio::river::Manager::create("audio::river::widget::TemporalViewer");
m_data.resize(m_sampleRate*3, 0.0);
}
audio::river::widget::TemporalViewer::~TemporalViewer() {
}
void audio::river::widget::TemporalViewer::onDataReceived(const void* _data,
const audio::Time& _time,
size_t _nbChunk,
enum audio::format _format,
uint32_t _frequency,
const std::vector<audio::channel>& _map) {
std::unique_lock<std::mutex> lock(m_mutex);
if (_format != audio::format_float) {
std::cout << "[ERROR] call wrong type ... (need int16_t)" << std::endl;
}
// get the curent power of the signal.
const float* data = static_cast<const float*>(_data);
for (size_t iii=0; iii<_nbChunk*_map.size(); ++iii) {
m_data.push_back(data[iii]);
}
/*
if (m_data.size()>m_sampleRate*nbSecond*10) {
m_data.erase(m_data.begin(), m_data.begin()+(m_data.size()-m_sampleRate*nbSecond));
}
*/
//markToRedraw();
}
void audio::river::widget::TemporalViewer::recordToggle() {
std::unique_lock<std::mutex> lock(m_mutex);
if (m_interface == nullptr) {
//Get the generic input:
std::vector<audio::channel> channel;
channel.push_back(audio::channel_frontLeft);
m_interface = m_manager->createInput(m_sampleRate,
channel,
audio::format_float,
"microphone");
if(m_interface == nullptr) {
ARW_ERROR("nullptr interface");
return;
}
// set callback mode ...
m_interface->setInputCallback(std::bind(&audio::river::widget::TemporalViewer::onDataReceived,
this,
std::placeholders::_1,
std::placeholders::_2,
std::placeholders::_3,
std::placeholders::_4,
std::placeholders::_5,
std::placeholders::_6));
// start the stream
m_interface->start();
periodicCallEnable();
} else {
m_interface->stop();
m_interface.reset();
periodicCallDisable();
}
}
void audio::river::widget::TemporalViewer::onDraw() {
m_draw.draw();
}
void audio::river::widget::TemporalViewer::onRegenerateDisplay() {
//!< Check if we really need to redraw the display, if not needed, we redraw the previous data ...
if (needRedraw() == false) {
return;
}
// remove previous data
m_draw.clear();
// set background
m_draw.setColor(etk::color::black);
m_draw.setPos(vec2(0,0));
m_draw.rectangleWidth(m_size);
std::unique_lock<std::mutex> lock(m_mutex);
if (m_data.size() == 0) {
return;
}
// create n section for display:
int32_t nbSlot = m_size.x();
int32_t sizeSlot = m_size.x()/nbSlot;
std::vector<float> list;
//ARW_INFO("nbSlot : " << nbSlot << " sizeSlot=" << sizeSlot << " m_size=" << m_size);
list.resize(nbSlot,0.0f);
int32_t step = m_sampleRate*nbSecond/nbSlot;
for (size_t kkk=0; kkk<m_sampleRate*nbSecond; ++kkk) {
int32_t id = kkk/step;
if (id < list.size()) {
if (kkk < m_data.size()) {
list[id] = std::max(list[id],m_data[kkk]);
}
}
}
// set all the line:
m_draw.setColor(etk::color::white);
m_draw.setThickness(1);
float origin = m_size.y()*0.5f;
float ratioY = m_size.y() / (m_maxVal - m_minVal);
float baseX = 0;
for (size_t iii=1; iii<list.size(); ++iii) {
m_draw.setPos(vec2(iii*sizeSlot, origin - ratioY*list[iii]));
m_draw.rectangle(vec2((iii+1)*sizeSlot, origin + ratioY*list[iii]));
if ((iii+1)*sizeSlot > m_size.x()) {
ARW_ERROR("wrong display position");
}
}
}
void audio::river::widget::TemporalViewer::periodicCall(const ewol::event::Time& _event) {
std::unique_lock<std::mutex> lock(m_mutex);
int32_t nbSampleDelta = _event.getDeltaCall() * float(m_sampleRate);
if (m_data.size()>m_sampleRate*nbSecond) {
if (nbSampleDelta < m_data.size()) {
m_data.erase(m_data.begin(), m_data.begin()+nbSampleDelta);
} else {
m_data.erase(m_data.begin(), m_data.begin()+(m_data.size()-m_sampleRate*nbSecond));
}
}
markToRedraw();
}

59
widget/audio/river/widget/TemporalViewer.h Normal file
View File

@@ -0,0 +1,59 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#pragma once
#include <ewol/widget/Widget.h>
#include <ewol/compositing/Drawing.h>
#include <audio/river/river.h>
#include <audio/river/Manager.h>
#include <audio/river/Interface.h>
#include <mutex>
namespace audio {
namespace river {
namespace widget {
class TemporalViewer : public ewol::Widget {
private:
mutable std::mutex m_mutex;
private:
ewol::compositing::Drawing m_draw; //!< drawing instance
protected:
//! @brief constructor
TemporalViewer();
void init();
public:
DECLARE_WIDGET_FACTORY(TemporalViewer, "TemporalViewer");
//! @brief destructor
virtual ~TemporalViewer();
void recordToggle();
void generateToggle() {
// ...
}
private:
std::vector<float> m_data;
private:
float m_minVal; //!< display minimum value
float m_maxVal; //!< display maximum value
public: // herited function
virtual void onDraw();
virtual void onRegenerateDisplay();
virtual void periodicCall(const ewol::event::Time& _event);
private:
std::shared_ptr<audio::river::Manager> m_manager;
std::shared_ptr<audio::river::Interface> m_interface;
void onDataReceived(const void* _data,
const audio::Time& _time,
size_t _nbChunk,
enum audio::format _format,
uint32_t _frequency,
const std::vector<audio::channel>& _map);
int32_t m_sampleRate;
};
}
}
}

13
widget/audio/river/widget/debug.cpp Normal file
View File

@@ -0,0 +1,13 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#include <audio/river/widget/debug.h>
int32_t audio::river::widget::getLogId() {
static int32_t g_val = elog::registerInstance("audio-river-widget");
return g_val;
}

43
widget/audio/river/widget/debug.h Normal file
View File

@@ -0,0 +1,43 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#pragma once
#include <elog/log.h>
namespace audio {
namespace river {
namespace widget {
int32_t getLogId();
}
}
}
#define ARW_BASE(info,data) ELOG_BASE(audio::river::widget::getLogId(),info,data)
#define ARW_PRINT(data) ARW_BASE(-1, data)
#define ARW_CRITICAL(data) ARW_BASE(1, data)
#define ARW_ERROR(data) ARW_BASE(2, data)
#define ARW_WARNING(data) ARW_BASE(3, data)
#ifdef DEBUG
#define ARW_INFO(data) ARW_BASE(4, data)
#define ARW_DEBUG(data) ARW_BASE(5, data)
#define ARW_VERBOSE(data) ARW_BASE(6, data)
#define ARW_TODO(data) ARW_BASE(4, "TODO : " << data)
#else
#define ARW_INFO(data) do { } while(false)
#define ARW_DEBUG(data) do { } while(false)
#define ARW_VERBOSE(data) do { } while(false)
#define ARW_TODO(data) do { } while(false)
#endif
#define ARW_ASSERT(cond,data) \
do { \
if (!(cond)) { \
ARW_CRITICAL(data); \
assert(!#cond); \
} \
} while (0)

42
widget/lutin_audio-river-widget.py Normal file
View File

@@ -0,0 +1,42 @@
#!/usr/bin/python
import lutin.module as module
import lutin.tools as tools
import lutin.debug as debug
import os
def get_type():
return "LIBRARY"
def get_desc():
return "audio specific widget"
def get_licence():
return "APACHE-2"
def get_compagny_type():
return "com"
def get_compagny_name():
return "atria-soft"
def get_maintainer():
return ["Mr DUPIN Edouard <yui.heero@gmail.com>"]
def get_version():
return [0,0,0]
def create(target, module_name):
my_module = module.Module(__file__, module_name, get_type())
my_module.add_src_file([
'audio/river/widget/TemporalViewer.cpp',
'audio/river/widget/debug.cpp'
])
my_module.add_header_file([
'audio/river/widget/TemporalViewer.h'
])
my_module.add_module_depend(['ewol', 'audio-river'])
my_module.add_path(tools.get_current_path(__file__))
return my_module