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
Download Patch File Download Diff File Expand all files Collapse all files

109
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();
for (auto &it : airtaudio::genericSampleRate()) {
if (snd_pcm_hw_params_test_rate(phandle, params, it, 0) == 0) {
info.sampleRates.push_back(it);
#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,