diff --git a/airtaudio/Api.cpp b/airtaudio/Api.cpp index 84b6ceb..aca7ca8 100644 --- a/airtaudio/Api.cpp +++ b/airtaudio/Api.cpp @@ -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(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) { diff --git a/airtaudio/Api.h b/airtaudio/Api.h index 2d657cf..fb55320 100644 --- a/airtaudio/Api.h +++ b/airtaudio/Api.h @@ -9,7 +9,6 @@ #define __AIRTAUDIO_API_H__ #include -#include #include #include #include @@ -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& _status)> AirTAudioCallback; - + typedef std11::function& _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 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 diff --git a/airtaudio/Interface.cpp b/airtaudio/Interface.cpp index 9de3331..ec24bf3 100644 --- a/airtaudio/Interface.cpp +++ b/airtaudio/Interface.cpp @@ -17,8 +17,8 @@ std::vector airtaudio::Interface::getCompiledApi() { std::vector 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 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 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 apis = getCompiledApi(); ATA_INFO(" find : " << apis.size() << " apis."); - for (auto &it : apis) { + for (size_t iii=0; iii can not create ..."); continue; diff --git a/airtaudio/Interface.h b/airtaudio/Interface.h index 63fd766..2096d2a 100644 --- a/airtaudio/Interface.h +++ b/airtaudio/Interface.h @@ -36,7 +36,7 @@ namespace airtaudio { */ class Interface { protected: - std::vector> m_apiAvaillable; + std::vector > 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 getStreamTime() { + std11::chrono::system_clock::time_point getStreamTime() { if (m_rtapi == nullptr) { - return std::chrono::time_point(); + return std11::chrono::system_clock::time_point(); } return m_rtapi->getStreamTime(); } diff --git a/airtaudio/api/Alsa.cpp b/airtaudio/api/Alsa.cpp index 2b57e98..2b4f8d2 100644 --- a/airtaudio/api/Alsa.cpp +++ b/airtaudio/api/Alsa.cpp @@ -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 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::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 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 lck(m_mutex); + std11::unique_lock 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 lck(m_mutex); + std11::unique_lock 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 lck(m_mutex); + std11::unique_lock 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(_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(_obj.time_since_epoch()); + #else + boost::chrono::nanoseconds ns = boost::chrono::duration_cast(_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 airtaudio::api::Alsa::getStreamTime() { - if (m_startTime == std::chrono::system_clock::time_point()) { +std11::chrono::time_point 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 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 airtaudio::api::Alsa::getStre */ #if 1 -std::chrono::time_point 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 airtaudio::api::Alsa::getStreamTime() { +std11::chrono::time_point 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 airtaudio::api::Alsa::getStre if(m_private->handles[1]) { snd_pcm_status(m_private->handles[1], status); snd_pcm_status_get_tstamp(status, ×tamp); - 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, ×tamp); - 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, ×tampHighRes); - 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, ×tampHighRes); - 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, ×tamp); - 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, ×tamp); - 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 lck(m_mutex); + std11::unique_lock 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 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 lck(m_mutex); + std11::unique_lock 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 lck(m_mutex); + std11::unique_lock lck(m_mutex); // Setup parameters and do buffer conversion if necessary. if (m_doConvertBuffer[0]) { buffer = m_deviceBuffer; diff --git a/airtaudio/api/Alsa.h b/airtaudio/api/Alsa.h index c2124fa..a2974a0 100644 --- a/airtaudio/api/Alsa.h +++ b/airtaudio/api/Alsa.h @@ -35,7 +35,7 @@ namespace airtaudio { private: static void alsaCallbackEvent(void* _userData); private: - std::unique_ptr m_private; + std11::shared_ptr m_private; std::vector 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(); }; }; }; diff --git a/airtaudio/api/Android.cpp b/airtaudio/api/Android.cpp index c793588..6acb793 100644 --- a/airtaudio/api/Android.cpp +++ b/airtaudio/api/Android.cpp @@ -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 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); } diff --git a/airtaudio/api/Asio.cpp b/airtaudio/api/Asio.cpp index 92775e8..1b2109d 100644 --- a/airtaudio/api/Asio.cpp +++ b/airtaudio/api/Asio.cpp @@ -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 m_private; + std::shared_ptr m_private; std::vector m_devices; void saveDeviceInfo(); bool m_coInitialized; diff --git a/airtaudio/api/Core.cpp b/airtaudio/api/Core.cpp index 92c8553..3142df4 100644 --- a/airtaudio/api/Core.cpp +++ b/airtaudio/api/Core.cpp @@ -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 lck(m_mutex); + std11::unique_lock 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(); diff --git a/airtaudio/api/Core.h b/airtaudio/api/Core.h index aa3d044..4ed1115 100644 --- a/airtaudio/api/Core.h +++ b/airtaudio/api/Core.h @@ -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 m_private; + std::shared_ptr m_private; bool probeDeviceOpen(uint32_t _device, airtaudio::mode _mode, uint32_t _channels, diff --git a/airtaudio/api/CoreIos.h b/airtaudio/api/CoreIos.h index 4cfd9a4..6d0c80e 100644 --- a/airtaudio/api/CoreIos.h +++ b/airtaudio/api/CoreIos.h @@ -46,7 +46,7 @@ namespace airtaudio { void callBackEvent(void* _data, int32_t _frameRate); public: - std::unique_ptr m_private; + std11::shared_ptr m_private; }; }; }; diff --git a/airtaudio/api/CoreIos.mm b/airtaudio/api/CoreIos.mm index e5b8a2f..ba55b71 100644 --- a/airtaudio/api/CoreIos.mm +++ b/airtaudio/api/CoreIos.mm @@ -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 status; if (m_doConvertBuffer[modeToIdTable(airtaudio::mode_output)] == true) { doStopStream = m_callback(nullptr, diff --git a/airtaudio/api/Ds.cpp b/airtaudio/api/Ds.cpp index 9a5a34e..33db3e7 100644 --- a/airtaudio/api/Ds.cpp +++ b/airtaudio/api/Ds.cpp @@ -74,7 +74,7 @@ namespace airtaudio { namespace api { class DsPrivate { public: - std::unique_ptr thread; + std11::shared_ptr 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 tmpThread(new std::thread(&airtaudio::api::Ds::dsCallbackEvent, this)); + std11::shared_ptr 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) { diff --git a/airtaudio/api/Ds.h b/airtaudio/api/Ds.h index 09145dc..ab39c28 100644 --- a/airtaudio/api/Ds.h +++ b/airtaudio/api/Ds.h @@ -36,7 +36,7 @@ namespace airtaudio { void callbackEvent(); private: static void dsCallbackEvent(void *_userData); - std::unique_ptr m_private; + std11::shared_ptr m_private; bool m_coInitialized; bool m_buffersRolling; long m_duplexPrerollBytes; diff --git a/airtaudio/api/Jack.cpp b/airtaudio/api/Jack.cpp index 300ac2a..f8b3d8e 100644 --- a/airtaudio/api/Jack.cpp +++ b/airtaudio/api/Jack.cpp @@ -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 lck(m_mutex); + std11::unique_lock 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 streamTime = getStreamTime(); + std11::chrono::time_point streamTime = getStreamTime(); std::vector 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) { diff --git a/airtaudio/api/Jack.h b/airtaudio/api/Jack.h index ead1a85..539a1ff 100644 --- a/airtaudio/api/Jack.h +++ b/airtaudio/api/Jack.h @@ -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 m_private; + std11::shared_ptr m_private; bool probeDeviceOpen(uint32_t _device, airtaudio::mode _mode, uint32_t _channels, diff --git a/airtaudio/api/Oss.cpp b/airtaudio/api/Oss.cpp index 83cffb6..91b7b77 100644 --- a/airtaudio/api/Oss.cpp +++ b/airtaudio/api/Oss.cpp @@ -35,8 +35,8 @@ namespace airtaudio { int32_t id[2]; // device ids bool xrun[2]; bool triggered; - std::condition_variable runnable; - std::unique_ptr thread; + std11::condition_variable runnable; + std11::shared_ptr 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 lck(m_mutex); + std11::unique_lock 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 status; if ( m_mode != airtaudio::mode_input && m_private->xrun[0] == true) { diff --git a/airtaudio/api/Oss.h b/airtaudio/api/Oss.h index 979e822..1abacca 100644 --- a/airtaudio/api/Oss.h +++ b/airtaudio/api/Oss.h @@ -32,7 +32,7 @@ namespace airtaudio { // will most likely produce highly undesireable results! void callbackEvent(); private: - std::unique_ptr m_private; + std11::shared_ptr m_private; bool probeDeviceOpen(uint32_t _device, airtaudio::mode _mode, uint32_t _channels, diff --git a/airtaudio/api/Pulse.cpp b/airtaudio/api/Pulse.cpp index 95cc650..cc7f453 100644 --- a/airtaudio/api/Pulse.cpp +++ b/airtaudio/api/Pulse.cpp @@ -53,9 +53,9 @@ namespace airtaudio { public: pa_simple *s_play; pa_simple *s_rec; - std::unique_ptr thread; + std11::shared_ptr 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 lck(m_mutex); + std11::unique_lock 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 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 tmpThread(new std::thread(&pulseaudio_callback, this)); + std11::shared_ptr tmpThread(new std11::thread(&pulseaudio_callback, this)); m_private->thread = std::move(tmpThread); if (m_private->thread == nullptr) { ATA_ERROR("error creating thread."); diff --git a/airtaudio/api/Pulse.h b/airtaudio/api/Pulse.h index bd1d7c7..42d85c2 100644 --- a/airtaudio/api/Pulse.h +++ b/airtaudio/api/Pulse.h @@ -33,7 +33,7 @@ namespace airtaudio { void callbackEventOneCycle(); void callbackEvent(); private: - std::unique_ptr m_private; + std11::shared_ptr m_private; std::vector m_devices; void saveDeviceInfo(); bool probeDeviceOpen(uint32_t _device, diff --git a/airtaudio/base.h b/airtaudio/base.h index 4cf3b8e..5474592 100644 --- a/airtaudio/base.h +++ b/airtaudio/base.h @@ -8,10 +8,21 @@ #ifndef __AIRTAUDIO_CB_H__ #define __AIRTAUDIO_CB_H__ -#include -#include -#include -#include +#if __cplusplus >= 201103L + #include + #include + #include + #include + #include + #include +#else + #include + #include + #include + #include + #include + #include +#endif #include