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() {
ATA_VERBOSE("Start Stream");
m_startTime = std::chrono::system_clock::now();
m_duration = std::chrono::duration<int64_t, std::micro>(0);
m_startTime = std11::chrono::system_clock::now();
m_duration = std11::chrono::microseconds(0);
return airtaudio::error_none;
}
@ -176,9 +176,9 @@ bool airtaudio::Api::probeDeviceOpen(uint32_t /*device*/,
}
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(" one element=" << std::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));
//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=" << std11::chrono::nanoseconds((int64_t(1000000000)) / int64_t(m_sampleRate)).count());
m_duration += std11::chrono::nanoseconds((int64_t(m_bufferSize) * int64_t(1000000000)) / int64_t(m_sampleRate));
}
long airtaudio::Api::getStreamLatency() {
@ -197,9 +197,9 @@ long airtaudio::Api::getStreamLatency() {
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) {
return std::chrono::system_clock::time_point();
return std11::chrono::system_clock::time_point();
}
return m_startTime + m_duration;
}
@ -226,8 +226,8 @@ void airtaudio::Api::clearStreamInfo() {
m_bufferSize = 0;
m_nBuffers = 0;
m_userFormat = audio::format_unknow;
m_startTime = std::chrono::system_clock::time_point();
m_duration = std::chrono::nanoseconds(0);
m_startTime = std11::chrono::system_clock::time_point();
m_duration = std11::chrono::nanoseconds(0);
m_deviceBuffer = nullptr;
m_callback = nullptr;
for (int32_t iii=0; iii<2; ++iii) {

18
airtaudio/Api.h
View File

@ -9,7 +9,6 @@
#define __AIRTAUDIO_API_H__
#include <sstream>
#include <chrono>
#include <airtaudio/debug.h>
#include <airtaudio/type.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 _status List of error that occured in the laps of time.
*/
typedef std::function<int32_t (const void* _inputBuffer,
const std::chrono::system_clock::time_point& _timeInput,
typedef std11::function<int32_t (const void* _inputBuffer,
const std11::chrono::system_clock::time_point& _timeInput,
void* _outputBuffer,
const std::chrono::system_clock::time_point& _timeOutput,
const std11::chrono::system_clock::time_point& _timeOutput,
uint32_t _nbChunk,
const std::vector<airtaudio::status>& _status)> AirTAudioCallback;
// A protected structure used for buffer conversion.
class ConvertInfo {
public:
@ -73,7 +71,7 @@ namespace airtaudio {
virtual enum airtaudio::error abortStream() = 0;
long getStreamLatency();
uint32_t getStreamSampleRate();
virtual std::chrono::time_point<std::chrono::system_clock> getStreamTime();
virtual std11::chrono::system_clock::time_point getStreamTime();
bool isStreamOpen() const {
return m_state != airtaudio::state_closed;
}
@ -82,7 +80,7 @@ namespace airtaudio {
}
protected:
mutable std::mutex m_mutex;
mutable std11::mutex m_mutex;
airtaudio::AirTAudioCallback m_callback;
uint32_t m_device[2]; // Playback and record, respectively.
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.
airtaudio::ConvertInfo m_convertInfo[2];
//std::chrono::system_clock::time_point
std::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::system_clock::time_point
std11::chrono::system_clock::time_point m_startTime; //!< start time of the stream (restart at every stop, pause ...)
std11::chrono::nanoseconds m_duration; //!< duration from wich the stream is started
/**
* @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;
// The order here will control the order of RtAudio's API search in
// the constructor.
for (auto &it : m_apiAvaillable) {
apis.push_back(it.first);
for (size_t iii=0; iii<m_apiAvaillable.size(); ++iii) {
apis.push_back(m_apiAvaillable[iii].first);
}
return apis;
}
@ -28,11 +28,11 @@ std::vector<enum airtaudio::type> airtaudio::Interface::getCompiledApi() {
void airtaudio::Interface::openRtApi(enum airtaudio::type _api) {
delete m_rtapi;
m_rtapi = nullptr;
for (auto &it :m_apiAvaillable) {
ATA_INFO("try open " << it.first);
if (_api == it.first) {
for (size_t iii=0; iii<m_apiAvaillable.size(); ++iii) {
ATA_INFO("try open " << m_apiAvaillable[iii].first);
if (_api == m_apiAvaillable[iii].first) {
ATA_INFO(" ==> call it");
m_rtapi = it.second();
m_rtapi = m_apiAvaillable[iii].second();
if (m_rtapi != nullptr) {
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.
std::vector<enum airtaudio::type> apis = getCompiledApi();
ATA_INFO(" find : " << apis.size() << " apis.");
for (auto &it : apis) {
for (size_t iii=0; iii<apis.size(); ++iii) {
ATA_INFO("try open ...");
openRtApi(it);
openRtApi(apis[iii]);
if(m_rtapi == nullptr) {
ATA_ERROR(" ==> can not create ...");
continue;

6
airtaudio/Interface.h
View File

@ -36,7 +36,7 @@ namespace airtaudio {
*/
class Interface {
protected:
std::vector<std::pair<enum airtaudio::type, Api* (*)()>> m_apiAvaillable;
std::vector<std::pair<enum airtaudio::type, Api* (*)()> > m_apiAvaillable;
protected:
airtaudio::Api *m_rtapi;
public:
@ -267,9 +267,9 @@ namespace airtaudio {
* @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.
*/
std::chrono::time_point<std::chrono::system_clock> getStreamTime() {
std11::chrono::system_clock::time_point getStreamTime() {
if (m_rtapi == nullptr) {
return std::chrono::time_point<std::chrono::system_clock>();
return std11::chrono::system_clock::time_point();
}
return m_rtapi->getStreamTime();
}

101
airtaudio/api/Alsa.cpp
View File

@ -28,13 +28,14 @@ namespace airtaudio {
snd_pcm_t *handles[2];
bool synchronized;
bool xrun[2];
std::condition_variable runnable_cv;
std11::condition_variable runnable_cv;
bool runnable;
std::unique_ptr<std::thread> thread;
std11::thread* thread;
bool threadRunning;
AlsaPrivate() :
synchronized(false),
runnable(false),
thread(nullptr),
threadRunning(false) {
handles[0] = nullptr;
handles[1] = nullptr;
@ -300,11 +301,21 @@ probeParameters:
}
// Test our discrete set of sample rate values.
info.sampleRates.clear();
#if __cplusplus >= 201103L
for (auto &it : airtaudio::genericSampleRate()) {
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) {
snd_pcm_close(phandle);
ATA_ERROR("no supported sample rates found for device (" << name << ").");
@ -696,8 +707,7 @@ foundDevice:
m_mode = _mode;
// Setup callback thread.
m_private->threadRunning = true;
std::unique_ptr<std::thread> tmpThread(new std::thread(&airtaudio::api::Alsa::alsaCallbackEvent, this));
m_private->thread = std::move(tmpThread);
m_private->thread = new std11::thread(&airtaudio::api::Alsa::alsaCallbackEvent, this);
if (m_private->thread == nullptr) {
m_private->threadRunning = false;
ATA_ERROR("creating callback thread!");
@ -742,6 +752,7 @@ enum airtaudio::error airtaudio::api::Alsa::closeStream() {
m_mutex.unlock();
if (m_private->thread != nullptr) {
m_private->thread->join();
m_private->thread = nullptr;
}
if (m_state == airtaudio::state_running) {
m_state = airtaudio::state_stopped;
@ -786,7 +797,7 @@ enum airtaudio::error airtaudio::api::Alsa::startStream() {
ATA_ERROR("the stream is already running!");
return airtaudio::error_warning;
}
std::unique_lock<std::mutex> lck(m_mutex);
std11::unique_lock<std11::mutex> lck(m_mutex);
int32_t result = 0;
snd_pcm_state_t state;
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;
}
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;
snd_pcm_t **handle = (snd_pcm_t **) m_private->handles;
if ( m_mode == airtaudio::mode_output
@ -884,7 +895,7 @@ enum airtaudio::error airtaudio::api::Alsa::abortStream() {
return airtaudio::error_warning;
}
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;
snd_pcm_t **handle = (snd_pcm_t **) m_private->handles;
if ( m_mode == airtaudio::mode_output
@ -925,8 +936,12 @@ void airtaudio::api::Alsa::callbackEvent() {
}
namespace std {
static std::ostream& operator <<(std::ostream& _os, const std::chrono::system_clock::time_point& _obj) {
std::chrono::nanoseconds ns = std::chrono::duration_cast<std::chrono::nanoseconds>(_obj.time_since_epoch());
static std::ostream& operator <<(std::ostream& _os, const std11::chrono::system_clock::time_point& _obj) {
#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 millisecond = (ns.count()%1000000000)/1000000;
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() {
if (m_startTime == std::chrono::system_clock::time_point()) {
std11::chrono::time_point<std11::chrono::system_clock> airtaudio::api::Alsa::getStreamTime() {
if (m_startTime == std11::chrono::system_clock::time_point()) {
snd_pcm_uframes_t avail;
snd_htimestamp_t tstamp;
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);
}
//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);
m_startTime = std::chrono::system_clock::from_time_t(tstamp.tv_sec) + std::chrono::nanoseconds(tstamp.tv_nsec);
m_startTime = std::chrono::system_clock::now();
//return std11::chrono::system_clock::from_time_t(tstamp.tv_sec) + std11::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 = std11::chrono::system_clock::now();
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;
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) {
//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;
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);
@ -977,31 +992,31 @@ std::chrono::time_point<std::chrono::system_clock> airtaudio::api::Alsa::getStre
*/
#if 1
std::chrono::time_point<std::chrono::system_clock> airtaudio::api::Alsa::getStreamTime() {
if (m_startTime == std::chrono::system_clock::time_point()) {
m_startTime = std::chrono::system_clock::now();
std11::chrono::system_clock::time_point airtaudio::api::Alsa::getStreamTime() {
if (m_startTime == std11::chrono::system_clock::time_point()) {
m_startTime = std11::chrono::system_clock::now();
// Corection of time stamp with the input properties ...
if (m_private->handles[0] != nullptr) {
//output
snd_pcm_sframes_t 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) {
//input
/*
snd_pcm_sframes_t 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);
return m_startTime + m_duration;
}
#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_timestamp_t timestamp;
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]) {
snd_pcm_status(m_private->handles[1], status);
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);
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);
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);
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);
//return m_startTime - std::chrono::nanoseconds(delay*1000000000LL/int64_t(m_sampleRate));
ATA_WARNING("delay : " << std::chrono::nanoseconds(delay*1000000000LL/int64_t(m_sampleRate)).count() << " ns");
//return m_startTime - std11::chrono::nanoseconds(delay*1000000000LL/int64_t(m_sampleRate));
ATA_WARNING("delay : " << std11::chrono::nanoseconds(delay*1000000000LL/int64_t(m_sampleRate)).count() << " ns");
return m_startTime + m_duration;
}
if(m_private->handles[0]) {
snd_pcm_status(m_private->handles[0], status);
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);
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);
snd_pcm_sframes_t delay = snd_pcm_status_get_delay(status);
//return m_startTime + std::chrono::nanoseconds(delay*1000000000LL/int64_t(m_sampleRate));
ATA_WARNING("delay : " << std::chrono::nanoseconds(delay*1000000000LL/int64_t(m_sampleRate)).count() << " ns");
//return m_startTime + std11::chrono::nanoseconds(delay*1000000000LL/int64_t(m_sampleRate));
ATA_WARNING("delay : " << std11::chrono::nanoseconds(delay*1000000000LL/int64_t(m_sampleRate)).count() << " ns");
return m_startTime + m_duration;
}
return std::chrono::system_clock::now();
return std11::chrono::system_clock::now();
}
#endif
void airtaudio::api::Alsa::callbackEventOneCycle() {
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 ....
/*
while (!m_private->runnable) {
@ -1059,7 +1074,7 @@ void airtaudio::api::Alsa::callbackEventOneCycle() {
return; // TODO : notify appl: airtaudio::error_warning;
}
int32_t doStopStream = 0;
std::chrono::system_clock::time_point streamTime;
std11::chrono::system_clock::time_point streamTime;
std::vector<enum airtaudio::status> status;
if ( m_mode != airtaudio::mode_input
&& m_private->xrun[0] == true) {
@ -1085,7 +1100,7 @@ void airtaudio::api::Alsa::callbackEventOneCycle() {
if ( m_mode == airtaudio::mode_input
|| m_mode == airtaudio::mode_duplex) {
std::unique_lock<std::mutex> lck(m_mutex);
std11::unique_lock<std11::mutex> lck(m_mutex);
// Setup parameters.
if (m_doConvertBuffer[1]) {
buffer = m_deviceBuffer;
@ -1146,9 +1161,9 @@ void airtaudio::api::Alsa::callbackEventOneCycle() {
noInput:
streamTime = getStreamTime();
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],
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,
status);
if (doStopStream == 2) {
@ -1158,7 +1173,7 @@ noInput:
if ( m_mode == airtaudio::mode_output
|| 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.
if (m_doConvertBuffer[0]) {
buffer = m_deviceBuffer;

4
airtaudio/api/Alsa.h
View File

@ -35,7 +35,7 @@ namespace airtaudio {
private:
static void alsaCallbackEvent(void* _userData);
private:
std::unique_ptr<AlsaPrivate> m_private;
std11::shared_ptr<AlsaPrivate> m_private;
std::vector<airtaudio::DeviceInfo> m_devices;
void saveDeviceInfo();
bool probeDeviceOpen(uint32_t _device,
@ -46,7 +46,7 @@ namespace airtaudio {
enum audio::format _format,
uint32_t *_bufferSize,
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,
int32_t _frameRate) {
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;
if (m_doConvertBuffer[airtaudio::mode_output] == true) {
doStopStream = m_callback(nullptr,
std::chrono::system_clock::time_point(),
std11::chrono::system_clock::time_point(),
m_userBuffer[airtaudio::mode_output],
streamTime,
_frameRate,
@ -124,7 +124,7 @@ void airtaudio::api::Android::callBackEvent(void* _data,
doStopStream = m_callback(_data,
streamTime,
nullptr,
std::chrono::system_clock::time_point(),
std11::chrono::system_clock::time_point(),
_frameRate,
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
// draining stream.
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;
if (m_mode != airtaudio::mode_input && asioXRun == true) {
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!
bool callbackEvent(long _bufferIndex);
private:
std::unique_ptr<AsioPrivate> m_private;
std::shared_ptr<AsioPrivate> m_private;
std::vector<airtaudio::DeviceInfo> m_devices;
void saveDeviceInfo();
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
bool xrun[2];
char *deviceBuffer;
std::condition_variable condition;
std11::condition_variable condition;
int32_t drainCounter; // Tracks callback counts when draining
bool internalDrain; // Indicates if stop is initiated from callback or not.
CorePrivate() :
@ -958,7 +958,7 @@ enum airtaudio::error airtaudio::api::Core::stopStream() {
if ( m_mode == airtaudio::mode_output
|| m_mode == airtaudio::mode_duplex) {
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->condition.wait(lck);
}
@ -1011,9 +1011,9 @@ void airtaudio::api::Core::coreStopStream(void *_userData) {
bool airtaudio::api::Core::callbackEvent(AudioDeviceID _deviceId,
const AudioBufferList *_inBufferList,
const std::chrono::system_clock::time_point& _inTime,
const std11::chrono::system_clock::time_point& _inTime,
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
|| m_state == airtaudio::state_stopping) {
return true;
@ -1027,7 +1027,7 @@ bool airtaudio::api::Core::callbackEvent(AudioDeviceID _deviceId,
m_state = airtaudio::state_stopping;
ATA_VERBOSE("Set state as stopping");
if (m_private->internalDrain == true) {
new std::thread(&airtaudio::api::Core::coreStopStream, this);
new std11::thread(&airtaudio::api::Core::coreStopStream, this);
} else {
// external call to stopStream()
m_private->condition.notify_one();

6
airtaudio/api/Core.h
View File

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

2
airtaudio/api/CoreIos.h
View File

@ -46,7 +46,7 @@ namespace airtaudio {
void callBackEvent(void* _data,
int32_t _frameRate);
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;
#endif
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;
if (m_doConvertBuffer[modeToIdTable(airtaudio::mode_output)] == true) {
doStopStream = m_callback(nullptr,

6
airtaudio/api/Ds.cpp
View File

@ -74,7 +74,7 @@ namespace airtaudio {
namespace api {
class DsPrivate {
public:
std::unique_ptr<std::thread> thread;
std11::shared_ptr<std11::thread> thread;
bool threadRunning;
uint32_t drainCounter; // Tracks callback counts when draining
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.
if (m_private->threadRunning == false) {
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);
if (m_private->thread == nullptr) {
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
// draining stream.
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;
if ( m_mode != airtaudio::mode_input
&& m_private->xrun[0] == true) {

2
airtaudio/api/Ds.h
View File

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

12
airtaudio/api/Jack.cpp
View File

@ -65,7 +65,7 @@ namespace airtaudio {
jack_port_t **ports[2];
std::string deviceName[2];
bool xrun[2];
std::condition_variable condition;
std11::condition_variable condition;
int32_t drainCounter; // Tracks callback counts when draining
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) {
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!!");
}
@ -596,7 +596,7 @@ enum airtaudio::error airtaudio::api::Jack::stopStream() {
|| m_mode == airtaudio::mode_duplex) {
if (m_private->drainCounter == 0) {
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);
}
}
@ -645,7 +645,7 @@ bool airtaudio::api::Jack::callbackEvent(uint64_t _nframes) {
if (m_private->drainCounter > 3) {
m_state = airtaudio::state_stopping;
if (m_private->internalDrain == true) {
new std::thread(jackStopStream, this);
new std11::thread(jackStopStream, this);
} else {
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.
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;
if (m_mode != airtaudio::mode_input && m_private->xrun[0] == true) {
status.push_back(airtaudio::status_underflow);
@ -672,7 +672,7 @@ bool airtaudio::api::Jack::callbackEvent(uint64_t _nframes) {
if (cbReturnValue == 2) {
m_state = airtaudio::state_stopping;
m_private->drainCounter = 2;
new std::thread(jackStopStream, this);
new std11::thread(jackStopStream, this);
return true;
}
else if (cbReturnValue == 1) {

2
airtaudio/api/Jack.h
View File

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

10
airtaudio/api/Oss.cpp
View File

@ -35,8 +35,8 @@ namespace airtaudio {
int32_t id[2]; // device ids
bool xrun[2];
bool triggered;
std::condition_variable runnable;
std::unique_ptr<std::thread> thread;
std11::condition_variable runnable;
std11::shared_ptr<std11::thread> thread;
bool threadRunning;
OssPrivate():
triggered(false),
@ -507,7 +507,7 @@ bool airtaudio::api::Oss::probeDeviceOpen(uint32_t _device,
m_mode = _mode;
// Setup callback thread.
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) {
m_private->threadRunning = false;
ATA_ERROR("creating callback thread!");
@ -702,7 +702,7 @@ unlock:
void airtaudio::api::Oss::callbackEvent() {
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);
if (m_state != airtaudio::state_running) {
return;
@ -714,7 +714,7 @@ void airtaudio::api::Oss::callbackEvent() {
}
// Invoke user callback to get fresh output data.
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;
if ( m_mode != airtaudio::mode_input
&& 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!
void callbackEvent();
private:
std::unique_ptr<OssPrivate> m_private;
std11::shared_ptr<OssPrivate> m_private;
bool probeDeviceOpen(uint32_t _device,
airtaudio::mode _mode,
uint32_t _channels,

10
airtaudio/api/Pulse.cpp
View File

@ -53,9 +53,9 @@ namespace airtaudio {
public:
pa_simple *s_play;
pa_simple *s_rec;
std::unique_ptr<std::thread> thread;
std11::shared_ptr<std11::thread> thread;
bool threadRunning;
std::condition_variable runnable_cv;
std11::condition_variable runnable_cv;
bool runnable;
PulsePrivate() :
s_play(0),
@ -137,7 +137,7 @@ enum airtaudio::error airtaudio::api::Pulse::closeStream() {
void airtaudio::api::Pulse::callbackEventOneCycle() {
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) {
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!");
return;
}
std::chrono::system_clock::time_point streamTime = getStreamTime();
std11::chrono::system_clock::time_point streamTime = getStreamTime();
std::vector<enum airtaudio::status> status;
int32_t doStopStream = m_callback(&m_userBuffer[airtaudio::modeToIdTable(airtaudio::mode_input)][0],
streamTime,
@ -398,7 +398,7 @@ bool airtaudio::api::Pulse::probeDeviceOpen(uint32_t _device,
}
if (!m_private->threadRunning) {
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);
if (m_private->thread == nullptr) {
ATA_ERROR("error creating thread.");

2
airtaudio/api/Pulse.h
View File

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

19
airtaudio/base.h
View File

@ -8,10 +8,21 @@
#ifndef __AIRTAUDIO_CB_H__
#define __AIRTAUDIO_CB_H__
#include <thread>
#include <condition_variable>
#include <mutex>
#include <functional>
#if __cplusplus >= 201103L
#include <thread>
#include <condition_variable>
#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/format.h>
#include <airtaudio/error.h>

2
airtaudio/type.cpp
View File

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

6
lutin_airtaudio.py
View File

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