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

[RENAME] change airtaudio => river

Browse Source
This commit is contained in:
Edouard DUPIN 2015-02-05 19:10:53 +01:00
parent e0e9b1670d
commit e7a23e6b8d
14 changed files with 214 additions and 214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
lutin_airtio.py → lutin_river.py
View File

@ -4,21 +4,21 @@ import lutinTools as tools
import lutinDebug as debug
def get_desc():
return "airtio : Multi-nodal audio interface"
return "river : Multi-nodal audio interface"
def create(target):
myModule = module.Module(__file__, 'airtio', 'LIBRARY')
myModule = module.Module(__file__, 'river', 'LIBRARY')
myModule.add_src_file([
'airtio/debug.cpp',
'airtio/Manager.cpp',
'airtio/Interface.cpp',
'airtio/io/Node.cpp',
'airtio/io/Manager.cpp'
'river/debug.cpp',
'river/Manager.cpp',
'river/Interface.cpp',
'river/io/Node.cpp',
'river/io/Manager.cpp'
])
myModule.add_module_depend(['airtaudio', 'airtalgo', 'ejson'])
myModule.add_module_depend(['audio', 'airtaudio', 'drain', 'ejson'])
myModule.add_export_path(tools.get_current_path(__file__))
# add the currrent module at the

6
lutin_airtio_test.py → lutin_river_test.py
View File

@ -4,11 +4,11 @@ import lutinTools as tools
import lutinDebug as debug
def get_desc():
return "airtio_test : Multi-nodal audio interface test"
return "river_test : Multi-nodal audio interface test"
def create(target):
myModule = module.Module(__file__, 'airtio_test', 'BINARY')
myModule = module.Module(__file__, 'river_test', 'BINARY')
myModule.add_src_file([
'test/main.cpp',
@ -16,7 +16,7 @@ def create(target):
])
myModule.copy_folder('data/*')
myModule.add_module_depend(['airtio', 'gtest', 'etk'])
myModule.add_module_depend(['river', 'gtest', 'etk'])
# add the currrent module at the
return myModule

130
airtio/Interface.cpp → river/Interface.cpp
View File

