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

[DEV] WORK on a port for BOOST

Browse Source
This commit is contained in:
Edouard DUPIN 2015-02-24 22:20:11 +01:00
parent 3a9ce1ffd9
commit 1d5ac5fecb
24 changed files with 152 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
airtaudio/Api.cpp
View File

@ -57,8 +57,8 @@ airtaudio::Api::~Api() {
enum airtaudio::error airtaudio::Api::startStream() { enum airtaudio::error airtaudio::Api::startStream() {
ATA_VERBOSE("Start Stream"); ATA_VERBOSE("Start Stream");
m_startTime = std::chrono::system_clock::now(); m_startTime = std11::chrono::system_clock::now();
m_duration = std::chrono::duration<int64_t, std::micro>(0); m_duration = std11::chrono::microseconds(0);
return airtaudio::error_none; return airtaudio::error_none;
} }
@ -176,9 +176,9 @@ bool airtaudio::Api::probeDeviceOpen(uint32_t /*device*/,
} }
void airtaudio::Api::tickStreamTime() { void airtaudio::Api::tickStreamTime() {
//ATA_WARNING("tick : size=" << m_bufferSize << " rate=" << m_sampleRate << " time=" << std::chrono::nanoseconds((int64_t(m_bufferSize) * int64_t(1000000000)) / int64_t(m_sampleRate)).count()); //ATA_WARNING("tick : size=" << m_bufferSize << " rate=" << m_sampleRate << " time=" << std11::chrono::nanoseconds((int64_t(m_bufferSize) * int64_t(1000000000)) / int64_t(m_sampleRate)).count());
//ATA_WARNING(" one element=" << std::chrono::nanoseconds((int64_t(1000000000)) / int64_t(m_sampleRate)).count()); //ATA_WARNING(" one element=" << std11::chrono::nanoseconds((int64_t(1000000000)) / int64_t(m_sampleRate)).count());
m_duration += std::chrono::nanoseconds((int64_t(m_bufferSize) * int64_t(1000000000)) / int64_t(m_sampleRate)); m_duration += std11::chrono::nanoseconds((int64_t(m_bufferSize) * int64_t(1000000000)) / int64_t(m_sampleRate));
} }
long airtaudio::Api::getStreamLatency() { long airtaudio::Api::getStreamLatency() {
@ -197,9 +197,9 @@ long airtaudio::Api::getStreamLatency() {
return totalLatency; return totalLatency;
} }
std::chrono::system_clock::time_point airtaudio::Api::getStreamTime() { std11::chrono::system_clock::time_point airtaudio::Api::getStreamTime() {
if (verifyStream() != airtaudio::error_none) { if (verifyStream() != airtaudio::error_none) {
return std::chrono::system_clock::time_point(); return std11::chrono::system_clock::time_point();
} }
return m_startTime + m_duration; return m_startTime + m_duration;
} }
@ -226,8 +226,8 @@ void airtaudio::Api::clearStreamInfo() {
m_bufferSize = 0; m_bufferSize = 0;
m_nBuffers = 0; m_nBuffers = 0;
m_userFormat = audio::format_unknow; m_userFormat = audio::format_unknow;
m_startTime = std::chrono::system_clock::time_point(); m_startTime = std11::chrono::system_clock::time_point();
m_duration = std::chrono::nanoseconds(0); m_duration = std11::chrono::nanoseconds(0);
m_deviceBuffer = nullptr; m_deviceBuffer = nullptr;
m_callback = nullptr; m_callback = nullptr;
for (int32_t iii=0; iii<2; ++iii) { for (int32_t iii=0; iii<2; ++iii) {

24
airtaudio/Api.h
View File

@ -9,7 +9,6 @@
#define __AIRTAUDIO_API_H__ #define __AIRTAUDIO_API_H__
#include <sstream> #include <sstream>
#include <chrono>
#include <airtaudio/debug.h> #include <airtaudio/debug.h>
#include <airtaudio/type.h> #include <airtaudio/type.h>
#include <airtaudio/state.h> #include <airtaudio/state.h>
@ -27,13 +26,12 @@ namespace airtaudio {
* @param _nbChunk The number of chunk of input or output chunk in the buffer (same size). * @param _nbChunk The number of chunk of input or output chunk in the buffer (same size).
* @param _status List of error that occured in the laps of time. * @param _status List of error that occured in the laps of time.
*/ */
typedef std::function<int32_t (const void* _inputBuffer, typedef std11::function<int32_t (const void* _inputBuffer,
const std::chrono::system_clock::time_point& _timeInput, const std11::chrono::system_clock::time_point& _timeInput,
void* _outputBuffer, void* _outputBuffer,
const std::chrono::system_clock::time_point& _timeOutput, const std11::chrono::system_clock::time_point& _timeOutput,
uint32_t _nbChunk, uint32_t _nbChunk,
const std::vector<airtaudio::status>& _status)> AirTAudioCallback; const std::vector<airtaudio::status>& _status)> AirTAudioCallback;
// A protected structure used for buffer conversion. // A protected structure used for buffer conversion.
class ConvertInfo { class ConvertInfo {
public: public:
@ -73,7 +71,7 @@ namespace airtaudio {
virtual enum airtaudio::error abortStream() = 0; virtual enum airtaudio::error abortStream() = 0;
long getStreamLatency(); long getStreamLatency();
uint32_t getStreamSampleRate(); uint32_t getStreamSampleRate();
virtual std::chrono::time_point<std::chrono::system_clock> getStreamTime(); virtual std11::chrono::system_clock::time_point getStreamTime();
bool isStreamOpen() const { bool isStreamOpen() const {
return m_state != airtaudio::state_closed; return m_state != airtaudio::state_closed;
} }
@ -82,7 +80,7 @@ namespace airtaudio {
} }
protected: protected:
mutable std::mutex m_mutex; mutable std11::mutex m_mutex;
airtaudio::AirTAudioCallback m_callback; airtaudio::AirTAudioCallback m_callback;
uint32_t m_device[2]; // Playback and record, respectively. uint32_t m_device[2]; // Playback and record, respectively.
enum airtaudio::mode m_mode; // airtaudio::mode_output, airtaudio::mode_input, or airtaudio::mode_duplex. enum airtaudio::mode m_mode; // airtaudio::mode_output, airtaudio::mode_input, or airtaudio::mode_duplex.
@ -103,9 +101,9 @@ namespace airtaudio {
enum audio::format m_deviceFormat[2]; // Playback and record, respectively. enum audio::format m_deviceFormat[2]; // Playback and record, respectively.
airtaudio::ConvertInfo m_convertInfo[2]; airtaudio::ConvertInfo m_convertInfo[2];
//std::chrono::system_clock::time_point //std11::chrono::system_clock::time_point
std::chrono::system_clock::time_point m_startTime; //!< start time of the stream (restart at every stop, pause ...) std11::chrono::system_clock::time_point m_startTime; //!< start time of the stream (restart at every stop, pause ...)
std::chrono::nanoseconds m_duration; //!< duration from wich the stream is started std11::chrono::nanoseconds m_duration; //!< duration from wich the stream is started
/** /**
* @brief api-specific method that attempts to open a device * @brief api-specific method that attempts to open a device

16
airtaudio/Interface.cpp
View File

@ -17,8 +17,8 @@ std::vector<enum airtaudio::type> airtaudio::Interface::getCompiledApi() {
std::vector<enum airtaudio::type> apis; std::vector<enum airtaudio::type> apis;
// The order here will control the order of RtAudio's API search in // The order here will control the order of RtAudio's API search in
// the constructor. // the constructor.
for (auto &it : m_apiAvaillable) { for (size_t iii=0; iii<m_apiAvaillable.size(); ++iii) {
apis.push_back(it.first); apis.push_back(m_apiAvaillable[iii].first);
} }
return apis; return apis;
} }
@ -28,11 +28,11 @@ std::vector<enum airtaudio::type> airtaudio::Interface::getCompiledApi() {
void airtaudio::Interface::openRtApi(enum airtaudio::type _api) { void airtaudio::Interface::openRtApi(enum airtaudio::type _api) {
delete m_rtapi; delete m_rtapi;
m_rtapi = nullptr; m_rtapi = nullptr;
for (auto &it :m_apiAvaillable) { for (size_t iii=0; iii<m_apiAvaillable.size(); ++iii) {
ATA_INFO("try open " << it.first); ATA_INFO("try open " << m_apiAvaillable[iii].first);
if (_api == it.first) { if (_api == m_apiAvaillable[iii].first) {
ATA_INFO(" ==> call it"); ATA_INFO(" ==> call it");
m_rtapi = it.second(); m_rtapi = m_apiAvaillable[iii].second();
if (m_rtapi != nullptr) { if (m_rtapi != nullptr) {
return; return;
} }
@ -118,9 +118,9 @@ enum airtaudio::error airtaudio::Interface::instanciate(enum airtaudio::type _ap
// one with at least one device or we reach the end of the list. // one with at least one device or we reach the end of the list.
std::vector<enum airtaudio::type> apis = getCompiledApi(); std::vector<enum airtaudio::type> apis = getCompiledApi();
ATA_INFO(" find : " << apis.size() << " apis."); ATA_INFO(" find : " << apis.size() << " apis.");
for (auto &it : apis) { for (size_t iii=0; iii<apis.size(); ++iii) {
ATA_INFO("try open ..."); ATA_INFO("try open ...");
openRtApi(it); openRtApi(apis[iii]);
if(m_rtapi == nullptr) { if(m_rtapi == nullptr) {
ATA_ERROR(" ==> can not create ..."); ATA_ERROR(" ==> can not create ...");
continue; continue;

6
airtaudio/Interface.h
View File

@ -36,7 +36,7 @@ namespace airtaudio {
*/ */
class Interface { class Interface {
protected: protected:
std::vector<std::pair<enum airtaudio::type, Api* (*)()>> m_apiAvaillable; std::vector<std::pair<enum airtaudio::type, Api* (*)()> > m_apiAvaillable;
protected: protected:
airtaudio::Api *m_rtapi; airtaudio::Api *m_rtapi;
public: public:
@ -267,9 +267,9 @@ namespace airtaudio {
* @brief If a stream is not open, an RtError (type = INVALID_USE) will be thrown. * @brief If a stream is not open, an RtError (type = INVALID_USE) will be thrown.
* @return the number of elapsed seconds since the stream was started. * @return the number of elapsed seconds since the stream was started.
*/ */
std::chrono::time_point<std::chrono::system_clock> getStreamTime() { std11::chrono::system_clock::time_point getStreamTime() {
if (m_rtapi == nullptr) { if (m_rtapi == nullptr) {
return std::chrono::time_point<std::chrono::system_clock>(); return std11::chrono::system_clock::time_point();
} }
return m_rtapi->getStreamTime(); return m_rtapi->getStreamTime();
} }

109
airtaudio/api/Alsa.cpp
View File

@ -28,13 +28,14 @@ namespace airtaudio {
snd_pcm_t *handles[2]; snd_pcm_t *handles[2];
bool synchronized; bool synchronized;
bool xrun[2]; bool xrun[2];
std::condition_variable runnable_cv; std11::condition_variable runnable_cv;
bool runnable; bool runnable;
std::unique_ptr<std::thread> thread; std11::thread* thread;
bool threadRunning; bool threadRunning;
AlsaPrivate() : AlsaPrivate() :
synchronized(false), synchronized(false),
runnable(false), runnable(false),
thread(nullptr),
threadRunning(false) { threadRunning(false) {
handles[0] = nullptr; handles[0] = nullptr;
handles[1] = nullptr; handles[1] = nullptr;
@ -300,11 +301,21 @@ probeParameters:
} }
// Test our discrete set of sample rate values. // Test our discrete set of sample rate values.
info.sampleRates.clear(); info.sampleRates.clear();
for (auto &it : airtaudio::genericSampleRate()) { #if __cplusplus >= 201103L
if (snd_pcm_hw_params_test_rate(phandle, params, it, 0) == 0) { for (auto &it : airtaudio::genericSampleRate()) {
info.sampleRates.push_back(it); if (snd_pcm_hw_params_test_rate(phandle, params, it, 0) == 0) {
info.sampleRates.push_back(it);
}
} }
} #else
for (std::vector<uint32_t>::const_iterator it(airtaudio::genericSampleRate().begin());
it != airtaudio::genericSampleRate().end();
++it ) {
if (snd_pcm_hw_params_test_rate(phandle, params, *it, 0) == 0) {
info.sampleRates.push_back(*it);
}
}
#endif
if (info.sampleRates.size() == 0) { if (info.sampleRates.size() == 0) {
snd_pcm_close(phandle); snd_pcm_close(phandle);
ATA_ERROR("no supported sample rates found for device (" << name << ")."); ATA_ERROR("no supported sample rates found for device (" << name << ").");
@ -696,8 +707,7 @@ foundDevice:
m_mode = _mode; m_mode = _mode;
// Setup callback thread. // Setup callback thread.
m_private->threadRunning = true; m_private->threadRunning = true;
std::unique_ptr<std::thread> tmpThread(new std::thread(&airtaudio::api::Alsa::alsaCallbackEvent, this)); m_private->thread = new std11::thread(&airtaudio::api::Alsa::alsaCallbackEvent, this);
m_private->thread = std::move(tmpThread);
if (m_private->thread == nullptr) { if (m_private->thread == nullptr) {
m_private->threadRunning = false; m_private->threadRunning = false;
ATA_ERROR("creating callback thread!"); ATA_ERROR("creating callback thread!");
@ -742,6 +752,7 @@ enum airtaudio::error airtaudio::api::Alsa::closeStream() {
m_mutex.unlock(); m_mutex.unlock();
if (m_private->thread != nullptr) { if (m_private->thread != nullptr) {
m_private->thread->join(); m_private->thread->join();
m_private->thread = nullptr;
} }
if (m_state == airtaudio::state_running) { if (m_state == airtaudio::state_running) {
m_state = airtaudio::state_stopped; m_state = airtaudio::state_stopped;
@ -786,7 +797,7 @@ enum airtaudio::error airtaudio::api::Alsa::startStream() {
ATA_ERROR("the stream is already running!"); ATA_ERROR("the stream is already running!");
return airtaudio::error_warning; return airtaudio::error_warning;
} }
std::unique_lock<std::mutex> lck(m_mutex); std11::unique_lock<std11::mutex> lck(m_mutex);
int32_t result = 0; int32_t result = 0;
snd_pcm_state_t state; snd_pcm_state_t state;
snd_pcm_t **handle = (snd_pcm_t **) m_private->handles; snd_pcm_t **handle = (snd_pcm_t **) m_private->handles;
@ -844,7 +855,7 @@ enum airtaudio::error airtaudio::api::Alsa::stopStream() {
return airtaudio::error_warning; return airtaudio::error_warning;
} }
m_state = airtaudio::state_stopped; m_state = airtaudio::state_stopped;
std::unique_lock<std::mutex> lck(m_mutex); std11::unique_lock<std11::mutex> lck(m_mutex);
int32_t result = 0; int32_t result = 0;
snd_pcm_t **handle = (snd_pcm_t **) m_private->handles; snd_pcm_t **handle = (snd_pcm_t **) m_private->handles;
if ( m_mode == airtaudio::mode_output if ( m_mode == airtaudio::mode_output
@ -884,7 +895,7 @@ enum airtaudio::error airtaudio::api::Alsa::abortStream() {
return airtaudio::error_warning; return airtaudio::error_warning;
} }
m_state = airtaudio::state_stopped; m_state = airtaudio::state_stopped;
std::unique_lock<std::mutex> lck(m_mutex); std11::unique_lock<std11::mutex> lck(m_mutex);
int32_t result = 0; int32_t result = 0;
snd_pcm_t **handle = (snd_pcm_t **) m_private->handles; snd_pcm_t **handle = (snd_pcm_t **) m_private->handles;
if ( m_mode == airtaudio::mode_output if ( m_mode == airtaudio::mode_output
@ -925,8 +936,12 @@ void airtaudio::api::Alsa::callbackEvent() {
} }
namespace std { namespace std {
static std::ostream& operator <<(std::ostream& _os, const std::chrono::system_clock::time_point& _obj) { static std::ostream& operator <<(std::ostream& _os, const std11::chrono::system_clock::time_point& _obj) {
std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.time_since_epoch()); #if __cplusplus >= 201103L
std11::chrono::nanoseconds ns = std11::chrono::duration_cast<std11::chrono::nanoseconds>(_obj.time_since_epoch());
#else
boost::chrono::nanoseconds ns = boost::chrono::duration_cast<boost::chrono::nanoseconds>(_obj.time_since_epoch());
#endif
int64_t totalSecond = ns.count()/1000000000; int64_t totalSecond = ns.count()/1000000000;
int64_t millisecond = (ns.count()%1000000000)/1000000; int64_t millisecond = (ns.count()%1000000000)/1000000;
int64_t microsecond = (ns.count()%1000000)/1000; int64_t microsecond = (ns.count()%1000000)/1000;
@ -943,8 +958,8 @@ namespace std {
} }
} }
/* /*
std::chrono::time_point<std::chrono::system_clock> airtaudio::api::Alsa::getStreamTime() { std11::chrono::time_point<std11::chrono::system_clock> airtaudio::api::Alsa::getStreamTime() {
if (m_startTime == std::chrono::system_clock::time_point()) { if (m_startTime == std11::chrono::system_clock::time_point()) {
snd_pcm_uframes_t avail; snd_pcm_uframes_t avail;
snd_htimestamp_t tstamp; snd_htimestamp_t tstamp;
if (m_private->handles[0] != nullptr) { if (m_private->handles[0] != nullptr) {
@ -953,22 +968,22 @@ std::chrono::time_point<std::chrono::system_clock> airtaudio::api::Alsa::getStre
int plop = snd_pcm_htimestamp(m_private->handles[1], &avail, &tstamp); int plop = snd_pcm_htimestamp(m_private->handles[1], &avail, &tstamp);
} }
//ATA_WARNING("plop : " << tstamp.tv_sec << " sec " << tstamp.tv_nsec); //ATA_WARNING("plop : " << tstamp.tv_sec << " sec " << tstamp.tv_nsec);
//return std::chrono::system_clock::from_time_t(tstamp.tv_sec) + std::chrono::nanoseconds(tstamp.tv_nsec); //return std11::chrono::system_clock::from_time_t(tstamp.tv_sec) + std11::chrono::nanoseconds(tstamp.tv_nsec);
m_startTime = std::chrono::system_clock::from_time_t(tstamp.tv_sec) + std::chrono::nanoseconds(tstamp.tv_nsec); m_startTime = std11::chrono::system_clock::from_time_t(tstamp.tv_sec) + std11::chrono::nanoseconds(tstamp.tv_nsec);
m_startTime = std::chrono::system_clock::now(); m_startTime = std11::chrono::system_clock::now();
if (m_private->handles[0] != nullptr) { if (m_private->handles[0] != nullptr) {
//m_startTime += std::chrono::nanoseconds(m_bufferSize*1000000000LL/int64_t(m_sampleRate)); //m_startTime += std11::chrono::nanoseconds(m_bufferSize*1000000000LL/int64_t(m_sampleRate));
snd_pcm_sframes_t frames; snd_pcm_sframes_t frames;
int result = snd_pcm_delay(m_private->handles[0], &frames); int result = snd_pcm_delay(m_private->handles[0], &frames);
m_startTime += std::chrono::nanoseconds(frames*1000000000LL/int64_t(m_sampleRate)); m_startTime += std11::chrono::nanoseconds(frames*1000000000LL/int64_t(m_sampleRate));
} else if (m_private->handles[1] != nullptr) { } else if (m_private->handles[1] != nullptr) {
//m_startTime -= std::chrono::nanoseconds(m_bufferSize*1000000000LL/int64_t(m_sampleRate)); //m_startTime -= std11::chrono::nanoseconds(m_bufferSize*1000000000LL/int64_t(m_sampleRate));
snd_pcm_sframes_t frames; snd_pcm_sframes_t frames;
int result = snd_pcm_delay(m_private->handles[1], &frames); int result = snd_pcm_delay(m_private->handles[1], &frames);
m_startTime -= std::chrono::nanoseconds(frames*1000000000LL/int64_t(m_sampleRate)); m_startTime -= std11::chrono::nanoseconds(frames*1000000000LL/int64_t(m_sampleRate));
} }
m_duration = std::chrono::microseconds(0); m_duration = std11::chrono::microseconds(0);
} }
//ATA_DEBUG(" createTimeStamp : " << m_startTime + m_duration); //ATA_DEBUG(" createTimeStamp : " << m_startTime + m_duration);
@ -977,31 +992,31 @@ std::chrono::time_point<std::chrono::system_clock> airtaudio::api::Alsa::getStre
*/ */
#if 1 #if 1
std::chrono::time_point<std::chrono::system_clock> airtaudio::api::Alsa::getStreamTime() { std11::chrono::system_clock::time_point airtaudio::api::Alsa::getStreamTime() {
if (m_startTime == std::chrono::system_clock::time_point()) { if (m_startTime == std11::chrono::system_clock::time_point()) {
m_startTime = std::chrono::system_clock::now(); m_startTime = std11::chrono::system_clock::now();
// Corection of time stamp with the input properties ... // Corection of time stamp with the input properties ...
if (m_private->handles[0] != nullptr) { if (m_private->handles[0] != nullptr) {
//output //output
snd_pcm_sframes_t frames; snd_pcm_sframes_t frames;
int result = snd_pcm_delay(m_private->handles[0], &frames); int result = snd_pcm_delay(m_private->handles[0], &frames);
m_startTime += std::chrono::nanoseconds(frames*1000000000LL/int64_t(m_sampleRate)); m_startTime += std11::chrono::nanoseconds(frames*1000000000LL/int64_t(m_sampleRate));
} else if (m_private->handles[1] != nullptr) { } else if (m_private->handles[1] != nullptr) {
//input //input
/* /*
snd_pcm_sframes_t frames; snd_pcm_sframes_t frames;
int result = snd_pcm_delay(m_private->handles[1], &frames); int result = snd_pcm_delay(m_private->handles[1], &frames);
m_startTime -= std::chrono::nanoseconds(frames*1000000000LL/int64_t(m_sampleRate)); m_startTime -= std11::chrono::nanoseconds(frames*1000000000LL/int64_t(m_sampleRate));
*/ */
} }
m_duration = std::chrono::microseconds(0); m_duration = std11::chrono::microseconds(0);
} }
//ATA_DEBUG(" createTimeStamp : " << m_startTime + m_duration); //ATA_DEBUG(" createTimeStamp : " << m_startTime + m_duration);
return m_startTime + m_duration; return m_startTime + m_duration;
} }
#else #else
std::chrono::time_point<std::chrono::system_clock> airtaudio::api::Alsa::getStreamTime() { std11::chrono::time_point<std11::chrono::system_clock> airtaudio::api::Alsa::getStreamTime() {
snd_pcm_status_t *status = nullptr; snd_pcm_status_t *status = nullptr;
snd_timestamp_t timestamp; snd_timestamp_t timestamp;
snd_htimestamp_t timestampHighRes; snd_htimestamp_t timestampHighRes;
@ -1009,41 +1024,41 @@ std::chrono::time_point<std::chrono::system_clock> airtaudio::api::Alsa::getStre
if(m_private->handles[1]) { if(m_private->handles[1]) {
snd_pcm_status(m_private->handles[1], status); snd_pcm_status(m_private->handles[1], status);
snd_pcm_status_get_tstamp(status, &timestamp); snd_pcm_status_get_tstamp(status, &timestamp);
m_startTime = std::chrono::system_clock::from_time_t(timestamp.tv_sec) + std::chrono::microseconds(timestamp.tv_usec); m_startTime = std11::chrono::system_clock::from_time_t(timestamp.tv_sec) + std11::chrono::microseconds(timestamp.tv_usec);
ATA_WARNING("time : " << m_startTime); ATA_WARNING("time : " << m_startTime);
snd_pcm_status_get_trigger_tstamp(status, &timestamp); snd_pcm_status_get_trigger_tstamp(status, &timestamp);
m_startTime = std::chrono::system_clock::from_time_t(timestamp.tv_sec) + std::chrono::microseconds(timestamp.tv_usec); m_startTime = std11::chrono::system_clock::from_time_t(timestamp.tv_sec) + std11::chrono::microseconds(timestamp.tv_usec);
ATA_WARNING("snd_pcm_status_get_trigger_tstamp : " << m_startTime); ATA_WARNING("snd_pcm_status_get_trigger_tstamp : " << m_startTime);
snd_pcm_status_get_htstamp(status, &timestampHighRes); snd_pcm_status_get_htstamp(status, &timestampHighRes);
ATA_WARNING("snd_pcm_status_get_htstamp : " << std::chrono::system_clock::from_time_t(timestampHighRes.tv_sec) + std::chrono::nanoseconds(timestampHighRes.tv_nsec);); ATA_WARNING("snd_pcm_status_get_htstamp : " << std11::chrono::system_clock::from_time_t(timestampHighRes.tv_sec) + std11::chrono::nanoseconds(timestampHighRes.tv_nsec););
snd_pcm_status_get_audio_htstamp(status, &timestampHighRes); snd_pcm_status_get_audio_htstamp(status, &timestampHighRes);
ATA_WARNING("snd_pcm_status_get_audio_htstamp : " << std::chrono::system_clock::from_time_t(timestampHighRes.tv_sec) + std::chrono::nanoseconds(timestampHighRes.tv_nsec);); ATA_WARNING("snd_pcm_status_get_audio_htstamp : " << std11::chrono::system_clock::from_time_t(timestampHighRes.tv_sec) + std11::chrono::nanoseconds(timestampHighRes.tv_nsec););
snd_pcm_sframes_t delay = snd_pcm_status_get_delay(status); snd_pcm_sframes_t delay = snd_pcm_status_get_delay(status);
//return m_startTime - std::chrono::nanoseconds(delay*1000000000LL/int64_t(m_sampleRate)); //return m_startTime - std11::chrono::nanoseconds(delay*1000000000LL/int64_t(m_sampleRate));
ATA_WARNING("delay : " << std::chrono::nanoseconds(delay*1000000000LL/int64_t(m_sampleRate)).count() << " ns"); ATA_WARNING("delay : " << std11::chrono::nanoseconds(delay*1000000000LL/int64_t(m_sampleRate)).count() << " ns");
return m_startTime + m_duration; return m_startTime + m_duration;
} }
if(m_private->handles[0]) { if(m_private->handles[0]) {
snd_pcm_status(m_private->handles[0], status); snd_pcm_status(m_private->handles[0], status);
snd_pcm_status_get_tstamp(status, &timestamp); snd_pcm_status_get_tstamp(status, &timestamp);
m_startTime = std::chrono::system_clock::from_time_t(timestamp.tv_sec) + std::chrono::microseconds(timestamp.tv_usec); m_startTime = std11::chrono::system_clock::from_time_t(timestamp.tv_sec) + std11::chrono::microseconds(timestamp.tv_usec);
ATA_WARNING("time : " << m_startTime); ATA_WARNING("time : " << m_startTime);
snd_pcm_status_get_trigger_tstamp(status, &timestamp); snd_pcm_status_get_trigger_tstamp(status, &timestamp);
m_startTime = std::chrono::system_clock::from_time_t(timestamp.tv_sec) + std::chrono::microseconds(timestamp.tv_usec); m_startTime = std11::chrono::system_clock::from_time_t(timestamp.tv_sec) + std11::chrono::microseconds(timestamp.tv_usec);
ATA_WARNING("start : " << m_startTime); ATA_WARNING("start : " << m_startTime);
snd_pcm_sframes_t delay = snd_pcm_status_get_delay(status); snd_pcm_sframes_t delay = snd_pcm_status_get_delay(status);
//return m_startTime + std::chrono::nanoseconds(delay*1000000000LL/int64_t(m_sampleRate)); //return m_startTime + std11::chrono::nanoseconds(delay*1000000000LL/int64_t(m_sampleRate));
ATA_WARNING("delay : " << std::chrono::nanoseconds(delay*1000000000LL/int64_t(m_sampleRate)).count() << " ns"); ATA_WARNING("delay : " << std11::chrono::nanoseconds(delay*1000000000LL/int64_t(m_sampleRate)).count() << " ns");
return m_startTime + m_duration; return m_startTime + m_duration;
} }
return std::chrono::system_clock::now(); return std11::chrono::system_clock::now();
} }
#endif #endif
void airtaudio::api::Alsa::callbackEventOneCycle() { void airtaudio::api::Alsa::callbackEventOneCycle() {
if (m_state == airtaudio::state_stopped) { if (m_state == airtaudio::state_stopped) {
std::unique_lock<std::mutex> lck(m_mutex); std11::unique_lock<std11::mutex> lck(m_mutex);
// TODO : Set this back .... // TODO : Set this back ....
/* /*
while (!m_private->runnable) { while (!m_private->runnable) {
@ -1059,7 +1074,7 @@ void airtaudio::api::Alsa::callbackEventOneCycle() {
return; // TODO : notify appl: airtaudio::error_warning; return; // TODO : notify appl: airtaudio::error_warning;
} }
int32_t doStopStream = 0; int32_t doStopStream = 0;
std::chrono::system_clock::time_point streamTime; std11::chrono::system_clock::time_point streamTime;
std::vector<enum airtaudio::status> status; std::vector<enum airtaudio::status> status;
if ( m_mode != airtaudio::mode_input if ( m_mode != airtaudio::mode_input
&& m_private->xrun[0] == true) { && m_private->xrun[0] == true) {
@ -1085,7 +1100,7 @@ void airtaudio::api::Alsa::callbackEventOneCycle() {
if ( m_mode == airtaudio::mode_input if ( m_mode == airtaudio::mode_input
|| m_mode == airtaudio::mode_duplex) { || m_mode == airtaudio::mode_duplex) {
std::unique_lock<std::mutex> lck(m_mutex); std11::unique_lock<std11::mutex> lck(m_mutex);
// Setup parameters. // Setup parameters.
if (m_doConvertBuffer[1]) { if (m_doConvertBuffer[1]) {
buffer = m_deviceBuffer; buffer = m_deviceBuffer;
@ -1146,9 +1161,9 @@ void airtaudio::api::Alsa::callbackEventOneCycle() {
noInput: noInput:
streamTime = getStreamTime(); streamTime = getStreamTime();
doStopStream = m_callback(&m_userBuffer[1][0], doStopStream = m_callback(&m_userBuffer[1][0],
streamTime,// - std::chrono::nanoseconds(m_latency[1]*1000000000LL/int64_t(m_sampleRate)), streamTime,// - std11::chrono::nanoseconds(m_latency[1]*1000000000LL/int64_t(m_sampleRate)),
&m_userBuffer[0][0], &m_userBuffer[0][0],
streamTime,// + std::chrono::nanoseconds(m_latency[0]*1000000000LL/int64_t(m_sampleRate)), streamTime,// + std11::chrono::nanoseconds(m_latency[0]*1000000000LL/int64_t(m_sampleRate)),
m_bufferSize, m_bufferSize,
status); status);
if (doStopStream == 2) { if (doStopStream == 2) {
@ -1158,7 +1173,7 @@ noInput:
if ( m_mode == airtaudio::mode_output if ( m_mode == airtaudio::mode_output
|| m_mode == airtaudio::mode_duplex) { || m_mode == airtaudio::mode_duplex) {
std::unique_lock<std::mutex> lck(m_mutex); std11::unique_lock<std11::mutex> lck(m_mutex);
// Setup parameters and do buffer conversion if necessary. // Setup parameters and do buffer conversion if necessary.
if (m_doConvertBuffer[0]) { if (m_doConvertBuffer[0]) {
buffer = m_deviceBuffer; buffer = m_deviceBuffer;

4
airtaudio/api/Alsa.h
View File

@ -35,7 +35,7 @@ namespace airtaudio {
private: private:
static void alsaCallbackEvent(void* _userData); static void alsaCallbackEvent(void* _userData);
private: private:
std::unique_ptr<AlsaPrivate> m_private; std11::shared_ptr<AlsaPrivate> m_private;
std::vector<airtaudio::DeviceInfo> m_devices; std::vector<airtaudio::DeviceInfo> m_devices;
void saveDeviceInfo(); void saveDeviceInfo();
bool probeDeviceOpen(uint32_t _device, bool probeDeviceOpen(uint32_t _device,
@ -46,7 +46,7 @@ namespace airtaudio {
enum audio::format _format, enum audio::format _format,
uint32_t *_bufferSize, uint32_t *_bufferSize,
airtaudio::StreamOptions *_options); airtaudio::StreamOptions *_options);
virtual std::chrono::system_clock::time_point getStreamTime(); virtual std11::chrono::system_clock::time_point getStreamTime();
}; };
}; };
}; };

6
airtaudio/api/Android.cpp
View File

@ -110,11 +110,11 @@ enum airtaudio::error airtaudio::api::Android::abortStream() {
void airtaudio::api::Android::callBackEvent(void* _data, void airtaudio::api::Android::callBackEvent(void* _data,
int32_t _frameRate) { int32_t _frameRate) {
int32_t doStopStream = 0; int32_t doStopStream = 0;
std::chrono::system_clock::time_point streamTime = getStreamTime(); std11::chrono::system_clock::time_point streamTime = getStreamTime();
std::vector<enum airtaudio::status> status; std::vector<enum airtaudio::status> status;
if (m_doConvertBuffer[airtaudio::mode_output] == true) { if (m_doConvertBuffer[airtaudio::mode_output] == true) {
doStopStream = m_callback(nullptr, doStopStream = m_callback(nullptr,
std::chrono::system_clock::time_point(), std11::chrono::system_clock::time_point(),
m_userBuffer[airtaudio::mode_output], m_userBuffer[airtaudio::mode_output],
streamTime, streamTime,
_frameRate, _frameRate,
@ -124,7 +124,7 @@ void airtaudio::api::Android::callBackEvent(void* _data,
doStopStream = m_callback(_data, doStopStream = m_callback(_data,
streamTime, streamTime,
nullptr, nullptr,
std::chrono::system_clock::time_point(), std11::chrono::system_clock::time_point(),
_frameRate, _frameRate,
status); status);
} }

2
airtaudio/api/Asio.cpp
View File

@ -692,7 +692,7 @@ bool airtaudio::api::Asio::callbackEvent(long bufferIndex) {
// Invoke user callback to get fresh output data UNLESS we are // Invoke user callback to get fresh output data UNLESS we are
// draining stream. // draining stream.
if (m_private->drainCounter == 0) { if (m_private->drainCounter == 0) {
std::chrono::system_clock::time_point streamTime = getStreamTime(); std11::chrono::system_clock::time_point streamTime = getStreamTime();
std::vector<enum airtaudio::status status; std::vector<enum airtaudio::status status;
if (m_mode != airtaudio::mode_input && asioXRun == true) { if (m_mode != airtaudio::mode_input && asioXRun == true) {
status.push_back(airtaudio::status_underflow); status.push_back(airtaudio::status_underflow);

2
airtaudio/api/Asio.h
View File

@ -33,7 +33,7 @@ namespace airtaudio {
// will most likely produce highly undesireable results! // will most likely produce highly undesireable results!
bool callbackEvent(long _bufferIndex); bool callbackEvent(long _bufferIndex);
private: private:
std::unique_ptr<AsioPrivate> m_private; std::shared_ptr<AsioPrivate> m_private;
std::vector<airtaudio::DeviceInfo> m_devices; std::vector<airtaudio::DeviceInfo> m_devices;
void saveDeviceInfo(); void saveDeviceInfo();
bool m_coInitialized; bool m_coInitialized;

10
airtaudio/api/Core.cpp
View File

@ -36,7 +36,7 @@ namespace airtaudio {
uint32_t nStreams[2]; // number of streams to use uint32_t nStreams[2]; // number of streams to use
bool xrun[2]; bool xrun[2];
char *deviceBuffer; char *deviceBuffer;
std::condition_variable condition; std11::condition_variable condition;
int32_t drainCounter; // Tracks callback counts when draining int32_t drainCounter; // Tracks callback counts when draining
bool internalDrain; // Indicates if stop is initiated from callback or not. bool internalDrain; // Indicates if stop is initiated from callback or not.
CorePrivate() : CorePrivate() :
@ -958,7 +958,7 @@ enum airtaudio::error airtaudio::api::Core::stopStream() {
if ( m_mode == airtaudio::mode_output if ( m_mode == airtaudio::mode_output
|| m_mode == airtaudio::mode_duplex) { || m_mode == airtaudio::mode_duplex) {
if (m_private->drainCounter == 0) { if (m_private->drainCounter == 0) {
std::unique_lock<std::mutex> lck(m_mutex); std11::unique_lock<std11::mutex> lck(m_mutex);
m_private->drainCounter = 2; m_private->drainCounter = 2;
m_private->condition.wait(lck); m_private->condition.wait(lck);
} }
@ -1011,9 +1011,9 @@ void airtaudio::api::Core::coreStopStream(void *_userData) {
bool airtaudio::api::Core::callbackEvent(AudioDeviceID _deviceId, bool airtaudio::api::Core::callbackEvent(AudioDeviceID _deviceId,
const AudioBufferList *_inBufferList, const AudioBufferList *_inBufferList,
const std::chrono::system_clock::time_point& _inTime, const std11::chrono::system_clock::time_point& _inTime,
const AudioBufferList *_outBufferList, const AudioBufferList *_outBufferList,
const std::chrono::system_clock::time_point& _outTime) { const std11::chrono::system_clock::time_point& _outTime) {
if ( m_state == airtaudio::state_stopped if ( m_state == airtaudio::state_stopped
|| m_state == airtaudio::state_stopping) { || m_state == airtaudio::state_stopping) {
return true; return true;
@ -1027,7 +1027,7 @@ bool airtaudio::api::Core::callbackEvent(AudioDeviceID _deviceId,
m_state = airtaudio::state_stopping; m_state = airtaudio::state_stopping;
ATA_VERBOSE("Set state as stopping"); ATA_VERBOSE("Set state as stopping");
if (m_private->internalDrain == true) { if (m_private->internalDrain == true) {
new std::thread(&airtaudio::api::Core::coreStopStream, this); new std11::thread(&airtaudio::api::Core::coreStopStream, this);
} else { } else {
// external call to stopStream() // external call to stopStream()
m_private->condition.notify_one(); m_private->condition.notify_one();

6
airtaudio/api/Core.h
View File

@ -33,9 +33,9 @@ namespace airtaudio {
long getStreamLatency(); long getStreamLatency();
bool callbackEvent(AudioDeviceID _deviceId, bool callbackEvent(AudioDeviceID _deviceId,
const AudioBufferList *_inBufferList, const AudioBufferList *_inBufferList,
const std::chrono::system_clock::time_point& _inTime, const std11::chrono::system_clock::time_point& _inTime,
const AudioBufferList *_outBufferList, const AudioBufferList *_outBufferList,
const std::chrono::system_clock::time_point& _outTime); const std11::chrono::system_clock::time_point& _outTime);
static OSStatus callbackEvent(AudioDeviceID _inDevice, static OSStatus callbackEvent(AudioDeviceID _inDevice,
const AudioTimeStamp* _inNow, const AudioTimeStamp* _inNow,
const AudioBufferList* _inInputData, const AudioBufferList* _inInputData,
@ -45,7 +45,7 @@ namespace airtaudio {
void* _infoPointer); void* _infoPointer);
static void coreStopStream(void *_userData); static void coreStopStream(void *_userData);
private: private:
std::unique_ptr<CorePrivate> m_private; std::shared_ptr<CorePrivate> m_private;
bool probeDeviceOpen(uint32_t _device, bool probeDeviceOpen(uint32_t _device,
airtaudio::mode _mode, airtaudio::mode _mode,
uint32_t _channels, uint32_t _channels,

2
airtaudio/api/CoreIos.h
View File

@ -46,7 +46,7 @@ namespace airtaudio {
void callBackEvent(void* _data, void callBackEvent(void* _data,
int32_t _frameRate); int32_t _frameRate);
public: public:
std::unique_ptr<CoreIosPrivate> m_private; std11::shared_ptr<CoreIosPrivate> m_private;
}; };
}; };
}; };

2
airtaudio/api/CoreIos.mm
View File

@ -127,7 +127,7 @@ void airtaudio::api::CoreIos::callBackEvent(void* _data,
return; return;
#endif #endif
int32_t doStopStream = 0; int32_t doStopStream = 0;
std::chrono::system_clock::time_point streamTime = getStreamTime(); std11::chrono::system_clock::time_point streamTime = getStreamTime();
std::vector<enum airtaudio::status> status; std::vector<enum airtaudio::status> status;
if (m_doConvertBuffer[modeToIdTable(airtaudio::mode_output)] == true) { if (m_doConvertBuffer[modeToIdTable(airtaudio::mode_output)] == true) {
doStopStream = m_callback(nullptr, doStopStream = m_callback(nullptr,

6
airtaudio/api/Ds.cpp
View File

@ -74,7 +74,7 @@ namespace airtaudio {
namespace api { namespace api {
class DsPrivate { class DsPrivate {
public: public:
std::unique_ptr<std::thread> thread; std11::shared_ptr<std11::thread> thread;
bool threadRunning; bool threadRunning;
uint32_t drainCounter; // Tracks callback counts when draining uint32_t drainCounter; // Tracks callback counts when draining
bool internalDrain; // Indicates if stop is initiated from callback or not. bool internalDrain; // Indicates if stop is initiated from callback or not.
@ -743,7 +743,7 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
// Setup the callback thread. // Setup the callback thread.
if (m_private->threadRunning == false) { if (m_private->threadRunning == false) {
m_private->threadRunning = true; m_private->threadRunning = true;
std::unique_ptr<std::thread> tmpThread(new std::thread(&airtaudio::api::Ds::dsCallbackEvent, this)); std11::shared_ptr<std11::thread> tmpThread(new std11::thread(&airtaudio::api::Ds::dsCallbackEvent, this));
m_private->thread = std::move(tmpThread); m_private->thread = std::move(tmpThread);
if (m_private->thread == nullptr) { if (m_private->thread == nullptr) {
ATA_ERROR("error creating callback thread!"); ATA_ERROR("error creating callback thread!");
@ -985,7 +985,7 @@ void airtaudio::api::Ds::callbackEvent() {
// Invoke user callback to get fresh output data UNLESS we are // Invoke user callback to get fresh output data UNLESS we are
// draining stream. // draining stream.
if (m_private->drainCounter == 0) { if (m_private->drainCounter == 0) {
std::chrono::system_clock::time_point streamTime = getStreamTime(); std11::chrono::system_clock::time_point streamTime = getStreamTime();
airtaudio::status status = airtaudio::status_ok; airtaudio::status status = airtaudio::status_ok;
if ( m_mode != airtaudio::mode_input if ( m_mode != airtaudio::mode_input
&& m_private->xrun[0] == true) { && m_private->xrun[0] == true) {

2
airtaudio/api/Ds.h
View File

@ -36,7 +36,7 @@ namespace airtaudio {
void callbackEvent(); void callbackEvent();
private: private:
static void dsCallbackEvent(void *_userData); static void dsCallbackEvent(void *_userData);
std::unique_ptr<DsPrivate> m_private; std11::shared_ptr<DsPrivate> m_private;
bool m_coInitialized; bool m_coInitialized;
bool m_buffersRolling; bool m_buffersRolling;
long m_duplexPrerollBytes; long m_duplexPrerollBytes;

12
airtaudio/api/Jack.cpp
View File

@ -65,7 +65,7 @@ namespace airtaudio {
jack_port_t **ports[2]; jack_port_t **ports[2];
std::string deviceName[2]; std::string deviceName[2];
bool xrun[2]; bool xrun[2];
std::condition_variable condition; std11::condition_variable condition;
int32_t drainCounter; // Tracks callback counts when draining int32_t drainCounter; // Tracks callback counts when draining
bool internalDrain; // Indicates if stop is initiated from callback or not. bool internalDrain; // Indicates if stop is initiated from callback or not.
@ -246,7 +246,7 @@ void airtaudio::api::Jack::jackShutdown(void* _userData) {
if (myClass->isStreamRunning() == false) { if (myClass->isStreamRunning() == false) {
return; return;
} }
new std::thread(&airtaudio::api::Jack::jackCloseStream, _userData); new std11::thread(&airtaudio::api::Jack::jackCloseStream, _userData);
ATA_ERROR("The Jack server is shutting down this client ... stream stopped and closed!!"); ATA_ERROR("The Jack server is shutting down this client ... stream stopped and closed!!");
} }
@ -596,7 +596,7 @@ enum airtaudio::error airtaudio::api::Jack::stopStream() {
|| m_mode == airtaudio::mode_duplex) { || m_mode == airtaudio::mode_duplex) {
if (m_private->drainCounter == 0) { if (m_private->drainCounter == 0) {
m_private->drainCounter = 2; m_private->drainCounter = 2;
std::unique_lock<std::mutex> lck(m_mutex); std11::unique_lock<std11::mutex> lck(m_mutex);
m_private->condition.wait(lck); m_private->condition.wait(lck);
} }
} }
@ -645,7 +645,7 @@ bool airtaudio::api::Jack::callbackEvent(uint64_t _nframes) {
if (m_private->drainCounter > 3) { if (m_private->drainCounter > 3) {
m_state = airtaudio::state_stopping; m_state = airtaudio::state_stopping;
if (m_private->internalDrain == true) { if (m_private->internalDrain == true) {
new std::thread(jackStopStream, this); new std11::thread(jackStopStream, this);
} else { } else {
m_private->condition.notify_one(); m_private->condition.notify_one();
} }
@ -653,7 +653,7 @@ bool airtaudio::api::Jack::callbackEvent(uint64_t _nframes) {
} }
// Invoke user callback first, to get fresh output data. // Invoke user callback first, to get fresh output data.
if (m_private->drainCounter == 0) { if (m_private->drainCounter == 0) {
std::chrono::time_point<std::chrono::system_clock> streamTime = getStreamTime(); std11::chrono::time_point<std11::chrono::system_clock> streamTime = getStreamTime();
std::vector<enum airtaudio::status> status; std::vector<enum airtaudio::status> status;
if (m_mode != airtaudio::mode_input && m_private->xrun[0] == true) { if (m_mode != airtaudio::mode_input && m_private->xrun[0] == true) {
status.push_back(airtaudio::status_underflow); status.push_back(airtaudio::status_underflow);
@ -672,7 +672,7 @@ bool airtaudio::api::Jack::callbackEvent(uint64_t _nframes) {
if (cbReturnValue == 2) { if (cbReturnValue == 2) {
m_state = airtaudio::state_stopping; m_state = airtaudio::state_stopping;
m_private->drainCounter = 2; m_private->drainCounter = 2;
new std::thread(jackStopStream, this); new std11::thread(jackStopStream, this);
return true; return true;
} }
else if (cbReturnValue == 1) { else if (cbReturnValue == 1) {

2
airtaudio/api/Jack.h
View File

@ -39,7 +39,7 @@ namespace airtaudio {
static void jackShutdown(void* _userData); static void jackShutdown(void* _userData);
static int32_t jackCallbackHandler(jack_nframes_t _nframes, void* _userData); static int32_t jackCallbackHandler(jack_nframes_t _nframes, void* _userData);
private: private:
std::unique_ptr<JackPrivate> m_private; std11::shared_ptr<JackPrivate> m_private;
bool probeDeviceOpen(uint32_t _device, bool probeDeviceOpen(uint32_t _device,
airtaudio::mode _mode, airtaudio::mode _mode,
uint32_t _channels, uint32_t _channels,

10
airtaudio/api/Oss.cpp
View File

@ -35,8 +35,8 @@ namespace airtaudio {
int32_t id[2]; // device ids int32_t id[2]; // device ids
bool xrun[2]; bool xrun[2];
bool triggered; bool triggered;
std::condition_variable runnable; std11::condition_variable runnable;
std::unique_ptr<std::thread> thread; std11::shared_ptr<std11::thread> thread;
bool threadRunning; bool threadRunning;
OssPrivate(): OssPrivate():
triggered(false), triggered(false),
@ -507,7 +507,7 @@ bool airtaudio::api::Oss::probeDeviceOpen(uint32_t _device,
m_mode = _mode; m_mode = _mode;
// Setup callback thread. // Setup callback thread.
m_private->threadRunning = true; m_private->threadRunning = true;
m_private->thread = new std::thread(ossCallbackHandler, this); m_private->thread = new std11::thread(ossCallbackHandler, this);
if (m_private->thread == nullptr) { if (m_private->thread == nullptr) {
m_private->threadRunning = false; m_private->threadRunning = false;
ATA_ERROR("creating callback thread!"); ATA_ERROR("creating callback thread!");
@ -702,7 +702,7 @@ unlock:
void airtaudio::api::Oss::callbackEvent() { void airtaudio::api::Oss::callbackEvent() {
if (m_state == airtaudio::state_stopped) { if (m_state == airtaudio::state_stopped) {
std::unique_lock<std::mutex> lck(m_mutex); std11::unique_lock<std11::mutex> lck(m_mutex);
m_private->runnable.wait(lck); m_private->runnable.wait(lck);
if (m_state != airtaudio::state_running) { if (m_state != airtaudio::state_running) {
return; return;
@ -714,7 +714,7 @@ void airtaudio::api::Oss::callbackEvent() {
} }
// Invoke user callback to get fresh output data. // Invoke user callback to get fresh output data.
int32_t doStopStream = 0; int32_t doStopStream = 0;
std::chrono::system_clock::time_point streamTime = getStreamTime(); std11::chrono::system_clock::time_point streamTime = getStreamTime();
std::vector<enum airtaudio::status> status; std::vector<enum airtaudio::status> status;
if ( m_mode != airtaudio::mode_input if ( m_mode != airtaudio::mode_input
&& m_private->xrun[0] == true) { && m_private->xrun[0] == true) {

2
airtaudio/api/Oss.h
View File

@ -32,7 +32,7 @@ namespace airtaudio {
// will most likely produce highly undesireable results! // will most likely produce highly undesireable results!
void callbackEvent(); void callbackEvent();
private: private:
std::unique_ptr<OssPrivate> m_private; std11::shared_ptr<OssPrivate> m_private;
bool probeDeviceOpen(uint32_t _device, bool probeDeviceOpen(uint32_t _device,
airtaudio::mode _mode, airtaudio::mode _mode,
uint32_t _channels, uint32_t _channels,

10
airtaudio/api/Pulse.cpp
View File

@ -53,9 +53,9 @@ namespace airtaudio {
public: public:
pa_simple *s_play; pa_simple *s_play;
pa_simple *s_rec; pa_simple *s_rec;
std::unique_ptr<std::thread> thread; std11::shared_ptr<std11::thread> thread;
bool threadRunning; bool threadRunning;
std::condition_variable runnable_cv; std11::condition_variable runnable_cv;
bool runnable; bool runnable;
PulsePrivate() : PulsePrivate() :
s_play(0), s_play(0),
@ -137,7 +137,7 @@ enum airtaudio::error airtaudio::api::Pulse::closeStream() {
void airtaudio::api::Pulse::callbackEventOneCycle() { void airtaudio::api::Pulse::callbackEventOneCycle() {
if (m_state == airtaudio::state_stopped) { if (m_state == airtaudio::state_stopped) {
std::unique_lock<std::mutex> lck(m_mutex); std11::unique_lock<std11::mutex> lck(m_mutex);
while (!m_private->runnable) { while (!m_private->runnable) {
m_private->runnable_cv.wait(lck); m_private->runnable_cv.wait(lck);
} }
@ -150,7 +150,7 @@ void airtaudio::api::Pulse::callbackEventOneCycle() {
ATA_ERROR("the stream is closed ... this shouldn't happen!"); ATA_ERROR("the stream is closed ... this shouldn't happen!");
return; return;
} }
std::chrono::system_clock::time_point streamTime = getStreamTime(); std11::chrono::system_clock::time_point streamTime = getStreamTime();
std::vector<enum airtaudio::status> status; std::vector<enum airtaudio::status> status;
int32_t doStopStream = m_callback(&m_userBuffer[airtaudio::modeToIdTable(airtaudio::mode_input)][0], int32_t doStopStream = m_callback(&m_userBuffer[airtaudio::modeToIdTable(airtaudio::mode_input)][0],
streamTime, streamTime,
@ -398,7 +398,7 @@ bool airtaudio::api::Pulse::probeDeviceOpen(uint32_t _device,
} }
if (!m_private->threadRunning) { if (!m_private->threadRunning) {
m_private->threadRunning = true; m_private->threadRunning = true;
std::unique_ptr<std::thread> tmpThread(new std::thread(&pulseaudio_callback, this)); std11::shared_ptr<std11::thread> tmpThread(new std11::thread(&pulseaudio_callback, this));
m_private->thread = std::move(tmpThread); m_private->thread = std::move(tmpThread);
if (m_private->thread == nullptr) { if (m_private->thread == nullptr) {
ATA_ERROR("error creating thread."); ATA_ERROR("error creating thread.");

2
airtaudio/api/Pulse.h
View File

@ -33,7 +33,7 @@ namespace airtaudio {
void callbackEventOneCycle(); void callbackEventOneCycle();
void callbackEvent(); void callbackEvent();
private: private:
std::unique_ptr<PulsePrivate> m_private; std11::shared_ptr<PulsePrivate> m_private;
std::vector<airtaudio::DeviceInfo> m_devices; std::vector<airtaudio::DeviceInfo> m_devices;
void saveDeviceInfo(); void saveDeviceInfo();
bool probeDeviceOpen(uint32_t _device, bool probeDeviceOpen(uint32_t _device,

19
airtaudio/base.h
View File

@ -8,10 +8,21 @@
#ifndef __AIRTAUDIO_CB_H__ #ifndef __AIRTAUDIO_CB_H__
#define __AIRTAUDIO_CB_H__ #define __AIRTAUDIO_CB_H__
#include <thread> #if __cplusplus >= 201103L
#include <condition_variable> #include <thread>
#include <mutex> #include <condition_variable>
#include <functional> #include <mutex>
#include <chrono>
#include <functional>
#include <memory>
#else
#include <etk/thread.h>
#include <etk/condition_variable.h>
#include <etk/mutex.h>
#include <etk/chrono.h>
#include <etk/functional.h>
#include <etk/memory.h>
#endif
#include <audio/channel.h> #include <audio/channel.h>
#include <audio/format.h> #include <audio/format.h>
#include <airtaudio/error.h> #include <airtaudio/error.h>

2
airtaudio/type.cpp
View File

@ -15,7 +15,7 @@
#undef __class__ #undef __class__
#define __class__ "type" #define __class__ "type"
static const char* listType[] { static const char* listType[] = {
"undefined", "undefined",
"alsa", "alsa",
"pulse", "pulse",

6
lutin_airtaudio.py
View File

@ -45,9 +45,9 @@ def create(target):
'airtaudio/api/Oss.cpp' 'airtaudio/api/Oss.cpp'
]) ])
myModule.add_optionnal_module_depend('alsa', "__LINUX_ALSA__") myModule.add_optionnal_module_depend('alsa', "__LINUX_ALSA__")
myModule.add_optionnal_module_depend('jack', "__UNIX_JACK__") #myModule.add_optionnal_module_depend('jack', "__UNIX_JACK__")
myModule.add_optionnal_module_depend('pulse', "__LINUX_PULSE__") #myModule.add_optionnal_module_depend('pulse', "__LINUX_PULSE__")
myModule.add_optionnal_module_depend('oss', "__LINUX_OSS__") #myModule.add_optionnal_module_depend('oss', "__LINUX_OSS__")
elif target.name=="MacOs": elif target.name=="MacOs":
myModule.add_src_file([ myModule.add_src_file([
'airtaudio/api/Core.cpp', 'airtaudio/api/Core.cpp',