@ -7,16 +7,16 @@
#include "debug.h"
#include "Interface.h"
#include "io/Node.h"
#include <airtalgo/EndPointCallback.h>
#include <airtalgo/EndPointWrite.h>
#include <airtalgo/EndPointRead.h>
#include <airtalgo/Volume.h>
#include <drain/EndPointCallback.h>
#include <drain/EndPointWrite.h>
#include <drain/EndPointRead.h>
#include <drain/Volume.h>
#undef __class__
#define __class__ "Interface"
airtio::Interface::Interface(void) :
river::Interface::Interface(void) :
m_node(nullptr),
m_freq(8000),
m_map(),
@ -26,41 +26,41 @@ airtio::Interface::Interface(void) :
}
bool airtio::Interface::init(const std::string& _name,
bool river::Interface::init(const std::string& _name,
float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std::shared_ptr<airtio::io::Node>& _node) {
const std::shared_ptr<river::io::Node>& _node) {
m_name = _name;
m_node = _node;
m_freq = _freq;
m_map = _map;
m_format = _format;
m_process = std::make_shared<airtalgo::Process>();
m_process = std::make_shared<drain::Process>();
m_volume = 0.0f;
// register interface to be notify from the volume change.
m_node->registerAsRemote(shared_from_this());
// Create convertion interface
if (m_node->isInput() == true) {
// add all time the volume stage :
std::shared_ptr<airtalgo::Volume> algo = airtalgo::Volume::create();
std::shared_ptr<drain::Volume> algo = drain::Volume::create();
algo->setInputFormat(m_node->getInterfaceFormat());
algo->setName("volume");
m_process->pushBack(algo);
AIRTIO_INFO("add basic volume stage (1)");
std::shared_ptr<airtalgo::VolumeElement> tmpVolume = m_node->getVolume();
std::shared_ptr<drain::VolumeElement> tmpVolume = m_node->getVolume();
if (tmpVolume != nullptr) {
AIRTIO_INFO(" add volume for node");
algo->addVolumeStage(tmpVolume);
}
} else {
// add all time the volume stage :
std::shared_ptr<airtalgo::Volume> algo = airtalgo::Volume::create();
std::shared_ptr<drain::Volume> algo = drain::Volume::create();
algo->setOutputFormat(m_node->getInterfaceFormat());
algo->setName("volume");
m_process->pushBack(algo);
AIRTIO_INFO("add basic volume stage (2)");
std::shared_ptr<airtalgo::VolumeElement> tmpVolume = m_node->getVolume();
std::shared_ptr<drain::VolumeElement> tmpVolume = m_node->getVolume();
if (tmpVolume != nullptr) {
AIRTIO_INFO(" add volume for node");
algo->addVolumeStage(tmpVolume);
@ -69,81 +69,81 @@ bool airtio::Interface::init(const std::string& _name,
return true;
}
std::shared_ptr<airtio::Interface> airtio::Interface::create(const std::string& _name,
std::shared_ptr<river::Interface> river::Interface::create(const std::string& _name,
float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std::shared_ptr<airtio::io::Node>& _node) {
std::shared_ptr<airtio::Interface> out = std::shared_ptr<airtio::Interface>(new airtio::Interface());
const std::shared_ptr<river::io::Node>& _node) {
std::shared_ptr<river::Interface> out = std::shared_ptr<river::Interface>(new river::Interface());
out->init(_name, _freq, _map, _format, _node);
return out;
}
airtio::Interface::~Interface() {
river::Interface::~Interface() {
//stop(true, true);
std::unique_lock<std::recursive_mutex> lock(m_mutex);
//m_node->interfaceRemove(shared_from_this());
m_process.reset();
}
/*
bool airtio::Interface::hasEndPoint() {
bool river::Interface::hasEndPoint() {
}
*/
void airtio::Interface::setReadwrite() {
void river::Interface::setReadwrite() {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
m_process->removeAlgoDynamic();
if (m_process->hasType<airtalgo::EndPoint>() ) {
if (m_process->hasType<drain::EndPoint>() ) {
AIRTIO_ERROR("Endpoint is already present ==> can not change");
return;
}
if (m_node->isInput() == true) {
m_process->removeIfLast<airtalgo::EndPoint>();
std::shared_ptr<airtalgo::EndPointRead> algo = airtalgo::EndPointRead::create();
///algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
m_process->removeIfLast<drain::EndPoint>();
std::shared_ptr<drain::EndPointRead> algo = drain::EndPointRead::create();
///algo->setInputFormat(drain::IOFormatInterface(m_map, m_format, m_freq));
algo->setOutputFormat(drain::IOFormatInterface(m_map, m_format, m_freq));
m_process->pushBack(algo);
} else {
m_process->removeIfFirst<airtalgo::EndPoint>();
std::shared_ptr<airtalgo::EndPointWrite> algo = airtalgo::EndPointWrite::create();
algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
//algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
m_process->removeIfFirst<drain::EndPoint>();
std::shared_ptr<drain::EndPointWrite> algo = drain::EndPointWrite::create();
algo->setInputFormat(drain::IOFormatInterface(m_map, m_format, m_freq));
//algo->setOutputFormat(drain::IOFormatInterface(m_map, m_format, m_freq));
m_process->pushFront(algo);
}
}
void airtio::Interface::setOutputCallback(size_t _chunkSize, airtalgo::needDataFunction _function) {
void river::Interface::setOutputCallback(size_t _chunkSize, drain::needDataFunction _function) {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
m_process->removeAlgoDynamic();
m_process->removeIfFirst<airtalgo::EndPoint>();
std::shared_ptr<airtalgo::Algo> algo = airtalgo::EndPointCallback::create(_function);
m_process->removeIfFirst<drain::EndPoint>();
std::shared_ptr<drain::Algo> algo = drain::EndPointCallback::create(_function);
AIRTIO_INFO("set property: " << m_map << " " << m_format << " " << m_freq);
algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
//algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
algo->setInputFormat(drain::IOFormatInterface(m_map, m_format, m_freq));
//algo->setOutputFormat(drain::IOFormatInterface(m_map, m_format, m_freq));
m_process->pushFront(algo);
}
void airtio::Interface::setInputCallback(size_t _chunkSize, airtalgo::haveNewDataFunction _function) {
void river::Interface::setInputCallback(size_t _chunkSize, drain::haveNewDataFunction _function) {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
m_process->removeAlgoDynamic();
m_process->removeIfLast<airtalgo::EndPoint>();
std::shared_ptr<airtalgo::Algo> algo = airtalgo::EndPointCallback::create(_function);
//algo->setInputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
algo->setOutputFormat(airtalgo::IOFormatInterface(m_map, m_format, m_freq));
m_process->removeIfLast<drain::EndPoint>();
std::shared_ptr<drain::Algo> algo = drain::EndPointCallback::create(_function);
//algo->setInputFormat(drain::IOFormatInterface(m_map, m_format, m_freq));
algo->setOutputFormat(drain::IOFormatInterface(m_map, m_format, m_freq));
m_process->pushBack(algo);
}
void airtio::Interface::setWriteCallback(airtalgo::needDataFunctionWrite _function) {
void river::Interface::setWriteCallback(drain::needDataFunctionWrite _function) {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
m_process->removeAlgoDynamic();
std::shared_ptr<airtalgo::EndPointWrite> algo = m_process->get<airtalgo::EndPointWrite>(0);
std::shared_ptr<drain::EndPointWrite> algo = m_process->get<drain::EndPointWrite>(0);
if (algo == nullptr) {
return;
}
algo->setCallback(_function);
}
void airtio::Interface::start(const std::chrono::system_clock::time_point& _time) {
void river::Interface::start(const std::chrono::system_clock::time_point& _time) {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
AIRTIO_DEBUG("start [BEGIN]");
m_process->updateInterAlgo();
@ -151,21 +151,21 @@ void airtio::Interface::start(const std::chrono::system_clock::time_point& _time
AIRTIO_DEBUG("start [ END ]");
}
void airtio::Interface::stop(bool _fast, bool _abort) {
void river::Interface::stop(bool _fast, bool _abort) {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
AIRTIO_DEBUG("stop [BEGIN]");
m_node->interfaceRemove(shared_from_this());
AIRTIO_DEBUG("stop [ END]");
}
void airtio::Interface::abort() {
void river::Interface::abort() {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
AIRTIO_DEBUG("abort [BEGIN]");
// TODO :...
AIRTIO_DEBUG("abort [ END ]");
}
bool airtio::Interface::setParameter(const std::string& _filter, const std::string& _parameter, const std::string& _value) {
bool river::Interface::setParameter(const std::string& _filter, const std::string& _parameter, const std::string& _value) {
AIRTIO_DEBUG("setParameter [BEGIN] : '" << _filter << "':'" << _parameter << "':'" << _value << "'");
bool out = false;
if ( _filter == "volume"
@ -173,7 +173,7 @@ bool airtio::Interface::setParameter(const std::string& _filter, const std::stri
AIRTIO_ERROR("Interface is not allowed to modify '" << _parameter << "' Volume just allowed to modify 'FLOW' volume");
return false;
}
std::shared_ptr<airtalgo::Algo> algo = m_process->get<airtalgo::Algo>(_filter);
std::shared_ptr<drain::Algo> algo = m_process->get<drain::Algo>(_filter);
if (algo == nullptr) {
AIRTIO_ERROR("setParameter(" << _filter << ") ==> no filter named like this ...");
return false;
@ -182,10 +182,10 @@ bool airtio::Interface::setParameter(const std::string& _filter, const std::stri
AIRTIO_DEBUG("setParameter [ END ] : '" << out << "'");
return out;
}
std::string airtio::Interface::getParameter(const std::string& _filter, const std::string& _parameter) const {
std::string river::Interface::getParameter(const std::string& _filter, const std::string& _parameter) const {
AIRTIO_DEBUG("getParameter [BEGIN] : '" << _filter << "':'" << _parameter << "'");
std::string out;
std::shared_ptr<airtalgo::Algo> algo = m_process->get<airtalgo::Algo>(_filter);
std::shared_ptr<drain::Algo> algo = m_process->get<drain::Algo>(_filter);
if (algo == nullptr) {
AIRTIO_ERROR("setParameter(" << _filter << ") ==> no filter named like this ...");
return "[ERROR]";
@ -194,10 +194,10 @@ std::string airtio::Interface::getParameter(const std::string& _filter, const st
AIRTIO_DEBUG("getParameter [ END ] : '" << out << "'");
return out;
}
std::string airtio::Interface::getParameterProperty(const std::string& _filter, const std::string& _parameter) const {
std::string river::Interface::getParameterProperty(const std::string& _filter, const std::string& _parameter) const {
AIRTIO_DEBUG("getParameterProperty [BEGIN] : '" << _filter << "':'" << _parameter << "'");
std::string out;
std::shared_ptr<airtalgo::Algo> algo = m_process->get<airtalgo::Algo>(_filter);
std::shared_ptr<drain::Algo> algo = m_process->get<drain::Algo>(_filter);
if (algo == nullptr) {
AIRTIO_ERROR("setParameter(" << _filter << ") ==> no filter named like this ...");
return "[ERROR]";
@ -207,10 +207,10 @@ std::string airtio::Interface::getParameterProperty(const std::string& _filter,
return out;
}
void airtio::Interface::write(const void* _value, size_t _nbChunk) {
void river::Interface::write(const void* _value, size_t _nbChunk) {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
m_process->updateInterAlgo();
std::shared_ptr<airtalgo::EndPointWrite> algo = m_process->get<airtalgo::EndPointWrite>(0);
std::shared_ptr<drain::EndPointWrite> algo = m_process->get<drain::EndPointWrite>(0);
if (algo == nullptr) {
return;
}
@ -219,7 +219,7 @@ void airtio::Interface::write(const void* _value, size_t _nbChunk) {
#if 0
// TODO : add API aCCess mutex for Read and write...
std::vector<int16_t> airtio::Interface::read(size_t _nbChunk) {
std::vector<int16_t> river::Interface::read(size_t _nbChunk) {
// TODO :...
std::vector<int16_t> data;
/*
@ -242,78 +242,78 @@ std::vector<int16_t> airtio::Interface::read(size_t _nbChunk) {
}
#endif
void airtio::Interface::read(void* _value, size_t _nbChunk) {
void river::Interface::read(void* _value, size_t _nbChunk) {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
m_process->updateInterAlgo();
// TODO :...
}
size_t airtio::Interface::size() const {
size_t river::Interface::size() const {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
// TODO :...
return 0;
}
void airtio::Interface::setBufferSize(size_t _nbChunk) {
void river::Interface::setBufferSize(size_t _nbChunk) {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
m_process->updateInterAlgo();
// TODO :...
}
void airtio::Interface::setBufferSize(const std::chrono::duration<int64_t, std::micro>& _time) {
void river::Interface::setBufferSize(const std::chrono::duration<int64_t, std::micro>& _time) {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
m_process->updateInterAlgo();
// TODO :...
}
void airtio::Interface::clearInternalBuffer() {
void river::Interface::clearInternalBuffer() {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
m_process->updateInterAlgo();
// TODO :...
}
std::chrono::system_clock::time_point airtio::Interface::getCurrentTime() const {
std::chrono::system_clock::time_point river::Interface::getCurrentTime() const {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
// TODO :...
return std::chrono::system_clock::time_point();
return std::chrono::system_clock::now();
}
void airtio::Interface::addVolumeGroup(const std::string& _name) {
void river::Interface::addVolumeGroup(const std::string& _name) {
std::unique_lock<std::recursive_mutex> lock(m_mutex);
AIRTIO_DEBUG("addVolumeGroup(" << _name << ")");
std::shared_ptr<airtalgo::Volume> algo = m_process->get<airtalgo::Volume>("volume");
std::shared_ptr<drain::Volume> algo = m_process->get<drain::Volume>("volume");
if (algo == nullptr) {
AIRTIO_ERROR("addVolumeGroup(" << _name << ") ==> no volume stage ... can not add it ...");
return;
}
if (_name == "FLOW") {
// Local volume name
algo->addVolumeStage(std::make_shared<airtalgo::VolumeElement>(_name));
algo->addVolumeStage(std::make_shared<drain::VolumeElement>(_name));
} else {
// get manager unique instance:
std::shared_ptr<airtio::io::Manager> mng = airtio::io::Manager::getInstance();
std::shared_ptr<river::io::Manager> mng = river::io::Manager::getInstance();
algo->addVolumeStage(mng->getVolumeGroup(_name));
}
}
void airtio::Interface::systemNewInputData(std::chrono::system_clock::time_point _time, void* _data, size_t _nbChunk) {
void river::Interface::systemNewInputData(std::chrono::system_clock::time_point _time, void* _data, size_t _nbChunk) {
std::unique_lock<std::recursive_mutex> lockProcess(m_mutex);
m_process->push(_time, _data, _nbChunk);
}
void airtio::Interface::systemNeedOutputData(std::chrono::system_clock::time_point _time, void* _data, size_t _nbChunk, size_t _chunkSize) {
void river::Interface::systemNeedOutputData(std::chrono::system_clock::time_point _time, void* _data, size_t _nbChunk, size_t _chunkSize) {
std::unique_lock<std::recursive_mutex> lockProcess(m_mutex);
m_process->pull(_time, _data, _nbChunk, _chunkSize);
}
void airtio::Interface::systemVolumeChange() {
void river::Interface::systemVolumeChange() {
std::unique_lock<std::recursive_mutex> lockProcess(m_mutex);
std::shared_ptr<airtalgo::Volume> algo = m_process->get<airtalgo::Volume>("volume");
std::shared_ptr<drain::Volume> algo = m_process->get<drain::Volume>("volume");
if (algo == nullptr) {
return;
}

22
airtio/Interface.h → river/Interface.h
View File

@ -15,12 +15,12 @@
#include <mutex>
#include <audio/format.h>
#include <audio/channel.h>
#include <airtalgo/Process.h>
#include <airtalgo/EndPointCallback.h>
#include <airtalgo/EndPointWrite.h>
#include <drain/Process.h>
#include <drain/EndPointCallback.h>
#include <drain/EndPointWrite.h>
#include <memory>
namespace airtio {
namespace river {
namespace io {
class Node;
}
@ -30,11 +30,11 @@ namespace airtio {
protected:
mutable std::recursive_mutex m_mutex;
protected:
std::shared_ptr<airtio::io::Node> m_node;
std::shared_ptr<river::io::Node> m_node;
float m_freq;
std::vector<audio::channel> m_map;
audio::format m_format;
std::shared_ptr<airtalgo::Process> m_process;
std::shared_ptr<drain::Process> m_process;
protected:
std::string m_name;
public:
@ -50,7 +50,7 @@ namespace airtio {
float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std::shared_ptr<airtio::io::Node>& _node);
const std::shared_ptr<river::io::Node>& _node);
public:
/**
* @brief Destructor
@ -60,7 +60,7 @@ namespace airtio {
float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std::shared_ptr<airtio::io::Node>& _node);
const std::shared_ptr<river::io::Node>& _node);
/**
* @brief set the read/write mode enable.
*/
@ -68,9 +68,9 @@ namespace airtio {
/**
* @brief When we want to implement a Callback Mode:
*/
virtual void setWriteCallback(airtalgo::needDataFunctionWrite _function);
virtual void setOutputCallback(size_t _chunkSize, airtalgo::needDataFunction _function);
virtual void setInputCallback(size_t _chunkSize, airtalgo::haveNewDataFunction _function);
virtual void setWriteCallback(drain::needDataFunctionWrite _function);
virtual void setOutputCallback(size_t _chunkSize, drain::needDataFunction _function);
virtual void setInputCallback(size_t _chunkSize, drain::haveNewDataFunction _function);
/**
* @brief Add a volume group of the current channel.
* @note If you do not call this function with the group "FLOW" you chan not have a channel volume.

44
airtio/Manager.cpp → river/Manager.cpp
View File

@ -16,75 +16,75 @@
#undef __class__
#define __class__ "Manager"
std::shared_ptr<airtio::Manager> airtio::Manager::create(const std::string& _applicationUniqueId) {
return std::shared_ptr<airtio::Manager>(new airtio::Manager(_applicationUniqueId));
std::shared_ptr<river::Manager> river::Manager::create(const std::string& _applicationUniqueId) {
return std::shared_ptr<river::Manager>(new river::Manager(_applicationUniqueId));
}
airtio::Manager::Manager(const std::string& _applicationUniqueId) :
river::Manager::Manager(const std::string& _applicationUniqueId) :
m_applicationUniqueId(_applicationUniqueId),
m_listOpenInterface() {
}
airtio::Manager::~Manager() {
river::Manager::~Manager() {
// TODO : Stop all interfaces...
}
std::vector<std::pair<std::string,std::string> > airtio::Manager::getListStreamInput() {
std::vector<std::pair<std::string,std::string> > river::Manager::getListStreamInput() {
std::vector<std::pair<std::string,std::string> > output;
//output.push_back(std::make_pair<std::string,std::string>("default", "48000 Hz, 16 bits, 2 channels: Default input "));
return output;
}
std::vector<std::pair<std::string,std::string> > airtio::Manager::getListStreamOutput() {
std::vector<std::pair<std::string,std::string> > river::Manager::getListStreamOutput() {
std::vector<std::pair<std::string,std::string> > output;
//output.push_back(std::make_pair<std::string,std::string>("default", "48000 Hz, 16 bits, 2 channels: Default output "));
return output;
}
bool airtio::Manager::setVolume(const std::string& _volumeName, float _valuedB) {
return airtio::io::Manager::getInstance()->setVolume(_volumeName, _valuedB);
bool river::Manager::setVolume(const std::string& _volumeName, float _valuedB) {
return river::io::Manager::getInstance()->setVolume(_volumeName, _valuedB);
}
float airtio::Manager::getVolume(const std::string& _volumeName) const {
return airtio::io::Manager::getInstance()->getVolume(_volumeName);
float river::Manager::getVolume(const std::string& _volumeName) const {
return river::io::Manager::getInstance()->getVolume(_volumeName);
}
std::pair<float,float> airtio::Manager::getVolumeRange(const std::string& _volumeName) const {
return airtio::io::Manager::getInstance()->getVolumeRange(_volumeName);
std::pair<float,float> river::Manager::getVolumeRange(const std::string& _volumeName) const {
return river::io::Manager::getInstance()->getVolumeRange(_volumeName);
}
std::shared_ptr<airtio::Interface> airtio::Manager::createOutput(float _freq,
std::shared_ptr<river::Interface> river::Manager::createOutput(float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std::string& _streamName,
const std::string& _name) {
// get global hardware interface:
std::shared_ptr<airtio::io::Manager> manager = airtio::io::Manager::getInstance();
std::shared_ptr<river::io::Manager> manager = river::io::Manager::getInstance();
// get the output or input channel :
std::shared_ptr<airtio::io::Node> node = manager->getNode(_streamName);//, false);
std::shared_ptr<river::io::Node> node = manager->getNode(_streamName);//, false);
// create user iterface:
std::shared_ptr<airtio::Interface> interface;
interface = airtio::Interface::create(_name, _freq, _map, _format, node);
std::shared_ptr<river::Interface> interface;
interface = river::Interface::create(_name, _freq, _map, _format, node);
// store it in a list (needed to apply some parameters).
m_listOpenInterface.push_back(interface);
return interface;
}
std::shared_ptr<airtio::Interface> airtio::Manager::createInput(float _freq,
std::shared_ptr<river::Interface> river::Manager::createInput(float _freq,
const std::vector<audio::channel>& _map,
audio::format _format,
const std::string& _streamName,
const std::string& _name) {
// get global hardware interface:
std::shared_ptr<airtio::io::Manager> manager = airtio::io::Manager::getInstance();
std::shared_ptr<river::io::Manager> manager = river::io::Manager::getInstance();
// get the output or input channel :
std::shared_ptr<airtio::io::Node> node = manager->getNode(_streamName);//, true);
std::shared_ptr<river::io::Node> node = manager->getNode(_streamName);//, true);
// create user iterface:
std::shared_ptr<airtio::Interface> interface;
interface = airtio::Interface::create(_name, _freq, _map, _format, node);
std::shared_ptr<river::Interface> interface;
interface = river::Interface::create(_name, _freq, _map, _format, node);
// store it in a list (needed to apply some parameters).
m_listOpenInterface.push_back(interface);
return interface;

8
airtio/Manager.h → river/Manager.h
View File

@ -10,25 +10,25 @@
#include <string>
#include <stdint.h>
#include <memory>
#include <airtio/Interface.h>
#include <river/Interface.h>
#include <audio/format.h>
#include <audio/channel.h>
namespace airtio {
namespace river {
/**
* @brief Audio interface manager : Single interface for every application that want to access on the Audio input/output
*/
class Manager {
private:
const std::string& m_applicationUniqueId; //!< name of the application that open the Audio Interface.
std::vector<std::weak_ptr<airtio::Interface> > m_listOpenInterface; //!< List of all open Stream.
std::vector<std::weak_ptr<river::Interface> > m_listOpenInterface; //!< List of all open Stream.
protected:
/**
* @brief Constructor
*/
Manager(const std::string& _applicationUniqueId);
public:
static std::shared_ptr<airtio::Manager> create(const std::string& _applicationUniqueId);
static std::shared_ptr<river::Manager> create(const std::string& _applicationUniqueId);
/**
* @brief Destructor
*/

6
airtio/debug.cpp → river/debug.cpp
View File

@ -4,10 +4,10 @@
* @license APACHE v2.0 (see license file)
*/
#include <airtio/debug.h>
#include <river/debug.h>
int32_t airtio::getLogId() {
static int32_t g_val = etk::log::registerInstance("airtio");
int32_t river::getLogId() {
static int32_t g_val = etk::log::registerInstance("river");
return g_val;
}

6
airtio/debug.h → river/debug.h
View File

@ -10,17 +10,17 @@
#include <etk/log.h>
namespace airtio {
namespace river {
int32_t getLogId();
};
// TODO : Review this problem of multiple intanciation of "std::stringbuf sb"
#define AIRTIO_BASE(info,data) \
do { \
if (info <= etk::log::getLevel(airtio::getLogId())) { \
if (info <= etk::log::getLevel(river::getLogId())) { \
std::stringbuf sb; \
std::ostream tmpStream(&sb); \
tmpStream << data; \
etk::log::logStream(airtio::getLogId(), info, __LINE__, __class__, __func__, tmpStream); \
etk::log::logStream(river::getLogId(), info, __LINE__, __class__, __func__, tmpStream); \
} \
} while(0)

0
airtio/debugRemove.h → river/debugRemove.h
View File

30
airtio/io/Manager.cpp → river/io/Manager.cpp
View File

@ -6,27 +6,27 @@
#include "Manager.h"
#include <memory>
#include <airtio/debug.h>
#include <river/debug.h>
#include "Node.h"
#undef __class__
#define __class__ "io::Manager"
airtio::io::Manager::Manager() {
river::io::Manager::Manager() {
if (m_config.load("DATA:hardware.json") == false) {
AIRTIO_ERROR("you must set a basic configuration file for harware configuration: DATA:hardware.json");
}
};
std::shared_ptr<airtio::io::Manager> airtio::io::Manager::getInstance() {
static std::shared_ptr<airtio::io::Manager> manager(new Manager());
std::shared_ptr<river::io::Manager> river::io::Manager::getInstance() {
static std::shared_ptr<river::io::Manager> manager(new Manager());
return manager;
}
std::shared_ptr<airtio::io::Node> airtio::io::Manager::getNode(const std::string& _name) {
std::shared_ptr<river::io::Node> river::io::Manager::getNode(const std::string& _name) {
for (size_t iii=0; iii< m_list.size(); ++iii) {
std::shared_ptr<airtio::io::Node> tmppp = m_list[iii].lock();
std::shared_ptr<river::io::Node> tmppp = m_list[iii].lock();
if ( tmppp != nullptr
&& _name == tmppp->getName()) {
return tmppp;
@ -35,7 +35,7 @@ std::shared_ptr<airtio::io::Node> airtio::io::Manager::getNode(const std::string
// check if the node can be open :
const std::shared_ptr<const ejson::Object> tmpObject = m_config.getObject(_name);
if (tmpObject != nullptr) {
std::shared_ptr<airtio::io::Node> tmp = airtio::io::Node::create(_name, tmpObject);
std::shared_ptr<river::io::Node> tmp = river::io::Node::create(_name, tmpObject);
m_list.push_back(tmp);
return tmp;
}
@ -43,7 +43,7 @@ std::shared_ptr<airtio::io::Node> airtio::io::Manager::getNode(const std::string
return nullptr;
}
std::shared_ptr<airtalgo::VolumeElement> airtio::io::Manager::getVolumeGroup(const std::string& _name) {
std::shared_ptr<drain::VolumeElement> river::io::Manager::getVolumeGroup(const std::string& _name) {
if (_name == "") {
AIRTIO_ERROR("Try to create an audio group with no name ...");
return nullptr;
@ -57,13 +57,13 @@ std::shared_ptr<airtalgo::VolumeElement> airtio::io::Manager::getVolumeGroup(con
}
}
AIRTIO_DEBUG("Add a new volume group : '" << _name << "'");
std::shared_ptr<airtalgo::VolumeElement> tmpVolume = std::make_shared<airtalgo::VolumeElement>(_name);
std::shared_ptr<drain::VolumeElement> tmpVolume = std::make_shared<drain::VolumeElement>(_name);
m_volumeGroup.push_back(tmpVolume);
return tmpVolume;
}
bool airtio::io::Manager::setVolume(const std::string& _volumeName, float _valuedB) {
std::shared_ptr<airtalgo::VolumeElement> volume = getVolumeGroup(_volumeName);
bool river::io::Manager::setVolume(const std::string& _volumeName, float _valuedB) {
std::shared_ptr<drain::VolumeElement> volume = getVolumeGroup(_volumeName);
if (volume == nullptr) {
AIRTIO_ERROR("Can not set volume ... : '" << _volumeName << "'");
return false;
@ -75,7 +75,7 @@ bool airtio::io::Manager::setVolume(const std::string& _volumeName, float _value
}
volume->setVolume(_valuedB);
for (auto &it2 : m_list) {
std::shared_ptr<airtio::io::Node> val = it2.lock();
std::shared_ptr<river::io::Node> val = it2.lock();
if (val != nullptr) {
val->volumeChange();
}
@ -83,8 +83,8 @@ bool airtio::io::Manager::setVolume(const std::string& _volumeName, float _value
return true;
}
float airtio::io::Manager::getVolume(const std::string& _volumeName) {
std::shared_ptr<airtalgo::VolumeElement> volume = getVolumeGroup(_volumeName);
float river::io::Manager::getVolume(const std::string& _volumeName) {
std::shared_ptr<drain::VolumeElement> volume = getVolumeGroup(_volumeName);
if (volume == nullptr) {
AIRTIO_ERROR("Can not get volume ... : '" << _volumeName << "'");
return 0.0f;
@ -92,6 +92,6 @@ float airtio::io::Manager::getVolume(const std::string& _volumeName) {
return volume->getVolume();
}
std::pair<float,float> airtio::io::Manager::getVolumeRange(const std::string& _volumeName) const {
std::pair<float,float> river::io::Manager::getVolumeRange(const std::string& _volumeName) const {
return std::make_pair<float,float>(-300, 300);
}

14
airtio/io/Manager.h → river/io/Manager.h
View File

@ -17,9 +17,9 @@
#include <audio/channel.h>
#include <ejson/ejson.h>
#include <memory>
#include <airtalgo/Volume.h>
#include <drain/Volume.h>
namespace airtio {
namespace river {
namespace io {
class Node;
class Manager {
@ -36,14 +36,14 @@ namespace airtio {
virtual ~Manager() {};
private:
ejson::Document m_config; // harware configuration
std::vector<std::shared_ptr<airtio::io::Node> > m_listKeepAlive; //!< list of all Node that might be keep alive sone time
std::vector<std::weak_ptr<airtio::io::Node> > m_list; //!< List of all IO node
std::vector<std::shared_ptr<river::io::Node> > m_listKeepAlive; //!< list of all Node that might be keep alive sone time
std::vector<std::weak_ptr<river::io::Node> > m_list; //!< List of all IO node
public:
std::shared_ptr<airtio::io::Node> getNode(const std::string& _name);
std::shared_ptr<river::io::Node> getNode(const std::string& _name);
private:
std::vector<std::shared_ptr<airtalgo::VolumeElement>> m_volumeGroup;
std::vector<std::shared_ptr<drain::VolumeElement>> m_volumeGroup;
public:
std::shared_ptr<airtalgo::VolumeElement> getVolumeGroup(const std::string& _name);
std::shared_ptr<drain::VolumeElement> getVolumeGroup(const std::string& _name);
/**
* @brief Set a volume for a specific group

32
airtio/io/Node.cpp → river/io/Node.cpp
View File

@ -5,7 +5,7 @@
*/
#include "Node.h"
#include <airtio/debug.h>
#include <river/debug.h>
#include <memory>
@ -25,7 +25,7 @@
#define INT32_MIN (-INT32_MAX - 1L)
#endif
int32_t airtio::io::Node::rtAudioCallback(void* _outputBuffer,
int32_t river::io::Node::rtAudioCallback(void* _outputBuffer,
void* _inputBuffer,
unsigned int _nBufferFrames,
double _streamTime,
@ -74,11 +74,11 @@ int32_t airtio::io::Node::rtAudioCallback(void* _outputBuffer,
}
std::shared_ptr<airtio::io::Node> airtio::io::Node::create(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config) {
return std::shared_ptr<airtio::io::Node>(new airtio::io::Node(_name, _config));
std::shared_ptr<river::io::Node> river::io::Node::create(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config) {
return std::shared_ptr<river::io::Node>(new river::io::Node(_name, _config));
}
airtio::io::Node::Node(const std::string& _name, const std::shared_ptr<const ejson::Object>& _config) :
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) {
@ -147,7 +147,7 @@ airtio::io::Node::Node(const std::string& _name, const std::shared_ptr<const ejs
if (volumeName != "") {
AIRTIO_INFO("add node volume stage : '" << volumeName << "'");
// use global manager for volume ...
m_volume = airtio::io::Manager::getInstance()->getVolumeGroup(volumeName);
m_volume = river::io::Manager::getInstance()->getVolumeGroup(volumeName);
}
enum audio::format formatType = audio::format_int16;
@ -257,7 +257,7 @@ airtio::io::Node::Node(const std::string& _name, const std::shared_ptr<const ejs
if (m_isInput == true) {
err = m_adac.openStream(nullptr, &params,
airtaudio::SINT16, m_hardwareFormat.getFrequency(), &m_rtaudioFrameSize,
std::bind(&airtio::io::Node::rtAudioCallback,
std::bind(&river::io::Node::rtAudioCallback,
this,
std::placeholders::_1,
std::placeholders::_2,
@ -268,7 +268,7 @@ airtio::io::Node::Node(const std::string& _name, const std::shared_ptr<const ejs
} else {
err = m_adac.openStream(&params, nullptr,
airtaudio::SINT16, m_hardwareFormat.getFrequency(), &m_rtaudioFrameSize,
std::bind(&airtio::io::Node::rtAudioCallback,
std::bind(&river::io::Node::rtAudioCallback,
this,
std::placeholders::_1,
std::placeholders::_2,
@ -282,7 +282,7 @@ airtio::io::Node::Node(const std::string& _name, const std::shared_ptr<const ejs
}
}
airtio::io::Node::~Node() {
river::io::Node::~Node() {
std::unique_lock<std::mutex> lock(m_mutex);
AIRTIO_INFO("-----------------------------------------------------------------");
AIRTIO_INFO("-- DESTROY NODE --");
@ -293,7 +293,7 @@ airtio::io::Node::~Node() {
}
};
void airtio::io::Node::start() {
void river::io::Node::start() {
std::unique_lock<std::mutex> lock(m_mutex);
AIRTIO_INFO("Start stream : '" << m_name << "' mode=" << (m_isInput?"input":"output") );
enum airtaudio::errorType err = m_adac.startStream();
@ -302,7 +302,7 @@ void airtio::io::Node::start() {
}
}
void airtio::io::Node::stop() {
void river::io::Node::stop() {
std::unique_lock<std::mutex> lock(m_mutex);
AIRTIO_INFO("Stop stream : '" << m_name << "' mode=" << (m_isInput?"input":"output") );
enum airtaudio::errorType err = m_adac.stopStream();
@ -311,7 +311,7 @@ void airtio::io::Node::stop() {
}
}
void airtio::io::Node::registerAsRemote(const std::shared_ptr<airtio::Interface>& _interface) {
void river::io::Node::registerAsRemote(const std::shared_ptr<river::Interface>& _interface) {
auto it = m_listAvaillable.begin();
while (it != m_listAvaillable.end()) {
if (it->expired() == true) {
@ -322,7 +322,7 @@ void airtio::io::Node::registerAsRemote(const std::shared_ptr<airtio::Interface>
m_listAvaillable.push_back(_interface);
}
void airtio::io::Node::interfaceAdd(const std::shared_ptr<airtio::Interface>& _interface) {
void river::io::Node::interfaceAdd(const std::shared_ptr<river::Interface>& _interface) {
{
std::unique_lock<std::mutex> lock(m_mutex);
for (size_t iii=0; iii< m_list.size(); ++iii) {
@ -338,7 +338,7 @@ void airtio::io::Node::interfaceAdd(const std::shared_ptr<airtio::Interface>& _i
}
}
void airtio::io::Node::interfaceRemove(const std::shared_ptr<airtio::Interface>& _interface) {
void river::io::Node::interfaceRemove(const std::shared_ptr<river::Interface>& _interface) {
{
std::unique_lock<std::mutex> lock(m_mutex);
for (size_t iii=0; iii< m_list.size(); ++iii) {
@ -356,9 +356,9 @@ void airtio::io::Node::interfaceRemove(const std::shared_ptr<airtio::Interface>&
}
void airtio::io::Node::volumeChange() {
void river::io::Node::volumeChange() {
for (auto &it : m_listAvaillable) {
std::shared_ptr<airtio::Interface> node = it.lock();
std::shared_ptr<river::Interface> node = it.lock();
if (node != nullptr) {
node->systemVolumeChange();
}

28
airtio/io/Node.h → river/io/Node.h
View File

@ -17,19 +17,19 @@
#include <audio/channel.h>
#include "Manager.h"
#include <memory>
#include <airtio/Interface.h>
#include <river/Interface.h>
#include <airtaudio/Interface.h>
#include <airtalgo/IOFormatInterface.h>
#include <airtalgo/Volume.h>
#include <drain/IOFormatInterface.h>
#include <drain/Volume.h>
namespace airtio {
namespace river {
namespace io {
class Manager;
class Node {
private:
mutable std::mutex m_mutex;
std::shared_ptr<const ejson::Object> m_config;
std::shared_ptr<airtalgo::VolumeElement> m_volume; //!< if a volume is set it is set here ...
std::shared_ptr<drain::VolumeElement> m_volume; //!< if a volume is set it is set here ...
private:
/**
* @brief Constructor
@ -42,12 +42,12 @@ namespace airtio {
*/
virtual ~Node();
private:
std::vector<std::weak_ptr<airtio::Interface> > m_listAvaillable; //!< List of all interface that exist on this Node
std::vector<std::shared_ptr<airtio::Interface> > m_list;
std::vector<std::weak_ptr<river::Interface> > m_listAvaillable; //!< List of all interface that exist on this Node
std::vector<std::shared_ptr<river::Interface> > m_list;
public:
void registerAsRemote(const std::shared_ptr<airtio::Interface>& _interface);
void interfaceAdd(const std::shared_ptr<airtio::Interface>& _interface);
void interfaceRemove(const std::shared_ptr<airtio::Interface>& _interface);
void registerAsRemote(const std::shared_ptr<river::Interface>& _interface);
void interfaceAdd(const std::shared_ptr<river::Interface>& _interface);
void interfaceRemove(const std::shared_ptr<river::Interface>& _interface);
private:
airtaudio::Interface m_adac; //!< Real audio interface
airtaudio::DeviceInfo m_info;
@ -65,13 +65,13 @@ namespace airtio {
return m_name;
}
private:
airtalgo::IOFormatInterface m_interfaceFormat;
drain::IOFormatInterface m_interfaceFormat;
public:
const airtalgo::IOFormatInterface& getInterfaceFormat() {
const drain::IOFormatInterface& getInterfaceFormat() {
return m_interfaceFormat;
}
private:
airtalgo::IOFormatInterface m_hardwareFormat;
drain::IOFormatInterface m_hardwareFormat;
private:
bool m_isInput;
public:
@ -85,7 +85,7 @@ namespace airtio {
void start();
void stop();
public:
const std::shared_ptr<airtalgo::VolumeElement>& getVolume() {
const std::shared_ptr<drain::VolumeElement>& getVolume() {
return m_volume;
}
public:

86
test/main.cpp
View File

@ -5,8 +5,8 @@
*/
#include "debug.h"
#include <airtio/Manager.h>
#include <airtio/Interface.h>
#include <river/Manager.h>
#include <river/Interface.h>
#include <gtest/gtest.h>
#include <etk/os/FSNode.h>
@ -19,10 +19,10 @@
class testOutWrite {
private:
std::vector<audio::channel> m_channelMap;
std::shared_ptr<airtio::Manager> m_manager;
std::shared_ptr<airtio::Interface> m_interface;
std::shared_ptr<river::Manager> m_manager;
std::shared_ptr<river::Interface> m_interface;
public:
testOutWrite(std::shared_ptr<airtio::Manager> _manager) :
testOutWrite(std::shared_ptr<river::Manager> _manager) :
m_manager(_manager) {
//Set stereo output:
m_channelMap.push_back(audio::channel_frontLeft);
@ -72,8 +72,8 @@ class testOutWrite {
};
TEST(TestALL, testOutputWrite) {
std::shared_ptr<airtio::Manager> manager;
manager = airtio::Manager::create("testApplication");
std::shared_ptr<river::Manager> manager;
manager = river::Manager::create("testApplication");
APPL_INFO("test output (write mode)");
std::shared_ptr<testOutWrite> process = std::make_shared<testOutWrite>(manager);
@ -85,11 +85,11 @@ TEST(TestALL, testOutputWrite) {
class testOutWriteCallback {
private:
std::shared_ptr<airtio::Manager> m_manager;
std::shared_ptr<airtio::Interface> m_interface;
std::shared_ptr<river::Manager> m_manager;
std::shared_ptr<river::Interface> m_interface;
double m_phase;
public:
testOutWriteCallback(std::shared_ptr<airtio::Manager> _manager) :
testOutWriteCallback(std::shared_ptr<river::Manager> _manager) :
m_manager(_manager),
m_phase(0) {
std::vector<audio::channel> channelMap;
@ -139,8 +139,8 @@ class testOutWriteCallback {
};
TEST(TestALL, testOutputWriteWithCallback) {
std::shared_ptr<airtio::Manager> manager;
manager = airtio::Manager::create("testApplication");
std::shared_ptr<river::Manager> manager;
manager = river::Manager::create("testApplication");
APPL_INFO("test output (write with callback event mode)");
std::shared_ptr<testOutWriteCallback> process = std::make_shared<testOutWriteCallback>(manager);
@ -152,11 +152,11 @@ TEST(TestALL, testOutputWriteWithCallback) {
class testOutCallback {
private:
std::shared_ptr<airtio::Manager> m_manager;
std::shared_ptr<airtio::Interface> m_interface;
std::shared_ptr<river::Manager> m_manager;
std::shared_ptr<river::Interface> m_interface;
double m_phase;
public:
testOutCallback(std::shared_ptr<airtio::Manager> _manager) :
testOutCallback(std::shared_ptr<river::Manager> _manager) :
m_manager(_manager),
m_phase(0) {
//Set stereo output:
@ -207,8 +207,8 @@ class testOutCallback {
};
TEST(TestALL, testOutputCallBack) {
std::shared_ptr<airtio::Manager> manager;
manager = airtio::Manager::create("testApplication");
std::shared_ptr<river::Manager> manager;
manager = river::Manager::create("testApplication");
APPL_INFO("test output (callback mode)");
std::shared_ptr<testOutCallback> process = std::make_shared<testOutCallback>(manager);
@ -221,10 +221,10 @@ TEST(TestALL, testOutputCallBack) {
class testInRead {
private:
std::vector<audio::channel> m_channelMap;
std::shared_ptr<airtio::Manager> m_manager;
std::shared_ptr<airtio::Interface> m_interface;
std::shared_ptr<river::Manager> m_manager;
std::shared_ptr<river::Interface> m_interface;
public:
testInRead(std::shared_ptr<airtio::Manager> _manager) :
testInRead(std::shared_ptr<river::Manager> _manager) :
m_manager(_manager){
//Set stereo output:
m_channelMap.push_back(audio::channel_frontLeft);
@ -253,8 +253,8 @@ class testInRead {
};
TEST(TestALL, testInputCallBack) {
std::shared_ptr<airtio::Manager> manager;
manager = airtio::Manager::create("testApplication");
std::shared_ptr<river::Manager> manager;
manager = river::Manager::create("testApplication");
APPL_INFO("test input (callback mode)");
std::shared_ptr<testInCallback> process = std::make_shared<testInCallback>(manager);
process->run();
@ -265,11 +265,11 @@ TEST(TestALL, testInputCallBack) {
class testInCallback {
private:
std::shared_ptr<airtio::Manager> m_manager;
std::shared_ptr<airtio::Interface> m_interface;
std::shared_ptr<river::Manager> m_manager;
std::shared_ptr<river::Interface> m_interface;
double m_phase;
public:
testInCallback(std::shared_ptr<airtio::Manager> _manager) :
testInCallback(std::shared_ptr<river::Manager> _manager) :
m_manager(_manager),
m_phase(0) {
//Set stereo output:
@ -316,8 +316,8 @@ class testInCallback {
};
TEST(TestALL, testInputCallBack) {
std::shared_ptr<airtio::Manager> manager;
manager = airtio::Manager::create("testApplication");
std::shared_ptr<river::Manager> manager;
manager = river::Manager::create("testApplication");
APPL_INFO("test input (callback mode)");
std::shared_ptr<testInCallback> process = std::make_shared<testInCallback>(manager);
process->run();
@ -328,15 +328,15 @@ TEST(TestALL, testInputCallBack) {
class testOutCallbackType {
private:
std::shared_ptr<airtio::Manager> m_manager;
std::shared_ptr<airtio::Interface> m_interface;
std::shared_ptr<river::Manager> m_manager;
std::shared_ptr<river::Interface> m_interface;
double m_phase;
float m_freq;
int32_t m_nbChannels;
float m_generateFreq;
public:
testOutCallbackType(const std::shared_ptr<airtio::Manager>& _manager,
testOutCallbackType(const std::shared_ptr<river::Manager>& _manager,
float _freq=48000.0f,
int32_t _nbChannels=2,
audio::format _format=audio::format_int16) :
@ -445,8 +445,8 @@ class testOutCallbackType {
class testResampling : public ::testing::TestWithParam<float> {};
TEST_P(testResampling, base) {
std::shared_ptr<airtio::Manager> manager;
manager = airtio::Manager::create("testApplication");
std::shared_ptr<river::Manager> manager;
manager = river::Manager::create("testApplication");
std::shared_ptr<testOutCallbackType> process = std::make_shared<testOutCallbackType>(manager, GetParam(), 2, audio::format_int16);
process->run();
process.reset();
@ -460,8 +460,8 @@ INSTANTIATE_TEST_CASE_P(InstantiationName,
class testFormat : public ::testing::TestWithParam<audio::format> {};
TEST_P(testFormat, base) {
std::shared_ptr<airtio::Manager> manager;
manager = airtio::Manager::create("testApplication");
std::shared_ptr<river::Manager> manager;
manager = river::Manager::create("testApplication");
std::shared_ptr<testOutCallbackType> process = std::make_shared<testOutCallbackType>(manager, 48000, 2, GetParam());
process->run();
process.reset();
@ -474,8 +474,8 @@ INSTANTIATE_TEST_CASE_P(InstantiationName,
class testChannels : public ::testing::TestWithParam<int32_t> {};
TEST_P(testChannels, base) {
std::shared_ptr<airtio::Manager> manager;
manager = airtio::Manager::create("testApplication");
std::shared_ptr<river::Manager> manager;
manager = river::Manager::create("testApplication");
std::shared_ptr<testOutCallbackType> process = std::make_shared<testOutCallbackType>(manager, 48000, GetParam(), audio::format_int16);
process->run();
process.reset();
@ -489,11 +489,11 @@ INSTANTIATE_TEST_CASE_P(InstantiationName,
class testCallbackVolume {
private:
std::shared_ptr<airtio::Manager> m_manager;
std::shared_ptr<airtio::Interface> m_interface;
std::shared_ptr<river::Manager> m_manager;
std::shared_ptr<river::Interface> m_interface;
double m_phase;
public:
testCallbackVolume(std::shared_ptr<airtio::Manager> _manager) :
testCallbackVolume(std::shared_ptr<river::Manager> _manager) :
m_manager(_manager),
m_phase(0) {
//Set stereo output:
@ -579,8 +579,8 @@ class testCallbackVolume {
TEST(TestALL, testVolume) {
std::shared_ptr<airtio::Manager> manager;
manager = airtio::Manager::create("testApplication");
std::shared_ptr<river::Manager> manager;
manager = river::Manager::create("testApplication");
std::shared_ptr<testCallbackVolume> process = std::make_shared<testCallbackVolume>(manager);
process->run();
process.reset();
@ -588,8 +588,8 @@ TEST(TestALL, testVolume) {
}
TEST(TestALL, testChannelsFormatResampling) {
std::shared_ptr<airtio::Manager> manager;
manager = airtio::Manager::create("testApplication");
std::shared_ptr<river::Manager> manager;
manager = river::Manager::create("testApplication");
APPL_INFO("test convert flaot to output (callback mode)");
std::vector<float> listFreq;
listFreq.push_back(4000);