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

Compare commits

base: musicdsp:c3a13b4a3936be193a1dc597640567a60120305d
Branches Tags
musicdsp:main
musicdsp:dev
musicdsp:gh-pages
musicdsp:dev-nao
musicdsp:v1.0.0
musicdsp:0.4.0
musicdsp:0.3.1
musicdsp:0.3.0
musicdsp:0.2.0
musicdsp:0.1.0
musicdsp:0.0.0
...
compare: musicdsp:5a9c89e4fe3df107b95fceaebee3b163a3d14d12
Branches Tags
musicdsp:dev
musicdsp:main
musicdsp:gh-pages
musicdsp:dev-nao
musicdsp:v1.0.0
musicdsp:0.4.0
musicdsp:0.3.1
musicdsp:0.3.0
musicdsp:0.2.0
musicdsp:0.1.0
musicdsp:0.0.0

10 Commits
c3a13b4a39 ... 5a9c89e4fe

Author SHA1 Message Date
Edouard DUPIN
5a9c89e4fe [RELEASE] Release v1.0.0 2021-02-16 21:47:42 +01:00
Edouard DUPIN
69f60f45fe [DEBUG] update new API of lutin log 2019-05-03 10:18:23 +02:00
Edouard DUPIN
28237ad66f [DEV] update etk null 2018-06-19 22:13:48 +02:00
Edouard DUPIN
0b8c0e3fd4 [DEV] update to the new ETK allocator wrapper 2017-10-21 19:05:21 +02:00
Edouard DUPIN
309b63254f [DEV] update new ETK 2017-09-26 15:57:44 +02:00
Edouard DUPIN
4bc3ff2f1a [DEV] continue removing STL 2017-09-14 00:59:21 +02:00
Edouard DUPIN
dfc867db87 [DEV] remove STL 2017-09-07 23:38:26 +02:00
Edouard DUPIN
a4ba319ffc [DEV] continue removing stl 2017-08-28 00:08:41 +02:00
Edouard DUPIN
bcff6508ab [DEBUG] corect puseaudio include 2017-04-12 23:35:49 +02:00
Edouard DUPIN
2a9f28b962 [DEV] update dev tag version 2016-10-24 21:55:23 +02:00
45 changed files with 717 additions and 742 deletions
Show Stats Expand all files Collapse all files

83
audio/orchestra/Api.cpp
View File

@ -8,40 +8,37 @@
//#include <etk/types.hpp>
#include <audio/orchestra/Interface.hpp>
#include <audio/orchestra/debug.hpp>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <climits>
#include <etk/types.hpp>
// Static variable definitions.
const std::vector<uint32_t>& audio::orchestra::genericSampleRate() {
static std::vector<uint32_t> list;
const etk::Vector<uint32_t>& audio::orchestra::genericSampleRate() {
static etk::Vector<uint32_t> list;
if (list.size() == 0) {
list.push_back(4000);
list.push_back(5512);
list.push_back(8000);
list.push_back(9600);
list.push_back(11025);
list.push_back(16000);
list.push_back(22050);
list.push_back(32000);
list.push_back(44100);
list.push_back(48000);
list.push_back(64000);
list.push_back(88200);
list.push_back(96000);
list.push_back(128000);
list.push_back(176400);
list.push_back(192000);
list.push_back(256000);
list.pushBack(4000);
list.pushBack(5512);
list.pushBack(8000);
list.pushBack(9600);
list.pushBack(11025);
list.pushBack(16000);
list.pushBack(22050);
list.pushBack(32000);
list.pushBack(44100);
list.pushBack(48000);
list.pushBack(64000);
list.pushBack(88200);
list.pushBack(96000);
list.pushBack(128000);
list.pushBack(176400);
list.pushBack(192000);
list.pushBack(256000);
}
return list;
};
audio::orchestra::Api::Api() :
m_callback(nullptr),
m_deviceBuffer(nullptr) {
m_callback(null),
m_deviceBuffer(null) {
m_device[0] = 11111;
m_device[1] = 11111;
m_state = audio::orchestra::state::closed;
@ -55,7 +52,7 @@ audio::orchestra::Api::~Api() {
enum audio::orchestra::error audio::orchestra::Api::startStream() {
ATA_VERBOSE("Start Stream");
m_startTime = audio::Time::now();
m_duration = std::chrono::microseconds(0);
m_duration = echrono::microseconds(0);
return audio::orchestra::error_none;
}
@ -70,19 +67,19 @@ enum audio::orchestra::error audio::orchestra::Api::openStream(audio::orchestra:
ATA_ERROR("a stream is already open!");
return audio::orchestra::error_invalidUse;
}
if ( _oParams != nullptr
if ( _oParams != null
&& _oParams->nChannels < 1) {
ATA_ERROR("a non-nullptr output StreamParameters structure cannot have an nChannels value less than one.");
ATA_ERROR("a non-null output StreamParameters structure cannot have an nChannels value less than one.");
return audio::orchestra::error_invalidUse;
}
if ( _iParams != nullptr
if ( _iParams != null
&& _iParams->nChannels < 1) {
ATA_ERROR("a non-nullptr input StreamParameters structure cannot have an nChannels value less than one.");
ATA_ERROR("a non-null input StreamParameters structure cannot have an nChannels value less than one.");
return audio::orchestra::error_invalidUse;
}
if ( _oParams == nullptr
&& _iParams == nullptr) {
ATA_ERROR("input and output StreamParameters structures are both nullptr!");
if ( _oParams == null
&& _iParams == null) {
ATA_ERROR("input and output StreamParameters structures are both null!");
return audio::orchestra::error_invalidUse;
}
if (audio::getFormatBytes(_format) == 0) {
@ -91,7 +88,7 @@ enum audio::orchestra::error audio::orchestra::Api::openStream(audio::orchestra:
}
uint32_t nDevices = getDeviceCount();
uint32_t oChannels = 0;
if (_oParams != nullptr) {
if (_oParams != null) {
oChannels = _oParams->nChannels;
if ( _oParams->deviceId >= nDevices
&& _oParams->deviceName == "") {
@ -100,7 +97,7 @@ enum audio::orchestra::error audio::orchestra::Api::openStream(audio::orchestra:
}
}
uint32_t iChannels = 0;
if (_iParams != nullptr) {
if (_iParams != null) {
iChannels = _iParams->nChannels;
if ( _iParams->deviceId >= nDevices
&& _iParams->deviceName == "") {
@ -250,8 +247,8 @@ void audio::orchestra::Api::clearStreamInfo() {
m_userFormat = audio::format_unknow;
m_startTime = audio::Time();
m_duration = audio::Duration(0);
m_deviceBuffer = nullptr;
m_callback = nullptr;
m_deviceBuffer = null;
m_callback = null;
for (int32_t iii=0; iii<2; ++iii) {
m_device[iii] = 11111;
m_doConvertBuffer[iii] = false;
@ -295,21 +292,21 @@ void audio::orchestra::Api::setConvertInfo(audio::orchestra::mode _mode, uint32_
if (m_deviceInterleaved[idTable] == false) {
if (_mode == audio::orchestra::mode_input) {
for (int32_t kkk=0; kkk<m_convertInfo[idTable].channels; ++kkk) {
m_convertInfo[idTable].inOffset.push_back(kkk * m_bufferSize);
m_convertInfo[idTable].outOffset.push_back(kkk);
m_convertInfo[idTable].inOffset.pushBack(kkk * m_bufferSize);
m_convertInfo[idTable].outOffset.pushBack(kkk);
m_convertInfo[idTable].inJump = 1;
}
} else {
for (int32_t kkk=0; kkk<m_convertInfo[idTable].channels; ++kkk) {
m_convertInfo[idTable].inOffset.push_back(kkk);
m_convertInfo[idTable].outOffset.push_back(kkk * m_bufferSize);
m_convertInfo[idTable].inOffset.pushBack(kkk);
m_convertInfo[idTable].outOffset.pushBack(kkk * m_bufferSize);
m_convertInfo[idTable].outJump = 1;
}
}
} else { // no (de)interleaving
for (int32_t kkk=0; kkk<m_convertInfo[idTable].channels; ++kkk) {
m_convertInfo[idTable].inOffset.push_back(kkk);
m_convertInfo[idTable].outOffset.push_back(kkk);
m_convertInfo[idTable].inOffset.pushBack(kkk);
m_convertInfo[idTable].outOffset.pushBack(kkk);
}
}

38
audio/orchestra/Api.hpp
View File

@ -6,7 +6,7 @@
*/
#pragma once
#include <sstream>
#include <etk/Stream.hpp>
#include <audio/orchestra/debug.hpp>
#include <audio/orchestra/type.hpp>
#include <audio/orchestra/state.hpp>
@ -22,22 +22,22 @@ namespace audio {
* @brief Audio-orchestra library namespace
*/
namespace orchestra {
const std::vector<uint32_t>& genericSampleRate();
const etk::Vector<uint32_t>& genericSampleRate();
/**
* @brief airtaudio callback function prototype.
* @param _inputBuffer For input (or duplex) streams, this buffer will hold _nbChunk of input audio chunk (nullptr if no data).
* @param _inputBuffer For input (or duplex) streams, this buffer will hold _nbChunk of input audio chunk (null if no data).
* @param _timeInput Timestamp of the first buffer sample (recording time).
* @param _outputBuffer For output (or duplex) streams, the client should write _nbChunk of audio chunk into this buffer (nullptr if no data).
* @param _outputBuffer For output (or duplex) streams, the client should write _nbChunk of audio chunk into this buffer (null if no data).
* @param _timeOutput Timestamp of the first buffer sample (playing time).
* @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 audio::Time& _timeInput,
void* _outputBuffer,
const audio::Time& _timeOutput,
uint32_t _nbChunk,
const std::vector<audio::orchestra::status>& _status)> AirTAudioCallback;
typedef etk::Function<int32_t (const void* _inputBuffer,
const audio::Time& _timeInput,
void* _outputBuffer,
const audio::Time& _timeOutput,
uint32_t _nbChunk,
const etk::Vector<audio::orchestra::status>& _status)> AirTAudioCallback;
// A protected structure used for buffer conversion.
class ConvertInfo {
public:
@ -46,24 +46,24 @@ namespace audio {
int32_t outJump;
enum audio::format inFormat;
enum audio::format outFormat;
std::vector<int> inOffset;
std::vector<int> outOffset;
etk::Vector<int> inOffset;
etk::Vector<int> outOffset;
};
class Api : public ememory::EnableSharedFromThis<Api>{
protected:
std::string m_name;
etk::String m_name;
public:
Api();
virtual ~Api();
void setName(const std::string& _name) {
void setName(const etk::String& _name) {
m_name = _name;
}
virtual const std::string& getCurrentApi() = 0;
virtual const etk::String& getCurrentApi() = 0;
virtual uint32_t getDeviceCount() = 0;
virtual audio::orchestra::DeviceInfo getDeviceInfo(uint32_t _device) = 0;
// TODO : Check API ...
virtual bool getNamedDeviceInfo(const std::string& _deviceName, audio::orchestra::DeviceInfo& _info) {
virtual bool getNamedDeviceInfo(const etk::String& _deviceName, audio::orchestra::DeviceInfo& _info) {
return false;
}
virtual uint32_t getDefaultInputDevice();
@ -90,12 +90,12 @@ namespace audio {
}
protected:
mutable std::mutex m_mutex;
mutable ethread::Mutex m_mutex;
audio::orchestra::AirTAudioCallback m_callback;
uint32_t m_device[2]; // Playback and record, respectively.
enum audio::orchestra::mode m_mode; // audio::orchestra::mode_output, audio::orchestra::mode_input, or audio::orchestra::mode_duplex.
enum audio::orchestra::state m_state; // STOPPED, RUNNING, or CLOSED
std::vector<char> m_userBuffer[2]; // Playback and record, respectively.
etk::Vector<char> m_userBuffer[2]; // Playback and record, respectively.
char *m_deviceBuffer;
bool m_doConvertBuffer[2]; // Playback and record, respectively.
bool m_deviceInterleaved[2]; // Playback and record, respectively.
@ -130,7 +130,7 @@ namespace audio {
enum audio::format _format,
uint32_t *_bufferSize,
const audio::orchestra::StreamOptions& _options);
virtual bool openName(const std::string& _deviceName,
virtual bool openName(const etk::String& _deviceName,
audio::orchestra::mode _mode,
uint32_t _channels,
uint32_t _firstChannel,

5
audio/orchestra/DeviceInfo.cpp
View File

@ -9,10 +9,9 @@
#include <audio/orchestra/debug.hpp>
#include <audio/orchestra/DeviceInfo.hpp>
#include <etk/stdTools.hpp>
#include <iostream>
void audio::orchestra::DeviceInfo::display(int32_t _tabNumber) const {
std::string space;
etk::String space;
for (int32_t iii=0; iii<_tabNumber; ++iii) {
space += " ";
}
@ -42,7 +41,7 @@ void audio::orchestra::DeviceInfo::clear() {
isDefault = false;
}
std::ostream& audio::orchestra::operator <<(std::ostream& _os, const audio::orchestra::DeviceInfo& _obj) {
etk::Stream& audio::orchestra::operator <<(etk::Stream& _os, const audio::orchestra::DeviceInfo& _obj) {
_os << "{";
if (_obj.isCorrect == false) {
_os << "NOT CORRECT INFORAMATIONS";

12
audio/orchestra/DeviceInfo.hpp
View File

@ -18,11 +18,11 @@ namespace audio {
public:
bool isCorrect; //!< the information is correct (the system can return information incorect).
bool input; //!< true if the device in an input; false: output.
std::string name; //!< Character string device identifier.
std::string desc; //!< description of the device
std::vector<audio::channel> channels; //!< Channels interfaces.
std::vector<uint32_t> sampleRates; //!< Supported sample rates (queried from list of standard rates).
std::vector<audio::format> nativeFormats; //!< Bit mask of supported data formats.
etk::String name; //!< Character string device identifier.
etk::String desc; //!< description of the device
etk::Vector<audio::channel> channels; //!< Channels interfaces.
etk::Vector<uint32_t> sampleRates; //!< Supported sample rates (queried from list of standard rates).
etk::Vector<audio::format> nativeFormats; //!< Bit mask of supported data formats.
bool isDefault; //! is default input/output
// Default constructor.
DeviceInfo() :
@ -43,7 +43,7 @@ namespace audio {
*/
void clear();
};
std::ostream& operator <<(std::ostream& _os, const audio::orchestra::DeviceInfo& _obj);
etk::Stream& operator <<(etk::Stream& _os, const audio::orchestra::DeviceInfo& _obj);
}
}

41
audio/orchestra/Interface.cpp
View File

@ -8,7 +8,6 @@
//#include <etk/types.hpp>
#include <audio/orchestra/Interface.hpp>
#include <audio/orchestra/debug.hpp>
#include <iostream>
#include <audio/orchestra/api/Alsa.hpp>
#include <audio/orchestra/api/Android.hpp>
#include <audio/orchestra/api/Asio.hpp>
@ -19,26 +18,26 @@
#include <audio/orchestra/api/Jack.hpp>
#include <audio/orchestra/api/Pulse.hpp>
std::vector<std::string> audio::orchestra::Interface::getListApi() {
std::vector<std::string> apis;
etk::Vector<etk::String> audio::orchestra::Interface::getListApi() {
etk::Vector<etk::String> apis;
// The order here will control the order of RtAudio's API search in
// the constructor.
for (size_t iii=0; iii<m_apiAvaillable.size(); ++iii) {
apis.push_back(m_apiAvaillable[iii].first);
apis.pushBack(m_apiAvaillable[iii].first);
}
return apis;
}
void audio::orchestra::Interface::openApi(const std::string& _api) {
void audio::orchestra::Interface::openApi(const etk::String& _api) {
m_api.reset();
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_api = m_apiAvaillable[iii].second();
if (m_api != nullptr) {
if (m_api != null) {
return;
}
}
@ -49,7 +48,7 @@ void audio::orchestra::Interface::openApi(const std::string& _api) {
audio::orchestra::Interface::Interface() :
m_api(nullptr) {
m_api(null) {
ATA_DEBUG("Add interface:");
#if defined(ORCHESTRA_BUILD_JACK)
addInterface(audio::orchestra::typeJack, audio::orchestra::api::Jack::create);
@ -80,13 +79,13 @@ audio::orchestra::Interface::Interface() :
#endif
}
void audio::orchestra::Interface::addInterface(const std::string& _api, ememory::SharedPtr<Api> (*_callbackCreate)()) {
m_apiAvaillable.push_back(std::pair<std::string, ememory::SharedPtr<Api> (*)()>(_api, _callbackCreate));
void audio::orchestra::Interface::addInterface(const etk::String& _api, ememory::SharedPtr<Api> (*_callbackCreate)()) {
m_apiAvaillable.pushBack(etk::Pair<etk::String, ememory::SharedPtr<Api> (*)()>(_api, _callbackCreate));
}
enum audio::orchestra::error audio::orchestra::Interface::clear() {
ATA_INFO("Clear API ...");
if (m_api == nullptr) {
if (m_api == null) {
ATA_WARNING("Interface NOT started!");
return audio::orchestra::error_none;
}
@ -94,9 +93,9 @@ enum audio::orchestra::error audio::orchestra::Interface::clear() {
return audio::orchestra::error_none;
}
enum audio::orchestra::error audio::orchestra::Interface::instanciate(const std::string& _api) {
enum audio::orchestra::error audio::orchestra::Interface::instanciate(const etk::String& _api) {
ATA_INFO("Instanciate API ...");
if (m_api != nullptr) {
if (m_api != null) {
ATA_WARNING("Interface already started!");
return audio::orchestra::error_none;
}
@ -104,7 +103,7 @@ enum audio::orchestra::error audio::orchestra::Interface::instanciate(const std:
ATA_INFO("API specified : " << _api);
// Attempt to open the specified API.
openApi(_api);
if (m_api != nullptr) {
if (m_api != null) {
if (m_api->getDeviceCount() != 0) {
ATA_INFO(" ==> api open");
}
@ -118,12 +117,12 @@ enum audio::orchestra::error audio::orchestra::Interface::instanciate(const std:
ATA_INFO("Auto choice API :");
// Iterate through the compiled APIs and return as soon as we find
// one with at least one device or we reach the end of the list.
std::vector<std::string> apis = getListApi();
etk::Vector<etk::String> apis = getListApi();
ATA_INFO(" find : " << apis.size() << " apis.");
for (size_t iii=0; iii<apis.size(); ++iii) {
ATA_INFO("try open ...");
openApi(apis[iii]);
if(m_api == nullptr) {
if(m_api == null) {
ATA_ERROR(" ==> can not create ...");
continue;
}
@ -134,7 +133,7 @@ enum audio::orchestra::error audio::orchestra::Interface::instanciate(const std:
ATA_INFO(" ==> Interface exist, but have no devices: " << m_api->getDeviceCount());
}
}
if (m_api != nullptr) {
if (m_api != null) {
return audio::orchestra::error_none;
}
ATA_ERROR("API NOT Supported '" << _api << "' not in " << getListApi());
@ -153,7 +152,7 @@ enum audio::orchestra::error audio::orchestra::Interface::openStream(audio::orch
uint32_t* _bufferFrames,
audio::orchestra::AirTAudioCallback _callback,
const audio::orchestra::StreamOptions& _options) {
if (m_api == nullptr) {
if (m_api == null) {
return audio::orchestra::error_inputNull;
}
return m_api->openStream(_outputParameters,
@ -166,12 +165,12 @@ enum audio::orchestra::error audio::orchestra::Interface::openStream(audio::orch
}
bool audio::orchestra::Interface::isMasterOf(audio::orchestra::Interface& _interface) {
if (m_api == nullptr) {
ATA_ERROR("Current Master API is nullptr ...");
if (m_api == null) {
ATA_ERROR("Current Master API is null ...");
return false;
}
if (_interface.m_api == nullptr) {
ATA_ERROR("Current Slave API is nullptr ...");
if (_interface.m_api == null) {
ATA_ERROR("Current Slave API is null ...");
return false;
}
if (m_api->getCurrentApi() != _interface.m_api->getCurrentApi()) {

69
audio/orchestra/Interface.hpp
View File

@ -6,8 +6,9 @@
*/
#pragma once
#include <string>
#include <vector>
#include <etk/String.hpp>
#include <etk/Vector.hpp>
#include <etk/Pair.hpp>
#include <audio/orchestra/base.hpp>
#include <audio/orchestra/CallbackInfo.hpp>
#include <audio/orchestra/Api.hpp>
@ -26,12 +27,12 @@ namespace audio {
*/
class Interface {
protected:
std::vector<std::pair<std::string, ememory::SharedPtr<Api> (*)()> > m_apiAvaillable;
etk::Vector<etk::Pair<etk::String, ememory::SharedPtr<Api> (*)()> > m_apiAvaillable;
protected:
ememory::SharedPtr<audio::orchestra::Api> m_api;
public:
void setName(const std::string& _name) {
if (m_api == nullptr) {
void setName(const etk::String& _name) {
if (m_api == null) {
return;
}
m_api->setName(_name);
@ -40,13 +41,13 @@ namespace audio {
* @brief Get the list of all availlable API in the system.
* @return the list of all APIs
*/
std::vector<std::string> getListApi();
etk::Vector<etk::String> getListApi();
/**
* @brief Add an interface of the Possible List.
* @param[in] _api Type of the interface.
* @param[in] _callbackCreate API creation callback.
*/
void addInterface(const std::string& _api, ememory::SharedPtr<Api> (*_callbackCreate)());
void addInterface(const etk::String& _api, ememory::SharedPtr<Api> (*_callbackCreate)());
/**
* @brief The class constructor.
* @note the creating of the basic instance is done by Instanciate
@ -66,12 +67,12 @@ namespace audio {
/**
* @brief Create an interface instance
*/
enum audio::orchestra::error instanciate(const std::string& _api = audio::orchestra::typeUndefined);
enum audio::orchestra::error instanciate(const etk::String& _api = audio::orchestra::typeUndefined);
/**
* @return the audio API specifier for the current instance of airtaudio.
*/
const std::string& getCurrentApi() {
if (m_api == nullptr) {
const etk::String& getCurrentApi() {
if (m_api == null) {
return audio::orchestra::typeUndefined;
}
return m_api->getCurrentApi();
@ -84,7 +85,7 @@ namespace audio {
* a system error occurs during processing, a warning will be issued.
*/
uint32_t getDeviceCount() {
if (m_api == nullptr) {
if (m_api == null) {
return 0;
}
return m_api->getDeviceCount();
@ -101,13 +102,13 @@ namespace audio {
* @return An audio::orchestra::DeviceInfo structure for a specified device number.
*/
audio::orchestra::DeviceInfo getDeviceInfo(uint32_t _device) {
if (m_api == nullptr) {
if (m_api == null) {
return audio::orchestra::DeviceInfo();
}
return m_api->getDeviceInfo(_device);
}
audio::orchestra::DeviceInfo getDeviceInfo(const std::string& _deviceName) {
if (m_api == nullptr) {
audio::orchestra::DeviceInfo getDeviceInfo(const etk::String& _deviceName) {
if (m_api == null) {
return audio::orchestra::DeviceInfo();
}
audio::orchestra::DeviceInfo info;
@ -124,7 +125,7 @@ namespace audio {
* before attempting to open a stream.
*/
uint32_t getDefaultOutputDevice() {
if (m_api == nullptr) {
if (m_api == null) {
return 0;
}
return m_api->getDefaultOutputDevice();
@ -139,7 +140,7 @@ namespace audio {
* before attempting to open a stream.
*/
uint32_t getDefaultInputDevice() {
if (m_api == nullptr) {
if (m_api == null) {
return 0;
}
return m_api->getDefaultInputDevice();
@ -154,12 +155,12 @@ namespace audio {
* @param _outputParameters Specifies output stream parameters to use
* when opening a stream, including a device ID, number of channels,
* and starting channel number. For input-only streams, this
* argument should be nullptr. The device ID is an index value between
* argument should be null. The device ID is an index value between
* 0 and getDeviceCount() - 1.
* @param _inputParameters Specifies input stream parameters to use
* when opening a stream, including a device ID, number of channels,
* and starting channel number. For output-only streams, this
* argument should be nullptr. The device ID is an index value between
* argument should be null. The device ID is an index value between
* 0 and getDeviceCount() - 1.
* @param _format An audio::format specifying the desired sample data format.
* @param _sampleRate The desired sample rate (sample frames per second).
@ -183,12 +184,12 @@ namespace audio {
* when an error has occured.
*/
enum audio::orchestra::error openStream(audio::orchestra::StreamParameters *_outputParameters,
audio::orchestra::StreamParameters *_inputParameters,
enum audio::format _format,
uint32_t _sampleRate,
uint32_t* _bufferFrames,
audio::orchestra::AirTAudioCallback _callback,
const audio::orchestra::StreamOptions& _options = audio::orchestra::StreamOptions());
audio::orchestra::StreamParameters *_inputParameters,
enum audio::format _format,
uint32_t _sampleRate,
uint32_t* _bufferFrames,
audio::orchestra::AirTAudioCallback _callback,
const audio::orchestra::StreamOptions& _options = audio::orchestra::StreamOptions());
/**
* @brief A function that closes a stream and frees any associated stream memory.
@ -197,7 +198,7 @@ namespace audio {
* returns (no exception is thrown).
*/
enum audio::orchestra::error closeStream() {
if (m_api == nullptr) {
if (m_api == null) {
return audio::orchestra::error_inputNull;
}
return m_api->closeStream();
@ -211,7 +212,7 @@ namespace audio {
* running.
*/
enum audio::orchestra::error startStream() {
if (m_api == nullptr) {
if (m_api == null) {
return audio::orchestra::error_inputNull;
}
return m_api->startStream();
@ -225,7 +226,7 @@ namespace audio {
* stopped.
*/
enum audio::orchestra::error stopStream() {
if (m_api == nullptr) {
if (m_api == null) {
return audio::orchestra::error_inputNull;
}
return m_api->stopStream();
@ -238,7 +239,7 @@ namespace audio {
* stopped.
*/
enum audio::orchestra::error abortStream() {
if (m_api == nullptr) {
if (m_api == null) {
return audio::orchestra::error_inputNull;
}
return m_api->abortStream();
@ -247,7 +248,7 @@ namespace audio {
* @return true if a stream is open and false if not.
*/
bool isStreamOpen() const {
if (m_api == nullptr) {
if (m_api == null) {
return false;
}
return m_api->isStreamOpen();
@ -256,7 +257,7 @@ namespace audio {
* @return true if the stream is running and false if it is stopped or not open.
*/
bool isStreamRunning() const {
if (m_api == nullptr) {
if (m_api == null) {
return false;
}
return m_api->isStreamRunning();
@ -266,7 +267,7 @@ namespace audio {
* @return the number of elapsed seconds since the stream was started.
*/
audio::Time getStreamTime() {
if (m_api == nullptr) {
if (m_api == null) {
return audio::Time();
}
return m_api->getStreamTime();
@ -281,7 +282,7 @@ namespace audio {
* @return The internal stream latency in sample frames.
*/
long getStreamLatency() {
if (m_api == nullptr) {
if (m_api == null) {
return 0;
}
return m_api->getStreamLatency();
@ -293,14 +294,14 @@ namespace audio {
* @return Returns actual sample rate in use by the stream.
*/
uint32_t getStreamSampleRate() {
if (m_api == nullptr) {
if (m_api == null) {
return 0;
}
return m_api->getStreamSampleRate();
}
bool isMasterOf(audio::orchestra::Interface& _interface);
protected:
void openApi(const std::string& _api);
void openApi(const etk::String& _api);
};
}
}

6
audio/orchestra/StreamOptions.cpp
View File

@ -15,13 +15,13 @@ static const char* listValue[] = {
"soft"
};
std::ostream& audio::orchestra::operator <<(std::ostream& _os, enum audio::orchestra::timestampMode _obj) {
etk::Stream& audio::orchestra::operator <<(etk::Stream& _os, enum audio::orchestra::timestampMode _obj) {
_os << listValue[_obj];
return _os;
}
namespace etk {
template <> bool from_string<enum audio::orchestra::timestampMode>(enum audio::orchestra::timestampMode& _variableRet, const std::string& _value) {
template <> bool from_string<enum audio::orchestra::timestampMode>(enum audio::orchestra::timestampMode& _variableRet, const etk::String& _value) {
if (_value == "hardware") {
_variableRet = audio::orchestra::timestampMode_Hardware;
return true;
@ -37,7 +37,7 @@ namespace etk {
return false;
}
template <enum audio::orchestra::timestampMode> std::string to_string(const enum audio::orchestra::timestampMode& _variable) {
template <enum audio::orchestra::timestampMode> etk::String toString(const enum audio::orchestra::timestampMode& _variable) {
return listValue[_variable];
}
}

5
audio/orchestra/StreamOptions.hpp
View File

@ -7,6 +7,7 @@
#pragma once
#include <audio/orchestra/Flags.hpp>
#include <etk/String.hpp>
namespace audio {
namespace orchestra {
@ -15,13 +16,13 @@ namespace audio {
timestampMode_trigered, //!< get harware triger time stamp and increment with duration
timestampMode_soft, //!< Simulate all timestamp.
};
std::ostream& operator <<(std::ostream& _os, enum audio::orchestra::timestampMode _obj);
etk::Stream& operator <<(etk::Stream& _os, enum audio::orchestra::timestampMode _obj);
class StreamOptions {
public:
audio::orchestra::Flags flags; //!< A bit-mask of stream flags
uint32_t numberOfBuffers; //!< Number of stream buffers.
std::string streamName; //!< A stream name (currently used only in Jack).
etk::String streamName; //!< A stream name (currently used only in Jack).
enum timestampMode mode; //!< mode of timestamping data...
// Default constructor.
StreamOptions() :

2
audio/orchestra/StreamParameters.hpp
View File

@ -14,7 +14,7 @@ namespace audio {
class StreamParameters {
public:
int32_t deviceId; //!< Device index (-1 to getDeviceCount() - 1).
std::string deviceName; //!< name of the device (if deviceId==-1 this must not be == "", and the oposite ...)
etk::String deviceName; //!< name of the device (if deviceId==-1 this must not be == "", and the oposite ...)
uint32_t nChannels; //!< Number of channels.
uint32_t firstChannel; //!< First channel index on device (default = 0).
// Default constructor.

173
audio/orchestra/api/Alsa.cpp
View File

@ -14,22 +14,22 @@
#include <audio/orchestra/debug.hpp>
#include <etk/stdTools.hpp>
#include <ethread/tools.hpp>
#include <climits>
#include <audio/orchestra/api/Alsa.hpp>
extern "C" {
#include <sched.h>
#include <getopt.h>
#include <sys/time.h>
#include <poll.h>
#include <sched.h>
#include <getopt.h>
#include <sys/time.h>
#include <poll.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <limits.h>
}
#include <cerrno>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::Alsa::create() {
return ememory::SharedPtr<audio::orchestra::api::Alsa>(new audio::orchestra::api::Alsa());
return ememory::SharedPtr<audio::orchestra::api::Alsa>(ETK_NEW(audio::orchestra::api::Alsa));
}
namespace audio {
@ -39,17 +39,17 @@ namespace audio {
public:
snd_pcm_t *handle;
bool xrun[2];
std::condition_variable runnable_cv;
ethread::Semaphore m_semaphore;
bool runnable;
std::thread* thread;
ethread::Thread* thread;
bool threadRunning;
bool mmapInterface; //!< enable or disable mmap mode...
enum timestampMode timeMode; //!< the timestamp of the flow came from the harware.
std::vector<snd_pcm_channel_area_t> areas;
etk::Vector<snd_pcm_channel_area_t> areas;
AlsaPrivate() :
handle(nullptr),
handle(null),
runnable(false),
thread(nullptr),
thread(null),
threadRunning(false),
mmapInterface(false),
timeMode(timestampMode_soft) {
@ -112,7 +112,7 @@ nextcard:
return nDevices;
}
bool audio::orchestra::api::Alsa::getNamedDeviceInfoLocal(const std::string& _deviceName, audio::orchestra::DeviceInfo& _info, int32_t _cardId, int32_t _subdevice, int32_t _localDeviceId, bool _input) {
bool audio::orchestra::api::Alsa::getNamedDeviceInfoLocal(const etk::String& _deviceName, audio::orchestra::DeviceInfo& _info, int32_t _cardId, int32_t _subdevice, int32_t _localDeviceId, bool _input) {
int32_t result;
snd_ctl_t *chandle;
int32_t openMode = SND_PCM_ASYNC;
@ -130,7 +130,7 @@ bool audio::orchestra::api::Alsa::getNamedDeviceInfoLocal(const std::string& _de
stream = SND_PCM_STREAM_PLAYBACK;
}
snd_pcm_info_set_stream(pcminfo, stream);
std::vector<std::string> listElement = etk::split(_deviceName, ',');
etk::Vector<etk::String> listElement = etk::split(_deviceName, ',');
if (listElement.size() == 0) {
ATA_ERROR("can not get control interface = '" << _deviceName << "' Can not plit at ',' ...");
return false;
@ -190,15 +190,13 @@ bool audio::orchestra::api::Alsa::getNamedDeviceInfoLocal(const std::string& _de
}
ATA_DEBUG("Input channel = " << value);
for (int32_t iii=0; iii<value; ++iii) {
_info.channels.push_back(audio::channel_unknow);
_info.channels.pushBack(audio::channel_unknow);
}
// Test our discrete set of sample rate values.
_info.sampleRates.clear();
for (std::vector<uint32_t>::const_iterator it(audio::orchestra::genericSampleRate().begin());
it != audio::orchestra::genericSampleRate().end();
++it ) {
if (snd_pcm_hw_params_test_rate(phandle, params, *it, 0) == 0) {
_info.sampleRates.push_back(*it);
for (auto &it: audio::orchestra::genericSampleRate()) {
if (snd_pcm_hw_params_test_rate(phandle, params, it, 0) == 0) {
_info.sampleRates.pushBack(it);
}
}
if (_info.sampleRates.size() == 0) {
@ -211,27 +209,27 @@ bool audio::orchestra::api::Alsa::getNamedDeviceInfoLocal(const std::string& _de
_info.nativeFormats.clear();
format = SND_PCM_FORMAT_S8;
if (snd_pcm_hw_params_test_format(phandle, params, format) == 0) {
_info.nativeFormats.push_back(audio::format_int8);
_info.nativeFormats.pushBack(audio::format_int8);
}
format = SND_PCM_FORMAT_S16;
if (snd_pcm_hw_params_test_format(phandle, params, format) == 0) {
_info.nativeFormats.push_back(audio::format_int16);
_info.nativeFormats.pushBack(audio::format_int16);
}
format = SND_PCM_FORMAT_S24;
if (snd_pcm_hw_params_test_format(phandle, params, format) == 0) {
_info.nativeFormats.push_back(audio::format_int24);
_info.nativeFormats.pushBack(audio::format_int24);
}
format = SND_PCM_FORMAT_S32;
if (snd_pcm_hw_params_test_format(phandle, params, format) == 0) {
_info.nativeFormats.push_back(audio::format_int32);
_info.nativeFormats.pushBack(audio::format_int32);
}
format = SND_PCM_FORMAT_FLOAT;
if (snd_pcm_hw_params_test_format(phandle, params, format) == 0) {
_info.nativeFormats.push_back(audio::format_float);
_info.nativeFormats.pushBack(audio::format_float);
}
format = SND_PCM_FORMAT_FLOAT64;
if (snd_pcm_hw_params_test_format(phandle, params, format) == 0) {
_info.nativeFormats.push_back(audio::format_double);
_info.nativeFormats.pushBack(audio::format_double);
}
// Check that we have at least one supported format
if (_info.nativeFormats.size() == 0) {
@ -406,7 +404,7 @@ foundDevice:
return openName(name, _mode, _channels, _firstChannel, _sampleRate, _format, _bufferSize, _options);
}
bool audio::orchestra::api::Alsa::openName(const std::string& _deviceName,
bool audio::orchestra::api::Alsa::openName(const etk::String& _deviceName,
audio::orchestra::mode _mode,
uint32_t _channels,
uint32_t _firstChannel,
@ -676,7 +674,7 @@ bool audio::orchestra::api::Alsa::openName(const std::string& _deviceName,
}
snd_pcm_uframes_t val;
// Set the software configuration to fill buffers with zeros and prevent device stopping on xruns.
snd_pcm_sw_params_t *swParams = nullptr;
snd_pcm_sw_params_t *swParams = null;
snd_pcm_sw_params_alloca(&swParams);
snd_pcm_sw_params_current(m_private->handle, swParams);
#if 0
@ -783,10 +781,10 @@ bool audio::orchestra::api::Alsa::openName(const std::string& _deviceName,
bufferBytes *= *_bufferSize;
if (m_deviceBuffer) {
free(m_deviceBuffer);
m_deviceBuffer = nullptr;
m_deviceBuffer = null;
}
m_deviceBuffer = (char *) calloc(bufferBytes, 1);
if (m_deviceBuffer == nullptr) {
if (m_deviceBuffer == null) {
ATA_ERROR("error allocating device buffer memory.");
goto error;
}
@ -803,8 +801,8 @@ bool audio::orchestra::api::Alsa::openName(const std::string& _deviceName,
// Setup callback thread.
m_private->threadRunning = true;
ATA_INFO("create thread ...");
m_private->thread = new std::thread(&audio::orchestra::api::Alsa::alsaCallbackEvent, this);
if (m_private->thread == nullptr) {
m_private->thread = ETK_NEW(ethread::Thread, [=]() {callbackEvent();});
if (m_private->thread == null) {
m_private->threadRunning = false;
ATA_ERROR("creating callback thread!");
goto error;
@ -814,7 +812,7 @@ bool audio::orchestra::api::Alsa::openName(const std::string& _deviceName,
error:
if (m_private->handle) {
snd_pcm_close(m_private->handle);
m_private->handle = nullptr;
m_private->handle = null;
}
for (int32_t iii=0; iii<2; ++iii) {
m_userBuffer[iii].clear();
@ -836,12 +834,12 @@ enum audio::orchestra::error audio::orchestra::api::Alsa::closeStream() {
m_mutex.lock();
if (m_state == audio::orchestra::state::stopped) {
m_private->runnable = true;
m_private->runnable_cv.notify_one();
m_private->m_semaphore.post();
}
m_mutex.unlock();
if (m_private->thread != nullptr) {
m_mutex.unLock();
if (m_private->thread != null) {
m_private->thread->join();
m_private->thread = nullptr;
m_private->thread = null;
}
if (m_state == audio::orchestra::state::running) {
m_state = audio::orchestra::state::stopped;
@ -850,7 +848,7 @@ enum audio::orchestra::error audio::orchestra::api::Alsa::closeStream() {
// close all stream :
if (m_private->handle) {
snd_pcm_close(m_private->handle);
m_private->handle = nullptr;
m_private->handle = null;
}
for (int32_t iii=0; iii<2; ++iii) {
m_userBuffer[iii].clear();
@ -865,23 +863,29 @@ enum audio::orchestra::error audio::orchestra::api::Alsa::closeStream() {
}
enum audio::orchestra::error audio::orchestra::api::Alsa::startStream() {
ATA_DEBUG("Start stream (DEGIN)");
// TODO : Check return ...
//audio::orchestra::Api::startStream();
// This method calls snd_pcm_prepare if the device isn't already in that state.
if (verifyStream() != audio::orchestra::error_none) {
ATA_WARNING("the stream not prepared!");
return audio::orchestra::error_fail;
}
if (m_state == audio::orchestra::state::running) {
ATA_ERROR("the stream is already running!");
return audio::orchestra::error_warning;
}
std::unique_lock<std::mutex> lck(m_mutex);
ATA_DEBUG("Lock");
ethread::UniqueLock lck(m_mutex);
ATA_DEBUG("Lock (done)");
int32_t result = 0;
snd_pcm_state_t state;
if (m_private->handle == nullptr) {
ATA_ERROR("send nullptr to alsa ...");
if (m_private->handle == null) {
ATA_ERROR("send null to alsa ...");
}
ATA_DEBUG("snd_pcm_state");
state = snd_pcm_state(m_private->handle);
ATA_DEBUG("snd_pcm_state (done)");
if (state != SND_PCM_STATE_PREPARED) {
ATA_ERROR("prepare stream");
result = snd_pcm_prepare(m_private->handle);
@ -893,10 +897,12 @@ enum audio::orchestra::error audio::orchestra::api::Alsa::startStream() {
m_state = audio::orchestra::state::running;
unlock:
m_private->runnable = true;
m_private->runnable_cv.notify_one();
m_private->m_semaphore.post();
if (result >= 0) {
ATA_DEBUG("Start stream (END2)");
return audio::orchestra::error_none;
}
ATA_DEBUG("Start stream (END)");
return audio::orchestra::error_systemError;
}
@ -909,7 +915,7 @@ enum audio::orchestra::error audio::orchestra::api::Alsa::stopStream() {
return audio::orchestra::error_warning;
}
m_state = audio::orchestra::state::stopped;
std::unique_lock<std::mutex> lck(m_mutex);
ethread::UniqueLock lck(m_mutex);
int32_t result = 0;
if (m_mode == audio::orchestra::mode_output) {
result = snd_pcm_drain(m_private->handle);
@ -936,7 +942,7 @@ enum audio::orchestra::error audio::orchestra::api::Alsa::abortStream() {
return audio::orchestra::error_warning;
}
m_state = audio::orchestra::state::stopped;
std::unique_lock<std::mutex> lck(m_mutex);
ethread::UniqueLock lck(m_mutex);
int32_t result = 0;
result = snd_pcm_drop(m_private->handle);
if (result < 0) {
@ -950,12 +956,6 @@ unlock:
return audio::orchestra::error_systemError;
}
void audio::orchestra::api::Alsa::alsaCallbackEvent(void *_userData) {
audio::orchestra::api::Alsa* myClass = reinterpret_cast<audio::orchestra::api::Alsa*>(_userData);
myClass->callbackEvent();
}
/**
* @briefTransfer method - write and wait for room in buffer using poll
*/
@ -979,9 +979,8 @@ static int32_t wait_for_poll(snd_pcm_t* _handle, struct pollfd* _ufds, unsigned
void audio::orchestra::api::Alsa::callbackEvent() {
// Lock while the system is not started ...
if (m_state == audio::orchestra::state::stopped) {
std::unique_lock<std::mutex> lck(m_mutex);
while (!m_private->runnable) {
m_private->runnable_cv.wait(lck);
m_private->m_semaphore.wait();
}
if (m_state != audio::orchestra::state::running) {
return;
@ -989,7 +988,7 @@ void audio::orchestra::api::Alsa::callbackEvent() {
}
ethread::setName("Alsa IO-" + m_name);
//Wait data with poll
std::vector<struct pollfd> ufds;
etk::Vector<struct pollfd> ufds;
signed short *ptr;
int32_t err, count, cptr, init;
count = snd_pcm_poll_descriptors_count(m_private->handle);
@ -1032,7 +1031,7 @@ void audio::orchestra::api::Alsa::callbackEvent() {
audio::Time audio::orchestra::api::Alsa::getStreamTime() {
//ATA_DEBUG("mode : " << m_private->timeMode);
if (m_private->timeMode == timestampMode_Hardware) {
snd_pcm_status_t *status = nullptr;
snd_pcm_status_t *status = null;
snd_pcm_status_alloca(&status);
// get harware timestamp all the time:
snd_pcm_status(m_private->handle, status);
@ -1055,7 +1054,7 @@ audio::Time audio::orchestra::api::Alsa::getStreamTime() {
ATA_VERBOSE("snd_pcm_status_get_htstamp : " << m_startTime);
snd_pcm_sframes_t delay = snd_pcm_status_get_delay(status);
audio::Duration timeDelay = audio::Duration(0, delay*1000000000LL/int64_t(m_sampleRate));
ATA_VERBOSE("delay : " << timeDelay.count() << " ns");
ATA_VERBOSE("delay : " << timeDelay);
//return m_startTime + m_duration;
if (m_mode == audio::orchestra::mode_output) {
// output
@ -1067,7 +1066,7 @@ audio::Time audio::orchestra::api::Alsa::getStreamTime() {
return m_startTime;
} else if (m_private->timeMode == timestampMode_trigered) {
if (m_startTime == audio::Time()) {
snd_pcm_status_t *status = nullptr;
snd_pcm_status_t *status = null;
snd_pcm_status_alloca(&status);
// get harware timestamp all the time:
snd_pcm_status(m_private->handle, status);
@ -1106,9 +1105,9 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleRead() {
}
int32_t doStopStream = 0;
audio::Time streamTime;
std::vector<enum audio::orchestra::status> status;
etk::Vector<enum audio::orchestra::status> status;
if (m_private->xrun[0] == true) {
status.push_back(audio::orchestra::status::underflow);
status.pushBack(audio::orchestra::status::underflow);
m_private->xrun[0] = false;
}
int32_t result;
@ -1121,7 +1120,7 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleRead() {
// !!! goto unlock;
}
std::unique_lock<std::mutex> lck(m_mutex);
ethread::UniqueLock lck(m_mutex);
// Setup parameters.
if (m_doConvertBuffer[1]) {
buffer = m_deviceBuffer;
@ -1167,7 +1166,7 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleRead() {
}
} else {
ATA_ERROR("audio read error, " << snd_strerror(result) << ".");
std::this_thread::sleep_for(std::chrono::milliseconds(10));
ethread::sleepMilliSeconds((10));
}
// TODO : Notify application ... audio::orchestra::error_warning;
goto noInput;
@ -1193,7 +1192,7 @@ noInput:
audio::Time startCall = audio::Time::now();
doStopStream = m_callback(&m_userBuffer[1][0],
streamTime,// - audio::Duration(m_latency[1]*1000000000LL/int64_t(m_sampleRate)),
nullptr,
null,
audio::Time(),
m_bufferSize,
status);
@ -1201,7 +1200,7 @@ noInput:
audio::Duration timeDelay(0, m_bufferSize*1000000000LL/int64_t(m_sampleRate));
audio::Duration timeProcess = stopCall - startCall;
if (timeDelay <= timeProcess) {
ATA_ERROR("SOFT XRUN ... : (bufferTime) " << timeDelay.count() << " < " << timeProcess.count() << " (process time) ns");
ATA_ERROR("SOFT XRUN ... : (bufferTime) " << timeDelay << " < " << timeProcess << " (process time)");
}
}
if (doStopStream == 2) {
@ -1223,9 +1222,9 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleWrite() {
}
int32_t doStopStream = 0;
audio::Time streamTime;
std::vector<enum audio::orchestra::status> status;
etk::Vector<enum audio::orchestra::status> status;
if (m_private->xrun[1] == true) {
status.push_back(audio::orchestra::status::overflow);
status.pushBack(audio::orchestra::status::overflow);
m_private->xrun[1] = false;
}
int32_t result;
@ -1241,7 +1240,7 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleWrite() {
streamTime = getStreamTime();
{
audio::Time startCall = audio::Time::now();
doStopStream = m_callback(nullptr,
doStopStream = m_callback(null,
audio::Time(),
&m_userBuffer[0][0],
streamTime,// + audio::Duration(m_latency[0]*1000000000LL/int64_t(m_sampleRate)),
@ -1251,14 +1250,14 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleWrite() {
audio::Duration timeDelay(0, m_bufferSize*1000000000LL/int64_t(m_sampleRate));
audio::Duration timeProcess = stopCall - startCall;
if (timeDelay <= timeProcess) {
ATA_ERROR("SOFT XRUN ... : (bufferTime) " << timeDelay.count() << " < " << timeProcess.count() << " (process time) ns");
ATA_ERROR("SOFT XRUN ... : (bufferTime) " << timeDelay << " < " << timeProcess << " (process time)");
}
}
if (doStopStream == 2) {
abortStream();
return;
}
std::unique_lock<std::mutex> lck(m_mutex);
ethread::UniqueLock lck(m_mutex);
// Setup parameters and do buffer conversion if necessary.
if (m_doConvertBuffer[0]) {
buffer = m_deviceBuffer;
@ -1325,9 +1324,9 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleMMAPWrite() {
}
int32_t doStopStream = 0;
audio::Time streamTime;
std::vector<enum audio::orchestra::status> status;
etk::Vector<enum audio::orchestra::status> status;
if (m_private->xrun[1] == true) {
status.push_back(audio::orchestra::status::overflow);
status.pushBack(audio::orchestra::status::overflow);
m_private->xrun[1] = false;
}
int32_t result;
@ -1347,7 +1346,7 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleMMAPWrite() {
streamTime = getStreamTime();
{
audio::Time startCall = audio::Time::now();
doStopStream = m_callback(nullptr,
doStopStream = m_callback(null,
audio::Time(),
&m_userBuffer[0][0],
streamTime,// + audio::Duration(m_latency[0]*1000000000LL/int64_t(m_sampleRate)),
@ -1357,7 +1356,7 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleMMAPWrite() {
audio::Duration timeDelay(0, m_bufferSize*1000000000LL/int64_t(m_sampleRate));
audio::Duration timeProcess = stopCall - startCall;
if (timeDelay <= timeProcess) {
ATA_ERROR("SOFT XRUN ... : (bufferTime) " << timeDelay.count() << " < " << timeProcess.count() << " (process time) ns");
ATA_ERROR("SOFT XRUN ... : (bufferTime) " << timeDelay << " < " << timeProcess << " (process time)");
}
}
if (doStopStream == 2) {
@ -1365,7 +1364,7 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleMMAPWrite() {
return;
}
{
std::unique_lock<std::mutex> lck(m_mutex);
ethread::UniqueLock lck(m_mutex);
// Setup parameters and do buffer conversion if necessary.
if (m_doConvertBuffer[0]) {
buffer = m_deviceBuffer;
@ -1397,7 +1396,7 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleMMAPWrite() {
// TODO: Understand why this does not work ...
// Write samples to device in interleaved/non-interleaved format.
if (m_deviceInterleaved[0]) {
const snd_pcm_channel_area_t* myAreas = nullptr;
const snd_pcm_channel_area_t* myAreas = null;
snd_pcm_uframes_t offset, frames;
frames = m_bufferSize;
ATA_DEBUG("START");
@ -1459,9 +1458,9 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleMMAPRead() {
}
int32_t doStopStream = 0;
audio::Time streamTime;
std::vector<enum audio::orchestra::status> status;
etk::Vector<enum audio::orchestra::status> status;
if (m_private->xrun[0] == true) {
status.push_back(audio::orchestra::status::underflow);
status.pushBack(audio::orchestra::status::underflow);
m_private->xrun[0] = false;
}
int32_t result;
@ -1474,7 +1473,7 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleMMAPRead() {
goto unlock;
}
{
std::unique_lock<std::mutex> lck(m_mutex);
ethread::UniqueLock lck(m_mutex);
// Setup parameters.
if (m_doConvertBuffer[1]) {
buffer = m_deviceBuffer;
@ -1521,7 +1520,7 @@ void audio::orchestra::api::Alsa::callbackEventOneCycleMMAPRead() {
}
} else {
ATA_ERROR("audio read error, " << snd_strerror(result) << ".");
std::this_thread::sleep_for(std::chrono::milliseconds(10));
ethread::sleepMilliSeconds((10));
}
// TODO : Notify application ... audio::orchestra::error_warning;
goto noInput;
@ -1549,7 +1548,7 @@ noInput:
audio::Time startCall = audio::Time::now();
doStopStream = m_callback(&m_userBuffer[1][0],
streamTime,// - audio::Duration(m_latency[1]*1000000000LL/int64_t(m_sampleRate)),
nullptr,
null,
audio::Time(),
m_bufferSize,
status);
@ -1557,7 +1556,7 @@ noInput:
audio::Duration timeDelay(0, m_bufferSize*1000000000LL/int64_t(m_sampleRate));
audio::Duration timeProcess = stopCall - startCall;
if (timeDelay <= timeProcess) {
ATA_ERROR("SOFT XRUN ... : (bufferTime) " << timeDelay.count() << " < " << timeProcess.count() << " (process time) ns");
ATA_ERROR("SOFT XRUN ... : (bufferTime) " << timeDelay << " < " << timeProcess << " (process time) ns");
}
}
if (doStopStream == 2) {
@ -1574,7 +1573,7 @@ unlock:
bool audio::orchestra::api::Alsa::isMasterOf(ememory::SharedPtr<audio::orchestra::Api> _api) {
ememory::SharedPtr<audio::orchestra::api::Alsa> slave = ememory::dynamicPointerCast<audio::orchestra::api::Alsa>(_api);
if (slave == nullptr) {
if (slave == null) {
ATA_ERROR("NULL ptr API (not ALSA ...)");
return false;
}
@ -1586,11 +1585,11 @@ bool audio::orchestra::api::Alsa::isMasterOf(ememory::SharedPtr<audio::orchestra
ATA_ERROR("The SLAVE stream is already running! ==> can not synchronize ...");
return false;
}
snd_pcm_t * master = nullptr;
if (m_private->handle != nullptr) {
snd_pcm_t * master = null;
if (m_private->handle != null) {
master = m_private->handle;
}
if (master == nullptr) {
if (master == null) {
ATA_ERROR("No ALSA handles ...");
return false;
}

12
audio/orchestra/api/Alsa.hpp
View File

@ -18,19 +18,19 @@ namespace audio {
public:
Alsa();
virtual ~Alsa();
const std::string& getCurrentApi() {
const etk::String& getCurrentApi() {
return audio::orchestra::typeAlsa;
}
uint32_t getDeviceCount();
private:
bool getNamedDeviceInfoLocal(const std::string& _deviceName,
bool getNamedDeviceInfoLocal(const etk::String& _deviceName,
audio::orchestra::DeviceInfo& _info,
int32_t _cardId=-1, // Alsa card ID
int32_t _subdevice=-1, // alsa subdevice ID
int32_t _localDeviceId=-1,// local ID of device find
bool _input=false);
public:
bool getNamedDeviceInfo(const std::string& _deviceName, audio::orchestra::DeviceInfo& _info) {
bool getNamedDeviceInfo(const etk::String& _deviceName, audio::orchestra::DeviceInfo& _info) {
return getNamedDeviceInfoLocal(_deviceName, _info);
}
audio::orchestra::DeviceInfo getDeviceInfo(uint32_t _device);
@ -47,11 +47,9 @@ namespace audio {
void callbackEventOneCycleWrite();
void callbackEventOneCycleMMAPRead();
void callbackEventOneCycleMMAPWrite();
private:
static void alsaCallbackEvent(void* _userData);
private:
ememory::SharedPtr<AlsaPrivate> m_private;
std::vector<audio::orchestra::DeviceInfo> m_devices;
etk::Vector<audio::orchestra::DeviceInfo> m_devices;
void saveDeviceInfo();
bool open(uint32_t _device,
enum audio::orchestra::mode _mode,
@ -62,7 +60,7 @@ namespace audio {
uint32_t *_bufferSize,
const audio::orchestra::StreamOptions& _options);
bool openName(const std::string& _deviceName,
bool openName(const etk::String& _deviceName,
audio::orchestra::mode _mode,
uint32_t _channels,
uint32_t _firstChannel,

20
audio/orchestra/api/Android.cpp
View File

@ -13,11 +13,13 @@
#include <audio/orchestra/debug.hpp>
#include <audio/orchestra/api/AndroidNativeInterface.hpp>
#include <audio/orchestra/api/Android.hpp>
#include <climits>
extern "C" {
#include <limits.h>
}
ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::Android::create() {
ATA_INFO("Create Android device ... ");
return ememory::SharedPtr<audio::orchestra::api::Android>(new audio::orchestra::api::Android());
return ememory::SharedPtr<audio::orchestra::api::Android>(ETK_NEW(audio::orchestra::api::Android));
}
@ -69,15 +71,15 @@ enum audio::orchestra::error audio::orchestra::api::Android::abortStream() {
void audio::orchestra::api::Android::playback(int16_t* _dst, int32_t _nbChunk) {
// clear output buffer:
if (_dst != nullptr) {
if (_dst != null) {
memset(_dst, 0, _nbChunk*audio::getFormatBytes(m_deviceFormat[modeToIdTable(m_mode)])*m_nDeviceChannels[modeToIdTable(m_mode)]);
}
int32_t doStopStream = 0;
audio::Time streamTime = getStreamTime();
std::vector<enum audio::orchestra::status> status;
etk::Vector<enum audio::orchestra::status> status;
if (m_doConvertBuffer[modeToIdTable(m_mode)] == true) {
ATA_VERBOSE("Need playback data " << int32_t(_nbChunk) << " userbuffer size = " << m_userBuffer[audio::orchestra::mode_output].size() << "pointer=" << int64_t(&m_userBuffer[audio::orchestra::mode_output][0]));
doStopStream = m_callback(nullptr,
doStopStream = m_callback(null,
audio::Time(),
&m_userBuffer[m_mode][0],
streamTime,
@ -86,7 +88,7 @@ void audio::orchestra::api::Android::playback(int16_t* _dst, int32_t _nbChunk) {
convertBuffer((char*)_dst, (char*)&m_userBuffer[audio::orchestra::mode_output][0], m_convertInfo[audio::orchestra::mode_output]);
} else {
ATA_VERBOSE("Need playback data " << int32_t(_nbChunk) << " pointer=" << int64_t(_dst));
doStopStream = m_callback(nullptr,
doStopStream = m_callback(null,
audio::Time(),
_dst,
streamTime,
@ -104,13 +106,13 @@ void audio::orchestra::api::Android::playback(int16_t* _dst, int32_t _nbChunk) {
void audio::orchestra::api::Android::record(int16_t* _dst, int32_t _nbChunk) {
int32_t doStopStream = 0;
audio::Time streamTime = getStreamTime();
std::vector<enum audio::orchestra::status> status;
etk::Vector<enum audio::orchestra::status> status;
if (m_doConvertBuffer[modeToIdTable(m_mode)] == true) {
ATA_VERBOSE("Need playback data " << int32_t(_nbChunk) << " userbuffer size = " << m_userBuffer[audio::orchestra::mode_output].size() << "pointer=" << int64_t(&m_userBuffer[audio::orchestra::mode_output][0]));
convertBuffer((char*)&m_userBuffer[audio::orchestra::mode_input][0], (char*)_dst, m_convertInfo[audio::orchestra::mode_input]);
doStopStream = m_callback(&m_userBuffer[m_mode][0],
streamTime,
nullptr,
null,
audio::Time(),
uint32_t(_nbChunk),
status);
@ -118,7 +120,7 @@ void audio::orchestra::api::Android::record(int16_t* _dst, int32_t _nbChunk) {
ATA_VERBOSE("Need playback data " << int32_t(_nbChunk) << " pointer=" << int64_t(_dst));
doStopStream = m_callback(_dst,
streamTime,
nullptr,
null,
audio::Time(),
uint32_t(_nbChunk),
status);

4
audio/orchestra/api/Android.hpp
View File

@ -18,7 +18,7 @@ namespace audio {
public:
Android();
virtual ~Android();
const std::string& getCurrentApi() {
const etk::String& getCurrentApi() {
return audio::orchestra::typeJava;
}
uint32_t getDeviceCount();
@ -39,7 +39,7 @@ namespace audio {
return m_uid;
}
private:
std::vector<audio::orchestra::DeviceInfo> m_devices;
etk::Vector<audio::orchestra::DeviceInfo> m_devices;
void saveDeviceInfo();
bool open(uint32_t _device,
audio::orchestra::mode _mode,

90
audio/orchestra/api/AndroidNativeInterface.cpp
View File

@ -4,9 +4,11 @@
* @license APACHE v2.0 (see license file)
*/
#include <jni.h>
#include <pthread.h>
#include <mutex>
extern "C" {
#include <jni.h>
#include <pthread.h>
}
#include <ethread/Mutex.hpp>
#include <audio/orchestra/debug.hpp>
#include <audio/orchestra/error.hpp>
#include <audio/orchestra/api/AndroidNativeInterface.hpp>
@ -35,19 +37,19 @@ class AndroidOrchestraContext {
private:
bool safeInitMethodID(jmethodID& _mid, jclass& _cls, const char* _name, const char* _sign) {
_mid = m_JavaVirtualMachinePointer->GetMethodID(_cls, _name, _sign);
if(_mid == nullptr) {
if(_mid == null) {
ATA_ERROR("C->java : Can't find the method " << _name);
/* remove access on the virtual machine : */
m_JavaVirtualMachinePointer = nullptr;
m_JavaVirtualMachinePointer = null;
return false;
}
return true;
}
bool java_attach_current_thread(int *_rstatus) {
ATA_DEBUG("C->java : call java");
if (jvm_basics::getJavaVM() == nullptr) {
if (jvm_basics::getJavaVM() == null) {
ATA_ERROR("C->java : JVM not initialised");
m_JavaVirtualMachinePointer = nullptr;
m_JavaVirtualMachinePointer = null;
return false;
}
*_rstatus = jvm_basics::getJavaVM()->GetEnv((void **) &m_JavaVirtualMachinePointer, JNI_VERSION_1_6);
@ -55,12 +57,12 @@ class AndroidOrchestraContext {
JavaVMAttachArgs lJavaVMAttachArgs;
lJavaVMAttachArgs.version = JNI_VERSION_1_6;
lJavaVMAttachArgs.name = "EwolNativeThread";
lJavaVMAttachArgs.group = nullptr;
lJavaVMAttachArgs.group = null;
int status = jvm_basics::getJavaVM()->AttachCurrentThread(&m_JavaVirtualMachinePointer, &lJavaVMAttachArgs);
jvm_basics::checkExceptionJavaVM(m_JavaVirtualMachinePointer);
if (status != JNI_OK) {
ATA_ERROR("C->java : AttachCurrentThread failed : " << status);
m_JavaVirtualMachinePointer = nullptr;
m_JavaVirtualMachinePointer = null;
return false;
}
}
@ -69,13 +71,13 @@ class AndroidOrchestraContext {
void java_detach_current_thread(int _status) {
if(_status == JNI_EDETACHED) {
jvm_basics::getJavaVM()->DetachCurrentThread();
m_JavaVirtualMachinePointer = nullptr;
m_JavaVirtualMachinePointer = null;
}
}
public:
AndroidOrchestraContext(JNIEnv* _env, jclass _classBase, jobject _objCallback) :
m_JavaVirtualMachinePointer(nullptr),
m_JavaVirtualMachinePointer(null),
m_javaClassOrchestra(0),
m_javaClassOrchestraCallback(0),
m_javaObjectOrchestraCallback(0),
@ -93,7 +95,7 @@ class AndroidOrchestraContext {
ATA_DEBUG("*******************************************");
m_JavaVirtualMachinePointer = _env;
// get default needed all time elements :
if (m_JavaVirtualMachinePointer == nullptr) {
if (m_JavaVirtualMachinePointer == null) {
ATA_ERROR("C->java: NULLPTR jvm interface");
return;
}
@ -102,15 +104,15 @@ class AndroidOrchestraContext {
if (m_javaClassOrchestra == 0) {
ATA_ERROR("C->java : Can't find org/musicdsp/orchestra/OrchestraNative class");
// remove access on the virtual machine :
m_JavaVirtualMachinePointer = nullptr;
m_JavaVirtualMachinePointer = null;
return;
}
/* The object field extends Activity and implement OrchestraCallback */
m_javaClassOrchestraCallback = m_JavaVirtualMachinePointer->GetObjectClass(_objCallback);
if(m_javaClassOrchestraCallback == nullptr) {
if(m_javaClassOrchestraCallback == null) {
ATA_ERROR("C->java : Can't find org/musicdsp/orchestra/OrchestraManagerCallback class");
// remove access on the virtual machine :
m_JavaVirtualMachinePointer = nullptr;
m_JavaVirtualMachinePointer = null;
return;
}
bool functionCallbackIsMissing = false;
@ -183,7 +185,7 @@ class AndroidOrchestraContext {
m_javaObjectOrchestraCallback = _env->NewGlobalRef(_objCallback);
if (m_javaObjectOrchestraCallback == nullptr) {
if (m_javaObjectOrchestraCallback == null) {
functionCallbackIsMissing = true;
}
@ -191,7 +193,7 @@ class AndroidOrchestraContext {
if (m_javaDefaultClassString == 0) {
ATA_ERROR("C->java : Can't find java/lang/String" );
// remove access on the virtual machine :
m_JavaVirtualMachinePointer = nullptr;
m_JavaVirtualMachinePointer = null;
functionCallbackIsMissing = true;
}
if (functionCallbackIsMissing == true) {
@ -205,7 +207,7 @@ class AndroidOrchestraContext {
void unInit(JNIEnv* _env) {
_env->DeleteGlobalRef(m_javaObjectOrchestraCallback);
m_javaObjectOrchestraCallback = nullptr;
m_javaObjectOrchestraCallback = null;
}
uint32_t getDeviceCount() {
@ -234,8 +236,8 @@ class AndroidOrchestraContext {
}
//Call java ...
jstring returnString = (jstring) m_JavaVirtualMachinePointer->CallObjectMethod(m_javaObjectOrchestraCallback, m_javaMethodOrchestraActivityAudioGetDeviceProperty, _idDevice);
const char *js = m_JavaVirtualMachinePointer->GetStringUTFChars(returnString, nullptr);
std::string retString(js);
const char *js = m_JavaVirtualMachinePointer->GetStringUTFChars(returnString, null);
etk::String retString(js);
m_JavaVirtualMachinePointer->ReleaseStringUTFChars(returnString, js);
//m_JavaVirtualMachinePointer->DeleteLocalRef(returnString);
// manage execption :
@ -256,19 +258,19 @@ class AndroidOrchestraContext {
ejson::Array list = doc["sample-rate"].toArray();
if (list.exist() == true) {
for (auto it : list) {
info.sampleRates.push_back(int32_t(it.toNumber().get(48000)));
info.sampleRates.pushBack(int32_t(it.toNumber().get(48000)));
}
}
list = doc["channels"].toArray();
if (list.exist() == true) {
for (auto it : list) {
info.channels.push_back(audio::getChannelFromString(it.toString().get("???")));
info.channels.pushBack(audio::getChannelFromString(it.toString().get("???")));
}
}
list = doc["format"].toArray();
if (list.exist() == true) {
for (auto it : list) {
info.nativeFormats.push_back(audio::getFormatFromString(it.toString().get("???")));
info.nativeFormats.pushBack(audio::getFormatFromString(it.toString().get("???")));
}
}
info.isDefault = doc["default"].toBoolean().get(false);
@ -276,7 +278,7 @@ class AndroidOrchestraContext {
return info;
}
private:
std::vector<ememory::WeakPtr<audio::orchestra::api::Android> > m_instanceList; // list of connected handle ...
etk::Vector<ememory::WeakPtr<audio::orchestra::api::Android> > m_instanceList; // list of connected handle ...
//AndroidAudioCallback m_audioCallBack;
//void* m_audioCallBackUserData;
public:
@ -305,7 +307,7 @@ class AndroidOrchestraContext {
jvm_basics::checkExceptionJavaVM(m_JavaVirtualMachinePointer);
java_detach_current_thread(status);
if (int32_t(ret) >= 0) {
m_instanceList.push_back(_instance);
m_instanceList.pushBack(_instance);
return int32_t(ret);
}
return -1;
@ -369,7 +371,7 @@ class AndroidOrchestraContext {
auto it = m_instanceList.begin();
while (it != m_instanceList.end()) {
auto elem = it->lock();
if (elem == nullptr) {
if (elem == null) {
it = m_instanceList.erase(it);
continue;
}
@ -383,7 +385,7 @@ class AndroidOrchestraContext {
auto it = m_instanceList.begin();
while (it != m_instanceList.end()) {
auto elem = it->lock();
if (elem == nullptr) {
if (elem == null) {
it = m_instanceList.erase(it);
continue;
}
@ -400,7 +402,7 @@ static int32_t s_nbContextRequested(0);
uint32_t audio::orchestra::api::android::getDeviceCount() {
if (s_localContext == nullptr) {
if (s_localContext == null) {
ATA_ERROR("Have no Orchertra API instanciate in JAVA ...");
return 0;
}
@ -408,7 +410,7 @@ uint32_t audio::orchestra::api::android::getDeviceCount() {
}
audio::orchestra::DeviceInfo audio::orchestra::api::android::getDeviceInfo(uint32_t _device) {
if (s_localContext == nullptr) {
if (s_localContext == null) {
return audio::orchestra::DeviceInfo();
}
return s_localContext->getDeviceInfo(_device);
@ -423,35 +425,35 @@ int32_t audio::orchestra::api::android::open(uint32_t _device,
uint32_t *_bufferSize,
const audio::orchestra::StreamOptions& _options,
ememory::SharedPtr<audio::orchestra::api::Android> _instance) {
if (s_localContext == nullptr) {
if (s_localContext == null) {
return -1;
}
return s_localContext->open(_device, _mode, _channels, _firstChannel, _sampleRate, _format, _bufferSize, _options, _instance);
}
enum audio::orchestra::error audio::orchestra::api::android::closeStream(int32_t _id) {
if (s_localContext == nullptr) {
if (s_localContext == null) {
return audio::orchestra::error_fail;
}
return s_localContext->closeStream(_id);
}
enum audio::orchestra::error audio::orchestra::api::android::startStream(int32_t _id) {
if (s_localContext == nullptr) {
if (s_localContext == null) {
return audio::orchestra::error_fail;
}
return s_localContext->startStream(_id);
}
enum audio::orchestra::error audio::orchestra::api::android::stopStream(int32_t _id) {
if (s_localContext == nullptr) {
if (s_localContext == null) {
return audio::orchestra::error_fail;
}
return s_localContext->stopStream(_id);
}
enum audio::orchestra::error audio::orchestra::api::android::abortStream(int32_t _id) {
if (s_localContext == nullptr) {
if (s_localContext == null) {
return audio::orchestra::error_fail;
}
return s_localContext->abortStream(_id);
@ -461,15 +463,15 @@ extern "C" {
void Java_org_musicdsp_orchestra_OrchestraNative_NNsetJavaManager(JNIEnv* _env,
jclass _classBase,
jobject _objCallback) {
std::unique_lock<std::mutex> lock(jvm_basics::getMutexJavaVM());
ethread::UniqueLock lock(jvm_basics::getMutexJavaVM());
ATA_INFO("*******************************************");
ATA_INFO("** Creating Orchestra context **");
ATA_INFO("*******************************************");
if (s_localContext != nullptr) {
if (s_localContext != null) {
s_nbContextRequested++;
}
s_localContext = ememory::makeShared<AndroidOrchestraContext>(_env, _classBase, _objCallback);
if (s_localContext == nullptr) {
if (s_localContext == null) {
ATA_ERROR("Can not allocate the orchestra main context instance");
return;
}
@ -477,7 +479,7 @@ extern "C" {
}
void Java_org_musicdsp_orchestra_OrchestraNative_NNsetJavaManagerRemove(JNIEnv* _env, jclass _cls) {
std::unique_lock<std::mutex> lock(jvm_basics::getMutexJavaVM());
ethread::UniqueLock lock(jvm_basics::getMutexJavaVM());
ATA_INFO("*******************************************");
ATA_INFO("** remove Orchestra Pointer **");
ATA_INFO("*******************************************");
@ -495,15 +497,15 @@ extern "C" {
jint _id,
jshortArray _location,
jint _nbChunk) {
std::unique_lock<std::mutex> lock(jvm_basics::getMutexJavaVM());
if (s_localContext == nullptr) {
ethread::UniqueLock lock(jvm_basics::getMutexJavaVM());
if (s_localContext == null) {
ATA_ERROR("Call audio with no more Low level interface");
return;
}
// get the short* pointer from the Java array
jboolean isCopy;
jshort* dst = _env->GetShortArrayElements(_location, &isCopy);
if (dst != nullptr) {
if (dst != null) {
//ATA_INFO("Need audioData " << int32_t(_nbChunk));
s_localContext->playback(int32_t(_id), static_cast<short*>(dst), int32_t(_nbChunk));
}
@ -518,15 +520,15 @@ extern "C" {
jint _id,
jshortArray _location,
jint _nbChunk) {
std::unique_lock<std::mutex> lock(jvm_basics::getMutexJavaVM());
if (s_localContext == nullptr) {
ethread::UniqueLock lock(jvm_basics::getMutexJavaVM());
if (s_localContext == null) {
ATA_ERROR("Call audio with no more Low level interface");
return;
}
// get the short* pointer from the Java array
jboolean isCopy;
jshort* dst = _env->GetShortArrayElements(_location, &isCopy);
if (dst != nullptr) {
if (dst != null) {
//ATA_INFO("Need audioData " << int32_t(_nbChunk));
s_localContext->record(int32_t(_id), static_cast<short*>(dst), int32_t(_nbChunk));
}

67
audio/orchestra/api/Asio.cpp
View File

@ -12,7 +12,7 @@
#include <audio/orchestra/debug.hpp>
ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::Asio::create() {
return ememory::SharedPtr<audio::orchestra::api::Asio>(new audio::orchestra::api::Asio());
return ememory::SharedPtr<audio::orchestra::api::Asio>(ETK_NEW(audio::orchestra::api::Asio));
}
@ -32,12 +32,13 @@ ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::Asio::create()
// on information found in
// http://www.cs.wustl.edu/~schmidt/win32-cv-1.html.
#include "asiosys.h"
#include "asio.h"
#include "iasiothiscallresolver.h"
#include "asiodrivers.h"
#include <cmath>
extern "C" {
#include "asiosys.h"
#include "asio.h"
#include "iasiothiscallresolver.h"
#include "asiodrivers.h"
#include <math.h>
}
static AsioDrivers drivers;
static ASIOCallbacks asioCallbacks;
static ASIODriverInfo driverInfo;
@ -70,12 +71,12 @@ static void sampleRateChanged(ASIOSampleRate _sRate);
static long asioMessages(long _selector, long _value, void* _message, double* _opt);
audio::orchestra::api::Asio::Asio() :
m_private(new audio::orchestra::api::AsioPrivate()) {
m_private(ETK_NEW(audio::orchestra::api::AsioPrivate)) {
// ASIO cannot run on a multi-threaded appartment. You can call
// CoInitialize beforehand, but it must be for appartment threading
// (in which case, CoInitilialize will return S_FALSE here).
m_coInitialized = false;
HRESULT hr = CoInitialize(nullptr);
HRESULT hr = CoInitialize(null);
if (FAILED(hr)) {
ATA_ERROR("requires a single-threaded appartment. Call CoInitializeEx(0,COINIT_APARTMENTTHREADED)");
}
@ -154,7 +155,7 @@ rtaudio::DeviceInfo audio::orchestra::api::Asio::getDeviceInfo(uint32_t _device)
for (uint32_t i=0; i<MAX_SAMPLE_RATES; i++) {
result = ASIOCanSampleRate((ASIOSampleRate) SAMPLE_RATES[i]);
if (result == ASE_OK) {
info.sampleRates.push_back(SAMPLE_RATES[i]);
info.sampleRates.pushBack(SAMPLE_RATES[i]);
}
}
// Determine supported data types ... just check first channel and assume rest are the same.
@ -173,19 +174,19 @@ rtaudio::DeviceInfo audio::orchestra::api::Asio::getDeviceInfo(uint32_t _device)
info.nativeFormats.clear();
if ( channelInfo.type == ASIOSTInt16MSB
|| channelInfo.type == ASIOSTInt16LSB) {
info.nativeFormats.push_back(audio::format_int16);
info.nativeFormats.pushBack(audio::format_int16);
} else if ( channelInfo.type == ASIOSTInt32MSB
|| channelInfo.type == ASIOSTInt32LSB) {
info.nativeFormats.push_back(audio::format_int32);
info.nativeFormats.pushBack(audio::format_int32);
} else if ( channelInfo.type == ASIOSTFloat32MSB
|| channelInfo.type == ASIOSTFloat32LSB) {
info.nativeFormats.push_back(audio::format_float);
info.nativeFormats.pushBack(audio::format_float);
} else if ( channelInfo.type == ASIOSTFloat64MSB
|| channelInfo.type == ASIOSTFloat64LSB) {
info.nativeFormats.push_back(audio::format_double);
info.nativeFormats.pushBack(audio::format_double);
} else if ( channelInfo.type == ASIOSTInt24MSB
|| channelInfo.type == ASIOSTInt24LSB) {
info.nativeFormats.push_back(audio::format_int24);
info.nativeFormats.pushBack(audio::format_int24);
}
if (info.outputChannels > 0){
if (getDefaultOutputDevice() == _device) {
@ -378,10 +379,10 @@ bool audio::orchestra::api::Asio::open(uint32_t _device,
log2_of_max_size = i;
}
}
long min_delta = std::abs((long)*_bufferSize - ((long)1 << log2_of_min_size));
long min_delta = etk::abs((long)*_bufferSize - ((long)1 << log2_of_min_size));
int32_t min_delta_num = log2_of_min_size;
for (int32_t i = log2_of_min_size + 1; i <= log2_of_max_size; i++) {
long current_delta = std::abs((long)*_bufferSize - ((long)1 << i));
long current_delta = etk::abs((long)*_bufferSize - ((long)1 << i));
if (current_delta < min_delta) {
min_delta = current_delta;
min_delta_num = i;
@ -410,10 +411,10 @@ bool audio::orchestra::api::Asio::open(uint32_t _device,
m_deviceInterleaved[modeToIdTable(_mode)] = false;
m_private->bufferInfos = 0;
// Create a manual-reset event.
m_private->condition = CreateEvent(nullptr, // no security
m_private->condition = CreateEvent(null, // no security
TRUE, // manual-reset
FALSE, // non-signaled initially
nullptr); // unnamed
null); // unnamed
// Create the ASIO internal buffers. Since RtAudio sets up input
// and output separately, we'll have to dispose of previously
// created output buffers for a duplex stream.
@ -421,16 +422,16 @@ bool audio::orchestra::api::Asio::open(uint32_t _device,
if ( _mode == audio::orchestra::mode_input
&& m_mode == audio::orchestra::mode_output) {
ASIODisposeBuffers();
if (m_private->bufferInfos == nullptr) {
if (m_private->bufferInfos == null) {
free(m_private->bufferInfos);
m_private->bufferInfos = nullptr;
m_private->bufferInfos = null;
}
}
// Allocate, initialize, and save the bufferInfos in our stream callbackInfo structure.
bool buffersAllocated = false;
uint32_t i, nChannels = m_nDeviceChannels[0] + m_nDeviceChannels[1];
m_private->bufferInfos = (ASIOBufferInfo *) malloc(nChannels * sizeof(ASIOBufferInfo));
if (m_private->bufferInfos == nullptr) {
if (m_private->bufferInfos == null) {
ATA_ERROR("error allocating bufferInfo memory for driver (" << driverName << ").");
goto error;
}
@ -450,7 +451,7 @@ bool audio::orchestra::api::Asio::open(uint32_t _device,
asioCallbacks.bufferSwitch = &bufferSwitch;
asioCallbacks.sampleRateDidChange = &sampleRateChanged;
asioCallbacks.asioMessage = &asioMessages;
asioCallbacks.bufferSwitchTimeInfo = nullptr;
asioCallbacks.bufferSwitchTimeInfo = null;
result = ASIOCreateBuffers(m_private->bufferInfos, nChannels, m_bufferSize, &asioCallbacks);
if (result != ASE_OK) {
ATA_ERROR("driver (" << driverName << ") error (" << getAsioErrorString(result) << ") creating buffers.");
@ -470,7 +471,7 @@ bool audio::orchestra::api::Asio::open(uint32_t _device,
uint64_t bufferBytes;
bufferBytes = m_nUserChannels[modeToIdTable(_mode)] * *_bufferSize * audio::getFormatBytes(m_userFormat);
m_userBuffer[modeToIdTable(_mode)] = (char *) calloc(bufferBytes, 1);
if (m_userBuffer[modeToIdTable(_mode)] == nullptr) {
if (m_userBuffer[modeToIdTable(_mode)] == null) {
ATA_ERROR("error allocating user buffer memory.");
goto error;
}
@ -489,10 +490,10 @@ bool audio::orchestra::api::Asio::open(uint32_t _device,
bufferBytes *= *_bufferSize;
if (m_deviceBuffer) {
free(m_deviceBuffer);
m_deviceBuffer = nullptr;
m_deviceBuffer = null;
}
m_deviceBuffer = (char *) calloc(bufferBytes, 1);
if (m_deviceBuffer == nullptr) {
if (m_deviceBuffer == null) {
ATA_ERROR("error allocating device buffer memory.");
goto error;
}
@ -529,9 +530,9 @@ error:
}
drivers.removeCurrentDriver();
CloseHandle(m_private->condition);
if (m_private->bufferInfos != nullptr) {
if (m_private->bufferInfos != null) {
free(m_private->bufferInfos);
m_private->bufferInfos = nullptr;
m_private->bufferInfos = null;
}
for (int32_t i=0; i<2; i++) {
if (m_userBuffer[i]) {
@ -679,7 +680,7 @@ bool audio::orchestra::api::Asio::callbackEvent(long bufferIndex) {
SetEvent(m_private->condition);
} else { // spawn a thread to stop the stream
unsigned threadId;
m_callbackInfo.thread = _beginthreadex(nullptr,
m_callbackInfo.thread = _beginthreadex(null,
0,
&asioStopStream,
&m_callbackInfo,
@ -692,13 +693,13 @@ bool audio::orchestra::api::Asio::callbackEvent(long bufferIndex) {
// draining stream.
if (m_private->drainCounter == 0) {
audio::Time streamTime = getStreamTime();
std::vector<enum audio::orchestra::status status;
etk::Vector<enum audio::orchestra::status status;
if (m_mode != audio::orchestra::mode_input && asioXRun == true) {
status.push_back(audio::orchestra::status::underflow);
status.pushBack(audio::orchestra::status::underflow);
asioXRun = false;
}
if (m_mode != audio::orchestra::mode_output && asioXRun == true) {
status.push_back(audio::orchestra::status::underflow;
status.pushBack(audio::orchestra::status::underflow;
asioXRun = false;
}
int32_t cbReturnValue = info->callback(m_userBuffer[1],
@ -711,7 +712,7 @@ bool audio::orchestra::api::Asio::callbackEvent(long bufferIndex) {
m_state = audio::orchestra::state::stopping;
m_private->drainCounter = 2;
unsigned threadId;
m_callbackInfo.thread = _beginthreadex(nullptr,
m_callbackInfo.thread = _beginthreadex(null,
0,
&asioStopStream,
&m_callbackInfo,

4
audio/orchestra/api/Asio.hpp
View File

@ -17,7 +17,7 @@ namespace audio {
public:
Asio();
virtual ~Asio();
const std::string& getCurrentApi() {
const etk::String& getCurrentApi() {
return audio::orchestra::typeAsio;
}
uint32_t getDeviceCount();
@ -34,7 +34,7 @@ namespace audio {
bool callbackEvent(long _bufferIndex);
private:
ememory::SharedPtr<AsioPrivate> m_private;
std::vector<audio::orchestra::DeviceInfo> m_devices;
etk::Vector<audio::orchestra::DeviceInfo> m_devices;
void saveDeviceInfo();
bool m_coInitialized;
bool open(uint32_t _device,

138
audio/orchestra/api/Core.cpp
View File

@ -16,12 +16,12 @@
#include <audio/orchestra/Interface.hpp>
#include <audio/orchestra/debug.hpp>
#include <thread>
#include <ethread/Thread.hpp>
#include <ethread/tools.hpp>
#include <audio/orchestra/api/Core.hpp>
ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::Core::create() {
return ememory::SharedPtr<audio::orchestra::api::Core>(new audio::orchestra::api::Core());
return ememory::SharedPtr<audio::orchestra::api::Core>(ETK_NEW(audio::orchestra::api::Core));
}
namespace audio {
@ -37,7 +37,7 @@ namespace audio {
uint32_t nStreams[2]; // number of streams to use
bool xrun[2];
char *deviceBuffer;
std::condition_variable condition;
ethread::Semaphore m_semaphore;
int32_t drainCounter; // Tracks callback counts when draining
bool internalDrain; // Indicates if stop is initiated from callback or not.
CorePrivate() :
@ -57,13 +57,13 @@ namespace audio {
}
audio::orchestra::api::Core::Core() :
m_private(new audio::orchestra::api::CorePrivate()) {
m_private(ETK_NEW(audio::orchestra::api::CorePrivate)) {
#if defined(AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER)
// This is a largely undocumented but absolutely necessary
// requirement starting with OS-X 10.6. If not called, queries and
// updates to various audio device properties are not handled
// correctly.
CFRunLoopRef theRunLoop = nullptr;
CFRunLoopRef theRunLoop = null;
AudioObjectPropertyAddress property = {
kAudioHardwarePropertyRunLoop,
kAudioObjectPropertyScopeGlobal,
@ -72,7 +72,7 @@ audio::orchestra::api::Core::Core() :
OSStatus result = AudioObjectSetPropertyData(kAudioObjectSystemObject,
&property,
0,
nullptr,
null,
sizeof(CFRunLoopRef),
&theRunLoop);
if (result != noErr) {
@ -98,7 +98,7 @@ uint32_t audio::orchestra::api::Core::getDeviceCount() {
kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMaster
};
OSStatus result = AudioObjectGetPropertyDataSize(kAudioObjectSystemObject, &propertyAddress, 0, nullptr, &dataSize);
OSStatus result = AudioObjectGetPropertyDataSize(kAudioObjectSystemObject, &propertyAddress, 0, null, &dataSize);
if (result != noErr) {
ATA_ERROR("OS-X error getting device info!");
return 0;
@ -121,7 +121,7 @@ uint32_t audio::orchestra::api::Core::getDefaultInputDevice() {
OSStatus result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
&property,
0,
nullptr,
null,
&dataSize,
&id);
if (result != noErr) {
@ -134,7 +134,7 @@ uint32_t audio::orchestra::api::Core::getDefaultInputDevice() {
result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
&property,
0,
nullptr,
null,
&dataSize,
(void*)&deviceList);
if (result != noErr) {
@ -165,7 +165,7 @@ uint32_t audio::orchestra::api::Core::getDefaultOutputDevice() {
OSStatus result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
&property,
0,
nullptr,
null,
&dataSize,
&id);
if (result != noErr) {
@ -178,7 +178,7 @@ uint32_t audio::orchestra::api::Core::getDefaultOutputDevice() {
result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
&property,
0,
nullptr,
null,
&dataSize,
(void*)&deviceList);
if (result != noErr) {
@ -223,7 +223,7 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Core::getDeviceInfo(uint32_t
OSStatus result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
&property,
0,
nullptr,
null,
&dataSize,
(void*)&deviceList);
if (result != noErr) {
@ -239,7 +239,7 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Core::getDeviceInfo(uint32_t
CFStringRef cfname;
dataSize = sizeof(CFStringRef);
property.mSelector = kAudioObjectPropertyManufacturer;
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, &cfname);
result = AudioObjectGetPropertyData(id, &property, 0, null, &dataSize, &cfname);
if (result != noErr) {
ATA_ERROR("system error (" << getErrorCode(result) << ") getting device manufacturer.");
info.clear();
@ -247,14 +247,14 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Core::getDeviceInfo(uint32_t
}
//const char *mname = CFStringGetCStringPtr(cfname, CFStringGetSystemEncoding());
int32_t length = CFStringGetLength(cfname);
std::vector<char> name;
etk::Vector<char> name;
name.resize(length * 3 + 1, '\0');
CFStringGetCString(cfname, &name[0], length * 3 + 1, CFStringGetSystemEncoding());
info.name.append(&name[0], strlen(&name[0]));
info.name.append(": ");
CFRelease(cfname);
property.mSelector = kAudioObjectPropertyName;
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, &cfname);
result = AudioObjectGetPropertyData(id, &property, 0, null, &dataSize, &cfname);
if (result != noErr) {
ATA_ERROR("system error (" << getErrorCode(result) << ") getting device name.");
info.clear();
@ -276,9 +276,9 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Core::getDeviceInfo(uint32_t
} else {
property.mScope = kAudioDevicePropertyScopeInput;
}
AudioBufferList *bufferList = nullptr;
AudioBufferList *bufferList = null;
dataSize = 0;
result = AudioObjectGetPropertyDataSize(id, &property, 0, nullptr, &dataSize);
result = AudioObjectGetPropertyDataSize(id, &property, 0, null, &dataSize);
if (result != noErr || dataSize == 0) {
ATA_ERROR("system error (" << getErrorCode(result) << ") getting stream configuration info for device (" << _device << ").");
info.clear();
@ -286,12 +286,12 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Core::getDeviceInfo(uint32_t
}
// Allocate the AudioBufferList.
bufferList = (AudioBufferList *) malloc(dataSize);
if (bufferList == nullptr) {
if (bufferList == null) {
ATA_ERROR("memory error allocating AudioBufferList.");
info.clear();
return info;
}
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, bufferList);
result = AudioObjectGetPropertyData(id, &property, 0, null, &dataSize, bufferList);
if ( result != noErr
|| dataSize == 0) {
free(bufferList);
@ -302,7 +302,7 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Core::getDeviceInfo(uint32_t
// Get channel information.
for (size_t iii=0; iii<bufferList->mNumberBuffers; ++iii) {
for (size_t jjj=0; jjj<bufferList->mBuffers[iii].mNumberChannels; ++jjj) {
info.channels.push_back(audio::channel_unknow);
info.channels.pushBack(audio::channel_unknow);
}
}
free(bufferList);
@ -316,7 +316,7 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Core::getDeviceInfo(uint32_t
// Determine the supported sample rates.
// ------------------------------------------------
property.mSelector = kAudioDevicePropertyAvailableNominalSampleRates;
result = AudioObjectGetPropertyDataSize(id, &property, 0, nullptr, &dataSize);
result = AudioObjectGetPropertyDataSize(id, &property, 0, null, &dataSize);
if ( result != kAudioHardwareNoError
|| dataSize == 0) {
ATA_ERROR("system error (" << getErrorCode(result) << ") getting sample rate info.");
@ -325,7 +325,7 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Core::getDeviceInfo(uint32_t
}
uint32_t nRanges = dataSize / sizeof(AudioValueRange);
AudioValueRange rangeList[ nRanges ];
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, &rangeList);
result = AudioObjectGetPropertyData(id, &property, 0, null, &dataSize, &rangeList);
if (result != kAudioHardwareNoError) {
ATA_ERROR("system error (" << getErrorCode(result) << ") getting sample rates.");
info.clear();
@ -344,7 +344,7 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Core::getDeviceInfo(uint32_t
for (auto &it : audio::orchestra::genericSampleRate()) {
if ( it >= minimumRate
&& it <= maximumRate) {
info.sampleRates.push_back(it);
info.sampleRates.pushBack(it);
}
}
if (info.sampleRates.size() == 0) {
@ -358,7 +358,7 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Core::getDeviceInfo(uint32_t
// CoreAudio always uses 32-bit floating point data for PCM streams.
// Thus, any other "physical" formats supported by the device are of
// no interest to the client.
info.nativeFormats.push_back(audio::format_float);
info.nativeFormats.pushBack(audio::format_float);
// ------------------------------------------------
// Determine the default channel.
// ------------------------------------------------
@ -386,10 +386,10 @@ OSStatus audio::orchestra::api::Core::callbackEvent(AudioDeviceID _inDevice,
audio::orchestra::api::Core* myClass = reinterpret_cast<audio::orchestra::api::Core*>(_userData);
audio::Time inputTime;
audio::Time outputTime;
if (_inInputTime != nullptr) {
if (_inInputTime != null) {
inputTime = audio::Time(_inInputTime->mHostTime/1000000000LL, _inInputTime->mHostTime%1000000000LL);
}
if (_inOutputTime != nullptr) {
if (_inOutputTime != null) {
outputTime = audio::Time(_inOutputTime->mHostTime/1000000000LL, _inOutputTime->mHostTime%1000000000LL);
}
if (myClass->callbackEvent(_inDevice, _inInputData, inputTime, _outOutputData, outputTime) == false) {
@ -427,7 +427,7 @@ static OSStatus rateListener(AudioObjectID _inDevice,
kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMaster
};
AudioObjectGetPropertyData(_inDevice, &property, 0, nullptr, &dataSize, rate);
AudioObjectGetPropertyData(_inDevice, &property, 0, null, &dataSize, rate);
return kAudioHardwareNoError;
}
@ -461,7 +461,7 @@ bool audio::orchestra::api::Core::open(uint32_t _device,
OSStatus result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
&property,
0,
nullptr,
null,
&dataSize,
(void *) &deviceList);
if (result != noErr) {
@ -481,7 +481,7 @@ bool audio::orchestra::api::Core::open(uint32_t _device,
AudioBufferList *bufferList = nil;
dataSize = 0;
property.mSelector = kAudioDevicePropertyStreamConfiguration;
result = AudioObjectGetPropertyDataSize(id, &property, 0, nullptr, &dataSize);
result = AudioObjectGetPropertyDataSize(id, &property, 0, null, &dataSize);
if ( result != noErr
|| dataSize == 0) {
ATA_ERROR("system error (" << getErrorCode(result) << ") getting stream configuration info for device (" << _device << ").");
@ -489,11 +489,11 @@ bool audio::orchestra::api::Core::open(uint32_t _device,
}
// Allocate the AudioBufferList.
bufferList = (AudioBufferList *) malloc(dataSize);
if (bufferList == nullptr) {
if (bufferList == null) {
ATA_ERROR("memory error allocating AudioBufferList.");
return false;
}
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, bufferList);
result = AudioObjectGetPropertyData(id, &property, 0, null, &dataSize, bufferList);
if ( result != noErr
|| dataSize == 0) {
ATA_ERROR("system error (" << getErrorCode(result) << ") getting stream configuration for device (" << _device << ").");
@ -569,7 +569,7 @@ bool audio::orchestra::api::Core::open(uint32_t _device,
AudioValueRange bufferRange;
dataSize = sizeof(AudioValueRange);
property.mSelector = kAudioDevicePropertyBufferFrameSizeRange;
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, &bufferRange);
result = AudioObjectGetPropertyData(id, &property, 0, null, &dataSize, &bufferRange);
if (result != noErr) {
ATA_ERROR("system error (" << getErrorCode(result) << ") getting buffer size range for device (" << _device << ").");
return false;
@ -587,7 +587,7 @@ bool audio::orchestra::api::Core::open(uint32_t _device,
uint32_t theSize = (uint32_t) *_bufferSize;
dataSize = sizeof(uint32_t);
property.mSelector = kAudioDevicePropertyBufferFrameSize;
result = AudioObjectSetPropertyData(id, &property, 0, nullptr, dataSize, &theSize);
result = AudioObjectSetPropertyData(id, &property, 0, null, dataSize, &theSize);
if (result != noErr) {
ATA_ERROR("system error (" << getErrorCode(result) << ") setting the buffer size for device (" << _device << ").");
return false;
@ -607,7 +607,7 @@ bool audio::orchestra::api::Core::open(uint32_t _device,
double nominalRate;
dataSize = sizeof(double);
property.mSelector = kAudioDevicePropertyNominalSampleRate;
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, &nominalRate);
result = AudioObjectGetPropertyData(id, &property, 0, null, &dataSize, &nominalRate);
if (result != noErr) {
ATA_ERROR("system error (" << getErrorCode(result) << ") getting current sample rate.");
return false;
@ -623,7 +623,7 @@ bool audio::orchestra::api::Core::open(uint32_t _device,
return false;
}
nominalRate = (double) _sampleRate;
result = AudioObjectSetPropertyData(id, &property, 0, nullptr, dataSize, &nominalRate);
result = AudioObjectSetPropertyData(id, &property, 0, null, dataSize, &nominalRate);
if (result != noErr) {
ATA_ERROR("system error (" << getErrorCode(result) << ") setting sample rate for device (" << _device << ").");
return false;
@ -635,7 +635,7 @@ bool audio::orchestra::api::Core::open(uint32_t _device,
if (microCounter > 5000000) {
break;
}
std::this_thread::sleep_for(std::chrono::milliseconds(5));
ethread::sleepMilliSeconds((5));
}
// Remove the property listener.
AudioObjectRemovePropertyListener(id, &tmp, &rateListener, (void *) &reportedRate);
@ -649,7 +649,7 @@ bool audio::orchestra::api::Core::open(uint32_t _device,
AudioStreamBasicDescription description;
dataSize = sizeof(AudioStreamBasicDescription);
property.mSelector = kAudioStreamPropertyVirtualFormat;
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, &description);
result = AudioObjectGetPropertyData(id, &property, 0, null, &dataSize, &description);
if (result != noErr) {
ATA_ERROR("system error (" << getErrorCode(result) << ") getting stream format for device (" << _device << ").");
return false;
@ -667,7 +667,7 @@ bool audio::orchestra::api::Core::open(uint32_t _device,
updateFormat = true;
}
if (updateFormat) {
result = AudioObjectSetPropertyData(id, &property, 0, nullptr, dataSize, &description);
result = AudioObjectSetPropertyData(id, &property, 0, null, dataSize, &description);
if (result != noErr) {
ATA_ERROR("system error (" << getErrorCode(result) << ") setting sample rate or data format for device (" << _device << ").");
return false;
@ -675,16 +675,16 @@ bool audio::orchestra::api::Core::open(uint32_t _device,
}
// Now check the physical format.
property.mSelector = kAudioStreamPropertyPhysicalFormat;
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, &description);
result = AudioObjectGetPropertyData(id, &property, 0, null, &dataSize, &description);
if (result != noErr) {
ATA_ERROR("system error (" << getErrorCode(result) << ") getting stream physical format for device (" << _device << ").");
return false;
}
//std::cout << "Current physical stream format:" << std::endl;
//std::cout << " mBitsPerChan = " << description.mBitsPerChannel << std::endl;
//std::cout << " aligned high = " << (description.mFormatFlags & kAudioFormatFlagIsAlignedHigh) << ", isPacked = " << (description.mFormatFlags & kAudioFormatFlagIsPacked) << std::endl;
//std::cout << " bytesPerFrame = " << description.mBytesPerFrame << std::endl;
//std::cout << " sample rate = " << description.mSampleRate << std::endl;
//ATA_DEBUG("Current physical stream format:");
//ATA_DEBUG(" mBitsPerChan = " << description.mBitsPerChannel);
//ATA_DEBUG(" aligned high = " << (description.mFormatFlags & kAudioFormatFlagIsAlignedHigh) << ", isPacked = " << (description.mFormatFlags & kAudioFormatFlagIsPacked));
//ATA_DEBUG(" bytesPerFrame = " << description.mBytesPerFrame);
//ATA_DEBUG(" sample rate = " << description.mSampleRate);
if ( description.mFormatID != kAudioFormatLinearPCM
|| description.mBitsPerChannel < 16) {
description.mFormatID = kAudioFormatLinearPCM;
@ -692,19 +692,19 @@ bool audio::orchestra::api::Core::open(uint32_t _device,
AudioStreamBasicDescription testDescription = description;
uint32_t formatFlags;
// We'll try higher bit rates first and then work our way down.
std::vector< std::pair<uint32_t, uint32_t> > physicalFormats;
etk::Vector< etk::Pair<uint32_t, uint32_t> > physicalFormats;
formatFlags = (description.mFormatFlags | kLinearPCMFormatFlagIsFloat) & ~kLinearPCMFormatFlagIsSignedInteger;
physicalFormats.push_back(std::pair<float, uint32_t>(32, formatFlags));
physicalFormats.pushBack(etk::Pair<float, uint32_t>(32, formatFlags));
formatFlags = (description.mFormatFlags | kLinearPCMFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked) & ~kLinearPCMFormatFlagIsFloat;
physicalFormats.push_back(std::pair<float, uint32_t>(32, formatFlags));
physicalFormats.push_back(std::pair<float, uint32_t>(24, formatFlags)); // 24-bit packed
physicalFormats.pushBack(etk::Pair<float, uint32_t>(32, formatFlags));
physicalFormats.pushBack(etk::Pair<float, uint32_t>(24, formatFlags)); // 24-bit packed
formatFlags &= ~(kAudioFormatFlagIsPacked | kAudioFormatFlagIsAlignedHigh);
physicalFormats.push_back(std::pair<float, uint32_t>(24.2, formatFlags)); // 24-bit in 4 bytes, aligned low
physicalFormats.pushBack(etk::Pair<float, uint32_t>(24.2, formatFlags)); // 24-bit in 4 bytes, aligned low
formatFlags |= kAudioFormatFlagIsAlignedHigh;
physicalFormats.push_back(std::pair<float, uint32_t>(24.4, formatFlags)); // 24-bit in 4 bytes, aligned high
physicalFormats.pushBack(etk::Pair<float, uint32_t>(24.4, formatFlags)); // 24-bit in 4 bytes, aligned high
formatFlags = (description.mFormatFlags | kLinearPCMFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked) & ~kLinearPCMFormatFlagIsFloat;
physicalFormats.push_back(std::pair<float, uint32_t>(16, formatFlags));
physicalFormats.push_back(std::pair<float, uint32_t>(8, formatFlags));
physicalFormats.pushBack(etk::Pair<float, uint32_t>(16, formatFlags));
physicalFormats.pushBack(etk::Pair<float, uint32_t>(8, formatFlags));
bool setPhysicalFormat = false;
for(uint32_t i=0; i<physicalFormats.size(); i++) {
testDescription = description;
@ -717,14 +717,14 @@ bool audio::orchestra::api::Core::open(uint32_t _device,
testDescription.mBytesPerFrame = testDescription.mBitsPerChannel/8 * testDescription.mChannelsPerFrame;
}
testDescription.mBytesPerPacket = testDescription.mBytesPerFrame * testDescription.mFramesPerPacket;
result = AudioObjectSetPropertyData(id, &property, 0, nullptr, dataSize, &testDescription);
result = AudioObjectSetPropertyData(id, &property, 0, null, dataSize, &testDescription);
if (result == noErr) {
setPhysicalFormat = true;
//std::cout << "Updated physical stream format:" << std::endl;
//std::cout << " mBitsPerChan = " << testDescription.mBitsPerChannel << std::endl;
//std::cout << " aligned high = " << (testDescription.mFormatFlags & kAudioFormatFlagIsAlignedHigh) << ", isPacked = " << (testDescription.mFormatFlags & kAudioFormatFlagIsPacked) << std::endl;
//std::cout << " bytesPerFrame = " << testDescription.mBytesPerFrame << std::endl;
//std::cout << " sample rate = " << testDescription.mSampleRate << std::endl;
//ATA_DEBUG("Updated physical stream format:");
//ATA_DEBUG(" mBitsPerChan = " << testDescription.mBitsPerChannel);
//ATA_DEBUG(" aligned high = " << (testDescription.mFormatFlags & kAudioFormatFlagIsAlignedHigh) << ", isPacked = " << (testDescription.mFormatFlags & kAudioFormatFlagIsPacked));
//ATA_DEBUG(" bytesPerFrame = " << testDescription.mBytesPerFrame);
//ATA_DEBUG(" sample rate = " << testDescription.mSampleRate);
break;
}
}
@ -738,7 +738,7 @@ bool audio::orchestra::api::Core::open(uint32_t _device,
dataSize = sizeof(uint32_t);
property.mSelector = kAudioDevicePropertyLatency;
if (AudioObjectHasProperty(id, &property) == true) {
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, &latency);
result = AudioObjectGetPropertyData(id, &property, 0, null, &dataSize, &latency);
if (result == kAudioHardwareNoError) {
m_latency[ _mode ] = latency;
} else {
@ -814,10 +814,10 @@ bool audio::orchestra::api::Core::open(uint32_t _device,
bufferBytes *= *_bufferSize;
if (m_deviceBuffer) {
free(m_deviceBuffer);
m_deviceBuffer = nullptr;
m_deviceBuffer = null;
}
m_deviceBuffer = (char *) calloc(bufferBytes, 1);
if (m_deviceBuffer == nullptr) {
if (m_deviceBuffer == null) {
ATA_ERROR("error allocating device buffer memory.");
goto error;
}
@ -908,7 +908,7 @@ enum audio::orchestra::error audio::orchestra::api::Core::closeStream() {
m_userBuffer[1].clear();
if (m_deviceBuffer) {
free(m_deviceBuffer);
m_deviceBuffer = nullptr;
m_deviceBuffer = null;
}
m_mode = audio::orchestra::mode_unknow;
m_state = audio::orchestra::state::closed;
@ -967,9 +967,9 @@ enum audio::orchestra::error audio::orchestra::api::Core::stopStream() {
if ( m_mode == audio::orchestra::mode_output
|| m_mode == audio::orchestra::mode_duplex) {
if (m_private->drainCounter == 0) {
std::unique_lock<std::mutex> lck(m_mutex);
ethread::UniqueLock lck(m_mutex);
m_private->drainCounter = 2;
m_private->condition.wait(lck);
m_private->m_semaphore.wait();
}
result = AudioDeviceStop(m_private->id[0], &audio::orchestra::api::Core::callbackEvent);
if (result != noErr) {
@ -1036,10 +1036,10 @@ bool audio::orchestra::api::Core::callbackEvent(AudioDeviceID _deviceId,
m_state = audio::orchestra::state::stopping;
ATA_VERBOSE("Set state as stopping");
if (m_private->internalDrain == true) {
new std::thread(&audio::orchestra::api::Core::coreStopStream, this);
ETK_NEW(ethread::Thread, &audio::orchestra::api::Core::coreStopStream, this);
} else {
// external call to stopStream()
m_private->condition.notify_one();
m_private->m_semaphore.post();
}
return true;
}
@ -1048,15 +1048,15 @@ bool audio::orchestra::api::Core::callbackEvent(AudioDeviceID _deviceId,
// draining stream or duplex mode AND the input/output devices are
// different AND this function is called for the input device.
if (m_private->drainCounter == 0 && (m_mode != audio::orchestra::mode_duplex || _deviceId == outputDevice)) {
std::vector<enum audio::orchestra::status> status;
etk::Vector<enum audio::orchestra::status> status;
if ( m_mode != audio::orchestra::mode_input
&& m_private->xrun[0] == true) {
status.push_back(audio::orchestra::status::underflow);
status.pushBack(audio::orchestra::status::underflow);
m_private->xrun[0] = false;
}
if ( m_mode != audio::orchestra::mode_output
&& m_private->xrun[1] == true) {
status.push_back(audio::orchestra::status::overflow);
status.pushBack(audio::orchestra::status::overflow);
m_private->xrun[1] = false;
}
int32_t cbReturnValue = m_callback(&m_userBuffer[1][0],

2
audio/orchestra/api/Core.hpp
View File

@ -20,7 +20,7 @@ namespace audio {
public:
Core();
virtual ~Core();
const std::string& getCurrentApi() {
const etk::String& getCurrentApi() {
return audio::orchestra::typeCoreOSX;
}
uint32_t getDeviceCount();

4
audio/orchestra/api/CoreIos.hpp
View File

@ -17,7 +17,7 @@ namespace audio {
public:
CoreIos();
virtual ~CoreIos();
const std::string& getCurrentApi() {
const etk::String& getCurrentApi() {
return audio::orchestra::typeCoreIOS;
}
uint32_t getDeviceCount();
@ -32,7 +32,7 @@ namespace audio {
// will most likely produce highly undesireable results!
void callbackEvent();
private:
std::vector<audio::orchestra::DeviceInfo> m_devices;
etk::Vector<audio::orchestra::DeviceInfo> m_devices;
void saveDeviceInfo();
bool open(uint32_t _device,
audio::orchestra::mode _mode,

24
audio/orchestra/api/CoreIos.mm
View File

@ -13,12 +13,14 @@
#include <audio/orchestra/Interface.hpp>
#include <audio/orchestra/debug.hpp>
#include <climits>
extern "C" {
#include <limits.h>
}
#include <audio/orchestra/api/CoreIos.hpp>
ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::CoreIos::create() {
ATA_INFO("Create CoreIos device ... ");
return ememory::SharedPtr<audio::orchestra::api::CoreIos>(new audio::orchestra::api::CoreIos());
return ememory::SharedPtr<audio::orchestra::api::CoreIos>(ETK_NEW(audio::orchestra::api::CoreIos));
}
#define kOutputBus 0
@ -38,7 +40,7 @@ namespace audio {
audio::orchestra::api::CoreIos::CoreIos() :
m_private(new audio::orchestra::api::CoreIosPrivate()) {
m_private(ETK_NEW(audio::orchestra::api::CoreIosPrivate)) {
ATA_INFO("new CoreIos");
int32_t deviceCount = 2;
ATA_ERROR("Get count devices : " << 2);
@ -132,12 +134,12 @@ void audio::orchestra::api::CoreIos::callBackEvent(void* _data,
int32_t _nbChunk,
const audio::Time& _time) {
int32_t doStopStream = 0;
std::vector<enum audio::orchestra::status> status;
etk::Vector<enum audio::orchestra::status> status;
if ( m_mode == audio::orchestra::mode_output
|| m_mode == audio::orchestra::mode_duplex) {
if (m_doConvertBuffer[modeToIdTable(audio::orchestra::mode_output)] == true) {
ATA_INFO("get output DATA : " << uint64_t(&m_userBuffer[modeToIdTable(audio::orchestra::mode_output)][0]));
doStopStream = m_callback(nullptr,
doStopStream = m_callback(null,
audio::Time(),
&m_userBuffer[modeToIdTable(audio::orchestra::mode_output)][0],
_time,
@ -146,7 +148,7 @@ void audio::orchestra::api::CoreIos::callBackEvent(void* _data,
convertBuffer((char*)_data, &m_userBuffer[modeToIdTable(audio::orchestra::mode_output)][0], m_convertInfo[modeToIdTable(audio::orchestra::mode_output)]);
} else {
ATA_INFO("have output DATA : " << uint64_t(_data));
doStopStream = m_callback(nullptr,
doStopStream = m_callback(null,
_time,
_data,
audio::Time(),
@ -159,7 +161,7 @@ void audio::orchestra::api::CoreIos::callBackEvent(void* _data,
ATA_INFO("have input DATA : " << uint64_t(_data));
doStopStream = m_callback(_data,
_time,
nullptr,
null,
audio::Time(),
_nbChunk,
status);
@ -178,12 +180,12 @@ static OSStatus playbackCallback(void *_userData,
uint32_t _inBusNumber,
uint32_t _inNumberFrames,
AudioBufferList* _ioData) {
if (_userData == nullptr) {
ATA_ERROR("callback event ... nullptr pointer");
if (_userData == null) {
ATA_ERROR("callback event ... null pointer");
return -1;
}
audio::Time tmpTimeime;
if (_inTime != nullptr) {
if (_inTime != null) {
tmpTimeime = audio::Time(_inTime->mHostTime/1000000000LL, _inTime->mHostTime%1000000000LL);
}
audio::orchestra::api::CoreIos* myClass = static_cast<audio::orchestra::api::CoreIos*>(_userData);
@ -265,7 +267,7 @@ bool audio::orchestra::api::CoreIos::open(uint32_t _device,
desc.componentManufacturer = kAudioUnitManufacturer_Apple;
// Get component
AudioComponent inputComponent = AudioComponentFindNext(nullptr, &desc);
AudioComponent inputComponent = AudioComponentFindNext(null, &desc);
// Get audio units
status = AudioComponentInstanceNew(inputComponent, &m_private->audioUnit);

171
audio/orchestra/api/Ds.cpp
View File

@ -13,7 +13,7 @@
#include <audio/orchestra/api/Ds.hpp>
ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::Ds::create() {
return ememory::SharedPtr<audio::orchestra::api::Ds>(new audio::orchestra::api::Ds());
return ememory::SharedPtr<audio::orchestra::api::Ds>(ETK_NEW(audio::orchestra::api::Ds));
}
@ -23,11 +23,10 @@ ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::Ds::create() {
// - Auto-call CoInitialize for DSOUND and ASIO platforms.
// Various revisions for RtAudio 4.0 by Gary Scavone, April 2007
// Changed device query structure for RtAudio 4.0.7, January 2010
#include <dsound.h>
#include <cassert>
#include <algorithm>
extern "C" {
#include <dsound.h>
#include <assert.h>
}
#if defined(__MINGW32__)
// missing from latest mingw winapi
#define WAVE_FORMAT_96M08 0x00010000 /* 96 kHz, Mono, 8-bit */
@ -59,7 +58,7 @@ class DsDevice {
public:
LPGUID id;
bool input;
std::string name;
etk::String name;
DsDevice() :
id(0),
input(false) {
@ -72,7 +71,7 @@ namespace audio {
namespace api {
class DsPrivate {
public:
ememory::SharedPtr<std::thread> thread;
ememory::SharedPtr<ethread::Thread> thread;
bool threadRunning;
uint32_t drainCounter; // Tracks callback counts when draining
bool internalDrain; // Indicates if stop is initiated from callback or not.
@ -83,7 +82,7 @@ namespace audio {
DWORD dsBufferSize[2];
DWORD dsPointerLeadTime[2]; // the number of bytes ahead of the safe pointer to lead by.
HANDLE condition;
std::vector<DsDevice> dsDevices;
etk::Vector<DsDevice> dsDevices;
DsPrivate() :
threadRunning(false),
drainCounter(0),
@ -107,15 +106,15 @@ static const char* getErrorString(int32_t _code);
struct DsProbeData {
bool isInput;
std::vector<DsDevice>* dsDevices;
etk::Vector<DsDevice>* dsDevices;
};
audio::orchestra::api::Ds::Ds() :
m_private(new audio::orchestra::api::DsPrivate()) {
m_private(ETK_NEW(audio::orchestra::api::DsPrivate)) {
// Dsound will run both-threaded. If CoInitialize fails, then just
// accept whatever the mainline chose for a threading model.
m_coInitialized = false;
HRESULT hr = CoInitialize(nullptr);
HRESULT hr = CoInitialize(null);
if (!FAILED(hr)) {
m_coInitialized = true;
}
@ -132,13 +131,13 @@ audio::orchestra::api::Ds::~Ds() {
#include "tchar.h"
static std::string convertTChar(LPCTSTR _name) {
static etk::String convertTChar(LPCTSTR _name) {
#if defined(UNICODE) || defined(_UNICODE)
int32_t length = WideCharToMultiByte(CP_UTF8, 0, _name, -1, nullptr, 0, nullptr, nullptr);
std::string s(length-1, '\0');
WideCharToMultiByte(CP_UTF8, 0, _name, -1, &s[0], length, nullptr, nullptr);
int32_t length = WideCharToMultiByte(CP_UTF8, 0, _name, -1, null, 0, null, null);
etk::String s(length-1, '\0');
WideCharToMultiByte(CP_UTF8, 0, _name, -1, &s[0], length, null, null);
#else
std::string s(_name);
etk::String s(_name);
#endif
return s;
}
@ -148,13 +147,13 @@ static BOOL CALLBACK deviceQueryCallback(LPGUID _lpguid,
LPCTSTR _module,
LPVOID _lpContext) {
struct DsProbeData& probeInfo = *(struct DsProbeData*) _lpContext;
std::vector<DsDevice>& dsDevices = *probeInfo.dsDevices;
etk::Vector<DsDevice>& dsDevices = *probeInfo.dsDevices;
HRESULT hr;
bool validDevice = false;
if (probeInfo.isInput == true) {
DSCCAPS caps;
LPDIRECTSOUNDCAPTURE object;
hr = DirectSoundCaptureCreate(_lpguid, &object, nullptr);
hr = DirectSoundCaptureCreate(_lpguid, &object, null);
if (hr != DS_OK) {
return TRUE;
}
@ -169,7 +168,7 @@ static BOOL CALLBACK deviceQueryCallback(LPGUID _lpguid,
} else {
DSCAPS caps;
LPDIRECTSOUND object;
hr = DirectSoundCreate(_lpguid, &object, nullptr);
hr = DirectSoundCreate(_lpguid, &object, null);
if (hr != DS_OK) {
return TRUE;
}
@ -187,16 +186,16 @@ static BOOL CALLBACK deviceQueryCallback(LPGUID _lpguid,
return TRUE;
}
// If good device, then save its name and guid.
std::string name = convertTChar(_description);
etk::String name = convertTChar(_description);
//if (name == "Primary Sound Driver" || name == "Primary Sound Capture Driver")
if (_lpguid == nullptr) {
if (_lpguid == null) {
name = "Default Device";
}
DsDevice device;
device.name = name;
device.input = probeInfo.isInput;
device.id = _lpguid;
dsDevices.push_back(device);
dsDevices.pushBack(device);
return TRUE;
}
@ -234,7 +233,7 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Ds::getDeviceInfo(uint32_t _
info.input = true;
LPDIRECTSOUND output;
DSCAPS outCaps;
result = DirectSoundCreate(m_private->dsDevices[_device].id, &output, nullptr);
result = DirectSoundCreate(m_private->dsDevices[_device].id, &output, null);
if (FAILED(result)) {
ATA_ERROR(getErrorString(result) << ": opening output device (" << m_private->dsDevices[_device].name << ")!");
info.clear();
@ -250,24 +249,24 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Ds::getDeviceInfo(uint32_t _
}
// Get output channel information.
if (outCaps.dwFlags & DSCAPS_PRIMARYSTEREO) {
info.channels.push_back(audio::channel_unknow);
info.channels.push_back(audio::channel_unknow);
info.channels.pushBack(audio::channel_unknow);
info.channels.pushBack(audio::channel_unknow);
} else {
info.channels.push_back(audio::channel_unknow);
info.channels.pushBack(audio::channel_unknow);
}
// Get sample rate information.
for (auto &it : audio::orchestra::genericSampleRate()) {
if ( it >= outCaps.dwMinSecondarySampleRate
&& it <= outCaps.dwMaxSecondarySampleRate) {
info.sampleRates.push_back(it);
info.sampleRates.pushBack(it);
}
}
// Get format information.
if (outCaps.dwFlags & DSCAPS_PRIMARY16BIT) {
info.nativeFormats.push_back(audio::format_int16);
info.nativeFormats.pushBack(audio::format_int16);
}
if (outCaps.dwFlags & DSCAPS_PRIMARY8BIT) {
info.nativeFormats.push_back(audio::format_int8);
info.nativeFormats.pushBack(audio::format_int8);
}
output->Release();
info.name = m_private->dsDevices[_device].name;
@ -275,7 +274,7 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Ds::getDeviceInfo(uint32_t _
return info;
} else {
LPDIRECTSOUNDCAPTURE input;
result = DirectSoundCaptureCreate(m_private->dsDevices[_device].id, &input, nullptr);
result = DirectSoundCaptureCreate(m_private->dsDevices[_device].id, &input, null);
if (FAILED(result)) {
ATA_ERROR(getErrorString(result) << ": opening input device (" << m_private->dsDevices[_device].name << ")!");
info.clear();
@ -292,67 +291,67 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Ds::getDeviceInfo(uint32_t _
}
// Get input channel information.
for (int32_t iii=0; iii<inCaps.dwChannels; ++iii) {
info.channels.push_back(audio::channel_unknow);
info.channels.pushBack(audio::channel_unknow);
}
// Get sample rate and format information.
std::vector<uint32_t> rates;
etk::Vector<uint32_t> rates;
if (inCaps.dwChannels >= 2) {
if ( (inCaps.dwFormats & WAVE_FORMAT_1S16)
|| (inCaps.dwFormats & WAVE_FORMAT_2S16)
|| (inCaps.dwFormats & WAVE_FORMAT_4S16)
|| (inCaps.dwFormats & WAVE_FORMAT_96S16) ) {
info.nativeFormats.push_back(audio::format_int16);
info.nativeFormats.pushBack(audio::format_int16);
}
if ( (inCaps.dwFormats & WAVE_FORMAT_1S08)
|| (inCaps.dwFormats & WAVE_FORMAT_2S08)
|| (inCaps.dwFormats & WAVE_FORMAT_4S08)
|| (inCaps.dwFormats & WAVE_FORMAT_96S08) ) {
info.nativeFormats.push_back(audio::format_int8);
info.nativeFormats.pushBack(audio::format_int8);
}
if ( (inCaps.dwFormats & WAVE_FORMAT_1S16)
|| (inCaps.dwFormats & WAVE_FORMAT_1S08) ){
rates.push_back(11025);
rates.pushBack(11025);
}
if ( (inCaps.dwFormats & WAVE_FORMAT_2S16)
|| (inCaps.dwFormats & WAVE_FORMAT_2S08) ){
rates.push_back(22050);
rates.pushBack(22050);
}
if ( (inCaps.dwFormats & WAVE_FORMAT_4S16)
|| (inCaps.dwFormats & WAVE_FORMAT_4S08) ){
rates.push_back(44100);
rates.pushBack(44100);
}
if ( (inCaps.dwFormats & WAVE_FORMAT_96S16)
|| (inCaps.dwFormats & WAVE_FORMAT_96S08) ){
rates.push_back(96000);
rates.pushBack(96000);
}
} else if (inCaps.dwChannels == 1) {
if ( (inCaps.dwFormats & WAVE_FORMAT_1M16)
|| (inCaps.dwFormats & WAVE_FORMAT_2M16)
|| (inCaps.dwFormats & WAVE_FORMAT_4M16)
|| (inCaps.dwFormats & WAVE_FORMAT_96M16) ) {
info.nativeFormats.push_back(audio::format_int16);
info.nativeFormats.pushBack(audio::format_int16);
}
if ( (inCaps.dwFormats & WAVE_FORMAT_1M08)
|| (inCaps.dwFormats & WAVE_FORMAT_2M08)
|| (inCaps.dwFormats & WAVE_FORMAT_4M08)
|| (inCaps.dwFormats & WAVE_FORMAT_96M08) ) {
info.nativeFormats.push_back(audio::format_int8);
info.nativeFormats.pushBack(audio::format_int8);
}
if ( (inCaps.dwFormats & WAVE_FORMAT_1M16)
|| (inCaps.dwFormats & WAVE_FORMAT_1M08) ){
rates.push_back(11025);
rates.pushBack(11025);
}
if ( (inCaps.dwFormats & WAVE_FORMAT_2M16)
|| (inCaps.dwFormats & WAVE_FORMAT_2M08) ){
rates.push_back(22050);
rates.pushBack(22050);
}
if ( (inCaps.dwFormats & WAVE_FORMAT_4M16)
|| (inCaps.dwFormats & WAVE_FORMAT_4M08) ){
rates.push_back(44100);
rates.pushBack(44100);
}
if ( (inCaps.dwFormats & WAVE_FORMAT_96M16)
|| (inCaps.dwFormats & WAVE_FORMAT_96M08) ){
rates.push_back(96000);
rates.pushBack(96000);
}
} else {
// technically, this would be an error
@ -374,10 +373,10 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Ds::getDeviceInfo(uint32_t _
}
}
if (found == false) {
info.sampleRates.push_back(rates[i]);
info.sampleRates.pushBack(rates[i]);
}
}
std::sort(info.sampleRates.begin(), info.sampleRates.end());
info.sampleRates.sort(0, info.sampleRates.size(), [](const uint32_t& _left, const uint32_t& _right) { return _left < _right;});
// Copy name and return.
info.name = m_private->dsDevices[_device].name;
info.isCorrect = true;
@ -453,7 +452,7 @@ bool audio::orchestra::api::Ds::open(uint32_t _device,
HRESULT result;
if (_mode == audio::orchestra::mode_output) {
LPDIRECTSOUND output;
result = DirectSoundCreate(m_private->dsDevices[_device].id, &output, nullptr);
result = DirectSoundCreate(m_private->dsDevices[_device].id, &output, null);
if (FAILED(result)) {
ATA_ERROR(getErrorString(result) << ": opening output device (" << m_private->dsDevices[_device].name << ")!");
return false;
@ -510,7 +509,7 @@ bool audio::orchestra::api::Ds::open(uint32_t _device,
bufferDescription.dwFlags = DSBCAPS_PRIMARYBUFFER;
// Obtain the primary buffer
LPDIRECTSOUNDBUFFER buffer;
result = output->CreateSoundBuffer(&bufferDescription, &buffer, nullptr);
result = output->CreateSoundBuffer(&bufferDescription, &buffer, null);
if (FAILED(result)) {
output->Release();
ATA_ERROR(getErrorString(result) << ": accessing primary buffer (" << m_private->dsDevices[_device].name << ")!");
@ -534,13 +533,13 @@ bool audio::orchestra::api::Ds::open(uint32_t _device,
bufferDescription.lpwfxFormat = &waveFormat;
// Try to create the secondary DS buffer. If that doesn't work,
// try to use software mixing. Otherwise, there's a problem.
result = output->CreateSoundBuffer(&bufferDescription, &buffer, nullptr);
result = output->CreateSoundBuffer(&bufferDescription, &buffer, null);
if (FAILED(result)) {
bufferDescription.dwFlags = ( DSBCAPS_STICKYFOCUS
| DSBCAPS_GLOBALFOCUS
| DSBCAPS_GETCURRENTPOSITION2
| DSBCAPS_LOCSOFTWARE); // Force software mixing
result = output->CreateSoundBuffer(&bufferDescription, &buffer, nullptr);
result = output->CreateSoundBuffer(&bufferDescription, &buffer, null);
if (FAILED(result)) {
output->Release();
ATA_ERROR(getErrorString(result) << ": creating secondary buffer (" << m_private->dsDevices[_device].name << ")!");
@ -561,7 +560,7 @@ bool audio::orchestra::api::Ds::open(uint32_t _device,
// Lock the DS buffer
LPVOID audioPtr;
DWORD dataLen;
result = buffer->Lock(0, dsBufferSize, &audioPtr, &dataLen, nullptr, nullptr, 0);
result = buffer->Lock(0, dsBufferSize, &audioPtr, &dataLen, null, null, 0);
if (FAILED(result)) {
output->Release();
buffer->Release();
@ -571,7 +570,7 @@ bool audio::orchestra::api::Ds::open(uint32_t _device,
// Zero the DS buffer
ZeroMemory(audioPtr, dataLen);
// Unlock the DS buffer
result = buffer->Unlock(audioPtr, dataLen, nullptr, 0);
result = buffer->Unlock(audioPtr, dataLen, null, 0);
if (FAILED(result)) {
output->Release();
buffer->Release();
@ -583,7 +582,7 @@ bool audio::orchestra::api::Ds::open(uint32_t _device,
}
if (_mode == audio::orchestra::mode_input) {
LPDIRECTSOUNDCAPTURE input;
result = DirectSoundCaptureCreate(m_private->dsDevices[_device].id, &input, nullptr);
result = DirectSoundCaptureCreate(m_private->dsDevices[_device].id, &input, null);
if (FAILED(result)) {
ATA_ERROR(getErrorString(result) << ": opening input device (" << m_private->dsDevices[_device].name << ")!");
return false;
@ -643,7 +642,7 @@ bool audio::orchestra::api::Ds::open(uint32_t _device,
bufferDescription.lpwfxFormat = &waveFormat;
// Create the capture buffer.
LPDIRECTSOUNDCAPTUREBUFFER buffer;
result = input->CreateCaptureBuffer(&bufferDescription, &buffer, nullptr);
result = input->CreateCaptureBuffer(&bufferDescription, &buffer, null);
if (FAILED(result)) {
input->Release();
ATA_ERROR(getErrorString(result) << ": creating input buffer (" << m_private->dsDevices[_device].name << ")!");
@ -667,7 +666,7 @@ bool audio::orchestra::api::Ds::open(uint32_t _device,
// Lock the capture buffer
LPVOID audioPtr;
DWORD dataLen;
result = buffer->Lock(0, dsBufferSize, &audioPtr, &dataLen, nullptr, nullptr, 0);
result = buffer->Lock(0, dsBufferSize, &audioPtr, &dataLen, null, null, 0);
if (FAILED(result)) {
input->Release();
buffer->Release();
@ -677,7 +676,7 @@ bool audio::orchestra::api::Ds::open(uint32_t _device,
// Zero the buffer
ZeroMemory(audioPtr, dataLen);
// Unlock the buffer
result = buffer->Unlock(audioPtr, dataLen, nullptr, 0);
result = buffer->Unlock(audioPtr, dataLen, null, 0);
if (FAILED(result)) {
input->Release();
buffer->Release();
@ -729,17 +728,17 @@ bool audio::orchestra::api::Ds::open(uint32_t _device,
free(m_deviceBuffer);
}
m_deviceBuffer = (char *) calloc(bufferBytes, 1);
if (m_deviceBuffer == nullptr) {
if (m_deviceBuffer == null) {
ATA_ERROR("error allocating device buffer memory.");
goto error;
}
}
}
// Create a manual-reset event.
m_private->condition = CreateEvent(nullptr, // no security
m_private->condition = CreateEvent(null, // no security
TRUE, // manual-reset
FALSE, // non-signaled initially
nullptr); // unnamed
null); // unnamed
m_private->id[modeToIdTable(_mode)] = ohandle;
m_private->buffer[modeToIdTable(_mode)] = bhandle;
m_private->dsBufferSize[modeToIdTable(_mode)] = dsBufferSize;
@ -762,9 +761,9 @@ bool audio::orchestra::api::Ds::open(uint32_t _device,
// Setup the callback thread.
if (m_private->threadRunning == false) {
m_private->threadRunning = true;
ememory::SharedPtr<std::thread> tmpThread(new std::thread(&audio::orchestra::api::Ds::dsCallbackEvent, this));
m_private->thread = std::move(tmpThread);
if (m_private->thread == nullptr) {
ememory::SharedPtr<ethread::Thread> tmpThread(ETK_NEW(ethread::Thread, [=](){audio::orchestra::api::Ds::dsCallbackEvent();});
m_private->thread = etk::move(tmpThread);
if (m_private->thread == null) {
ATA_ERROR("error creating callback thread!");
goto error;
}
@ -774,7 +773,7 @@ bool audio::orchestra::api::Ds::open(uint32_t _device,
return true;
error:
if (m_private->buffer[0]) {
// the object pointer can be nullptr and valid
// the object pointer can be null and valid
LPDIRECTSOUND object = (LPDIRECTSOUND) m_private->id[0];
LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) m_private->buffer[0];
if (buffer) {
@ -785,7 +784,7 @@ error:
if (m_private->buffer[1]) {
LPDIRECTSOUNDCAPTURE object = (LPDIRECTSOUNDCAPTURE) m_private->id[1];
LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) m_private->buffer[1];
if (buffer != nullptr) {
if (buffer != null) {
buffer->Release();
}
}
@ -808,11 +807,11 @@ enum audio::orchestra::error audio::orchestra::api::Ds::closeStream() {
}
// Stop the callback thread.
m_private->threadRunning = false;
if (m_private->thread != nullptr) {
if (m_private->thread != null) {
m_private->thread->join();
m_private->thread = nullptr;
m_private->thread = null;
}
if (m_private->buffer[0]) { // the object pointer can be nullptr and valid
if (m_private->buffer[0]) { // the object pointer can be null and valid
LPDIRECTSOUND object = (LPDIRECTSOUND) m_private->id[0];
LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) m_private->buffer[0];
if (buffer) {
@ -919,7 +918,7 @@ enum audio::orchestra::error audio::orchestra::api::Ds::stopStream() {
}
// Lock the buffer and clear it so that if we start to play again,
// we won't have old data playing.
result = buffer->Lock(0, m_private->dsBufferSize[0], &audioPtr, &dataLen, nullptr, nullptr, 0);
result = buffer->Lock(0, m_private->dsBufferSize[0], &audioPtr, &dataLen, null, null, 0);
if (FAILED(result)) {
ATA_ERROR(getErrorString(result) << ": locking output buffer!");
goto unlock;
@ -927,7 +926,7 @@ enum audio::orchestra::error audio::orchestra::api::Ds::stopStream() {
// Zero the DS buffer
ZeroMemory(audioPtr, dataLen);
// Unlock the DS buffer
result = buffer->Unlock(audioPtr, dataLen, nullptr, 0);
result = buffer->Unlock(audioPtr, dataLen, null, 0);
if (FAILED(result)) {
ATA_ERROR(getErrorString(result) << ": unlocking output buffer!");
goto unlock;
@ -938,7 +937,7 @@ enum audio::orchestra::error audio::orchestra::api::Ds::stopStream() {
if ( m_mode == audio::orchestra::mode_input
|| m_mode == audio::orchestra::mode_duplex) {
LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) m_private->buffer[1];
audioPtr = nullptr;
audioPtr = null;
dataLen = 0;
m_state = audio::orchestra::state::stopped;
result = buffer->Stop();
@ -948,7 +947,7 @@ enum audio::orchestra::error audio::orchestra::api::Ds::stopStream() {
}
// Lock the buffer and clear it so that if we start to play again,
// we won't have old data playing.
result = buffer->Lock(0, m_private->dsBufferSize[1], &audioPtr, &dataLen, nullptr, nullptr, 0);
result = buffer->Lock(0, m_private->dsBufferSize[1], &audioPtr, &dataLen, null, null, 0);
if (FAILED(result)) {
ATA_ERROR(getErrorString(result) << ": locking input buffer!");
goto unlock;
@ -956,7 +955,7 @@ enum audio::orchestra::error audio::orchestra::api::Ds::stopStream() {
// Zero the DS buffer
ZeroMemory(audioPtr, dataLen);
// Unlock the DS buffer
result = buffer->Unlock(audioPtr, dataLen, nullptr, 0);
result = buffer->Unlock(audioPtr, dataLen, null, 0);
if (FAILED(result)) {
ATA_ERROR(getErrorString(result) << ": unlocking input buffer!");
goto unlock;
@ -1009,15 +1008,15 @@ void audio::orchestra::api::Ds::callbackEvent() {
// draining stream.
if (m_private->drainCounter == 0) {
audio::Time streamTime = getStreamTime();
std::vector<audio::orchestra::status> status;
etk::Vector<audio::orchestra::status> status;
if ( m_mode != audio::orchestra::mode_input
&& m_private->xrun[0] == true) {
status.push_back(audio::orchestra::status::underflow);
status.pushBack(audio::orchestra::status::underflow);
m_private->xrun[0] = false;
}
if ( m_mode != audio::orchestra::mode_output
&& m_private->xrun[1] == true) {
status.push_back(audio::orchestra::status::overflow);
status.pushBack(audio::orchestra::status::overflow);
m_private->xrun[1] = false;
}
int32_t cbReturnValue = m_callback(&m_userBuffer[1][0],
@ -1040,8 +1039,8 @@ void audio::orchestra::api::Ds::callbackEvent() {
DWORD currentWritePointer, safeWritePointer;
DWORD currentReadPointer, safeReadPointer;
UINT nextWritePointer;
LPVOID buffer1 = nullptr;
LPVOID buffer2 = nullptr;
LPVOID buffer1 = null;
LPVOID buffer2 = null;
DWORD bufferSize1 = 0;
DWORD bufferSize2 = 0;
char *buffer;
@ -1064,23 +1063,23 @@ void audio::orchestra::api::Ds::callbackEvent() {
LPDIRECTSOUNDBUFFER dsWriteBuffer = (LPDIRECTSOUNDBUFFER) m_private->buffer[0];
LPDIRECTSOUNDCAPTUREBUFFER dsCaptureBuffer = (LPDIRECTSOUNDCAPTUREBUFFER) m_private->buffer[1];
DWORD startSafeWritePointer, startSafeReadPointer;
result = dsWriteBuffer->GetCurrentPosition(nullptr, &startSafeWritePointer);
result = dsWriteBuffer->GetCurrentPosition(null, &startSafeWritePointer);
if (FAILED(result)) {
ATA_ERROR(getErrorString(result) << ": getting current write position!");
return;
}
result = dsCaptureBuffer->GetCurrentPosition(nullptr, &startSafeReadPointer);
result = dsCaptureBuffer->GetCurrentPosition(null, &startSafeReadPointer);
if (FAILED(result)) {
ATA_ERROR(getErrorString(result) << ": getting current read position!");
return;
}
while (true) {
result = dsWriteBuffer->GetCurrentPosition(nullptr, &safeWritePointer);
result = dsWriteBuffer->GetCurrentPosition(null, &safeWritePointer);
if (FAILED(result)) {
ATA_ERROR(getErrorString(result) << ": getting current write position!");
return;
}
result = dsCaptureBuffer->GetCurrentPosition(nullptr, &safeReadPointer);
result = dsCaptureBuffer->GetCurrentPosition(null, &safeReadPointer);
if (FAILED(result)) {
ATA_ERROR(getErrorString(result) << ": getting current read position!");
return;
@ -1154,7 +1153,7 @@ void audio::orchestra::api::Ds::callbackEvent() {
// safeWritePointer and leadPointer. If leadPointer is not
// beyond the next endWrite position, wait until it is.
leadPointer = safeWritePointer + m_private->dsPointerLeadTime[0];
//std::cout << "safeWritePointer = " << safeWritePointer << ", leadPointer = " << leadPointer << ", nextWritePointer = " << nextWritePointer << std::endl;
//ATA_DEBUG("safeWritePointer = " << safeWritePointer << ", leadPointer = " << leadPointer << ", nextWritePointer = " << nextWritePointer);
if (leadPointer > dsBufferSize) {
leadPointer -= dsBufferSize;
}
@ -1201,7 +1200,7 @@ void audio::orchestra::api::Ds::callbackEvent() {
}
// Copy our buffer into the DS buffer
CopyMemory(buffer1, buffer, bufferSize1);
if (buffer2 != nullptr) {
if (buffer2 != null) {
CopyMemory(buffer2, buffer+bufferSize1, bufferSize2);
}
// Update our buffer offset and unlock sound buffer
@ -1319,12 +1318,12 @@ void audio::orchestra::api::Ds::callbackEvent() {
if (m_duplexPrerollBytes <= 0) {
// Copy our buffer into the DS buffer
CopyMemory(buffer, buffer1, bufferSize1);
if (buffer2 != nullptr) {
if (buffer2 != null) {
CopyMemory(buffer+bufferSize1, buffer2, bufferSize2);
}
} else {
memset(buffer, 0, bufferSize1);
if (buffer2 != nullptr) {
if (buffer2 != null) {
memset(buffer + bufferSize1, 0, bufferSize2);
}
m_duplexPrerollBytes -= bufferSize1 + bufferSize2;

2
audio/orchestra/api/Ds.hpp
View File

@ -17,7 +17,7 @@ namespace audio {
public:
Ds();
virtual ~Ds();
const std::string& getCurrentApi() {
const etk::String& getCurrentApi() {
return audio::orchestra::typeDs;
}
uint32_t getDeviceCount();

2
audio/orchestra/api/Dummy.cpp
View File

@ -10,7 +10,7 @@
#include <audio/orchestra/debug.hpp>
ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::Dummy::create() {
return ememory::SharedPtr<audio::orchestra::api::Dummy>(new audio::orchestra::api::Dummy());
return ememory::SharedPtr<audio::orchestra::api::Dummy>(ETK_NEW(audio::orchestra::api::Dummy));
}

2
audio/orchestra/api/Dummy.hpp
View File

@ -18,7 +18,7 @@ namespace audio {
static ememory::SharedPtr<audio::orchestra::Api> create();
public:
Dummy();
const std::string& getCurrentApi() {
const etk::String& getCurrentApi() {
return audio::orchestra::typeDummy;
}
uint32_t getDeviceCount();

146
audio/orchestra/api/Jack.cpp
View File

@ -7,17 +7,17 @@
// must run before :
#if defined(ORCHESTRA_BUILD_JACK)
#include <climits>
#include <iostream>
extern "C" {
#include <limits.h>
#include <string.h>
}
#include <audio/orchestra/Interface.hpp>
#include <audio/orchestra/debug.hpp>
#include <cstring>
#include <ethread/tools.hpp>
#include <audio/orchestra/api/Jack.hpp>
ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::Jack::create() {
return ememory::SharedPtr<audio::orchestra::api::Jack>(new audio::orchestra::api::Jack());
return ememory::SharedPtr<audio::orchestra::api::Jack>(ETK_NEW(audio::orchestra::api::Jack));
}
@ -52,9 +52,9 @@ ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::Jack::create()
// stream cannot be opened.
#include <jack/jack.h>
#include <cstdio>
extern "C" {
#include <stdio.h>
}
namespace audio {
namespace orchestra {
@ -63,9 +63,9 @@ namespace audio {
public:
jack_client_t *client;
jack_port_t **ports[2];
std::string deviceName[2];
etk::String deviceName[2];
bool xrun[2];
std::condition_variable condition;
ethread::Semaphore m_semaphore;
int32_t drainCounter; // Tracks callback counts when draining
bool internalDrain; // Indicates if stop is initiated from callback or not.
@ -84,7 +84,7 @@ namespace audio {
}
audio::orchestra::api::Jack::Jack() :
m_private(new audio::orchestra::api::JackPrivate()) {
m_private(ETK_NEW(audio::orchestra::api::JackPrivate)) {
// Nothing to do here.
}
@ -97,23 +97,23 @@ audio::orchestra::api::Jack::~Jack() {
uint32_t audio::orchestra::api::Jack::getDeviceCount() {
// See if we can become a jack client.
jack_options_t options = (jack_options_t) (JackNoStartServer); //JackNullOption;
jack_status_t *status = nullptr;
jack_status_t *status = null;
jack_client_t *client = jack_client_open("orchestraJackCount", options, status);
if (client == nullptr) {
if (client == null) {
return 0;
}
const char **ports;
std::string port, previousPort;
etk::String port, previousPort;
uint32_t nChannels = 0, nDevices = 0;
ports = jack_get_ports(client, nullptr, nullptr, 0);
ports = jack_get_ports(client, null, null, 0);
if (ports) {
// Parse the port names up to the first colon (:).
size_t iColon = 0;
do {
port = (char *) ports[ nChannels ];
iColon = port.find(":");
if (iColon != std::string::npos) {
port = port.substr(0, iColon + 1);
if (iColon != etk::String::npos) {
port = port.extract(0, iColon + 1);
if (port != previousPort) {
nDevices++;
previousPort = port;
@ -121,6 +121,7 @@ uint32_t audio::orchestra::api::Jack::getDeviceCount() {
}
} while (ports[++nChannels]);
free(ports);
ports = null;
}
jack_client_close(client);
return nDevices*2;
@ -129,18 +130,18 @@ uint32_t audio::orchestra::api::Jack::getDeviceCount() {
audio::orchestra::DeviceInfo audio::orchestra::api::Jack::getDeviceInfo(uint32_t _device) {
audio::orchestra::DeviceInfo info;
jack_options_t options = (jack_options_t) (JackNoStartServer); //JackNullOption
jack_status_t *status = nullptr;
jack_status_t *status = null;
jack_client_t *client = jack_client_open("orchestraJackInfo", options, status);
if (client == nullptr) {
if (client == null) {
ATA_ERROR("Jack server not found or connection error!");
// TODO : audio::orchestra::error_warning;
info.clear();
return info;
}
const char **ports;
std::string port, previousPort;
etk::String port, previousPort;
uint32_t nPorts = 0, nDevices = 0;
ports = jack_get_ports(client, nullptr, nullptr, 0);
ports = jack_get_ports(client, null, null, 0);
int32_t deviceID = _device/2;
info.input = _device%2==0?true:false; // note that jack sens are inverted
if (ports) {
@ -149,8 +150,8 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Jack::getDeviceInfo(uint32_t
do {
port = (char *) ports[nPorts];
iColon = port.find(":");
if (iColon != std::string::npos) {
port = port.substr(0, iColon);
if (iColon != etk::String::npos) {
port = port.extract(0, iColon);
if (port != previousPort) {
if (nDevices == deviceID) {
info.name = port;
@ -170,25 +171,25 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Jack::getDeviceInfo(uint32_t
}
// Get the current jack server sample rate.
info.sampleRates.clear();
info.sampleRates.push_back(jack_get_sample_rate(client));
info.sampleRates.pushBack(jack_get_sample_rate(client));
if (info.input == true) {
ports = jack_get_ports(client, info.name.c_str(), nullptr, JackPortIsOutput);
ports = jack_get_ports(client, info.name.c_str(), null, JackPortIsOutput);
if (ports) {
int32_t iii=0;
while (ports[iii]) {
ATA_ERROR(" ploppp='" << ports[iii] << "'");
info.channels.push_back(audio::channel_unknow);
info.channels.pushBack(audio::channel_unknow);
iii++;
}
free(ports);
}
} else {
ports = jack_get_ports(client, info.name.c_str(), nullptr, JackPortIsInput);
ports = jack_get_ports(client, info.name.c_str(), null, JackPortIsInput);
if (ports) {
int32_t iii=0;
while (ports[iii]) {
ATA_ERROR(" ploppp='" << ports[iii] << "'");
info.channels.push_back(audio::channel_unknow);
info.channels.pushBack(audio::channel_unknow);
iii++;
}
free(ports);
@ -202,7 +203,7 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Jack::getDeviceInfo(uint32_t
return info;
}
// Jack always uses 32-bit floats.
info.nativeFormats.push_back(audio::format_float);
info.nativeFormats.pushBack(audio::format_float);
// Jack doesn't provide default devices so we'll use the first available one.
if (deviceID == 0) {
info.isDefault = true;
@ -223,15 +224,6 @@ int32_t audio::orchestra::api::Jack::jackCallbackHandler(jack_nframes_t _nframes
return 0;
}
// This function will be called by a spawned thread when the Jack
// server signals that it is shutting down. It is necessary to handle
// it this way because the jackShutdown() function must return before
// the jack_deactivate() function (in closeStream()) will return.
void audio::orchestra::api::Jack::jackCloseStream(void* _userData) {
ethread::setName("Jack_closeStream");
audio::orchestra::api::Jack* myClass = reinterpret_cast<audio::orchestra::api::Jack*>(_userData);
myClass->closeStream();
}
void audio::orchestra::api::Jack::jackShutdown(void* _userData) {
audio::orchestra::api::Jack* myClass = reinterpret_cast<audio::orchestra::api::Jack*>(_userData);
@ -243,7 +235,7 @@ void audio::orchestra::api::Jack::jackShutdown(void* _userData) {
if (myClass->isStreamRunning() == false) {
return;
}
new std::thread(&audio::orchestra::api::Jack::jackCloseStream, _userData);
ETK_NEW(ethread::Thread, [=](){myClass->closeStream();});
ATA_ERROR("The Jack server is shutting down this client ... stream stopped and closed!!");
}
@ -272,8 +264,8 @@ bool audio::orchestra::api::Jack::open(uint32_t _device,
|| ( _mode == audio::orchestra::mode_input
&& m_mode != audio::orchestra::mode_output)) {
jack_options_t jackoptions = (jack_options_t) (JackNoStartServer); //JackNullOption;
jack_status_t *status = nullptr;
if (!_options.streamName.empty()) {
jack_status_t *status = null;
if (_options.streamName.size() != 0) {
client = jack_client_open(_options.streamName.c_str(), jackoptions, status);
} else {
client = jack_client_open("orchestraJack", jackoptions, status);
@ -287,19 +279,19 @@ bool audio::orchestra::api::Jack::open(uint32_t _device,
client = m_private->client;
}
const char **ports;
std::string port, previousPort, deviceName;
etk::String port, previousPort, deviceName;
uint32_t nPorts = 0, nDevices = 0;
int32_t deviceID = _device/2;
bool isInput = _device%2==0?true:false;
ports = jack_get_ports(client, nullptr, nullptr, 0);
ports = jack_get_ports(client, null, null, 0);
if (ports) {
// Parse the port names up to the first colon (:).
size_t iColon = 0;
do {
port = (char *) ports[ nPorts ];
iColon = port.find(":");
if (iColon != std::string::npos) {
port = port.substr(0, iColon);
if (iColon != etk::String::npos) {
port = port.extract(0, iColon);
if (port != previousPort) {
if (nDevices == deviceID) {
deviceName = port;
@ -322,7 +314,7 @@ bool audio::orchestra::api::Jack::open(uint32_t _device,
if (_mode == audio::orchestra::mode_input) {
flag = JackPortIsOutput;
}
ports = jack_get_ports(client, deviceName.c_str(), nullptr, flag);
ports = jack_get_ports(client, deviceName.c_str(), null, flag);
if (ports) {
while (ports[ nChannels ]) {
nChannels++;
@ -343,7 +335,7 @@ bool audio::orchestra::api::Jack::open(uint32_t _device,
}
m_sampleRate = jackRate;
// Get the latency of the JACK port.
ports = jack_get_ports(client, deviceName.c_str(), nullptr, flag);
ports = jack_get_ports(client, deviceName.c_str(), null, flag);
if (ports[ _firstChannel ]) {
// Added by Ge Wang
jack_latency_callback_mode_t cbmode = (_mode == audio::orchestra::mode_input ? JackCaptureLatency : JackPlaybackLatency);
@ -409,7 +401,7 @@ bool audio::orchestra::api::Jack::open(uint32_t _device,
bufferBytes *= *_bufferSize;
if (m_deviceBuffer) free(m_deviceBuffer);
m_deviceBuffer = (char *) calloc(bufferBytes, 1);
if (m_deviceBuffer == nullptr) {
if (m_deviceBuffer == null) {
ATA_ERROR("error allocating device buffer memory.");
goto error;
}
@ -417,7 +409,7 @@ bool audio::orchestra::api::Jack::open(uint32_t _device,
}
// Allocate memory for the Jack ports (channels) identifiers.
m_private->ports[modeToIdTable(_mode)] = (jack_port_t **) malloc (sizeof (jack_port_t *) * _channels);
if (m_private->ports[modeToIdTable(_mode)] == nullptr) {
if (m_private->ports[modeToIdTable(_mode)] == null) {
ATA_ERROR("error allocating port memory.");
goto error;
}
@ -464,20 +456,20 @@ bool audio::orchestra::api::Jack::open(uint32_t _device,
return true;
error:
jack_client_close(m_private->client);
if (m_private->ports[0] != nullptr) {
if (m_private->ports[0] != null) {
free(m_private->ports[0]);
m_private->ports[0] = nullptr;
m_private->ports[0] = null;
}
if (m_private->ports[1] != nullptr) {
if (m_private->ports[1] != null) {
free(m_private->ports[1]);
m_private->ports[1] = nullptr;
m_private->ports[1] = null;
}
for (int32_t iii=0; iii<2; ++iii) {
m_userBuffer[iii].clear();
}
if (m_deviceBuffer) {
free(m_deviceBuffer);
m_deviceBuffer = nullptr;
m_deviceBuffer = null;
}
return false;
}
@ -487,26 +479,26 @@ enum audio::orchestra::error audio::orchestra::api::Jack::closeStream() {
ATA_ERROR("no open stream to close!");
return audio::orchestra::error_warning;
}
if (m_private != nullptr) {
if (m_private != null) {
if (m_state == audio::orchestra::state::running) {
jack_deactivate(m_private->client);
}
jack_client_close(m_private->client);
}
if (m_private->ports[0] != nullptr) {
if (m_private->ports[0] != null) {
free(m_private->ports[0]);
m_private->ports[0] = nullptr;
m_private->ports[0] = null;
}
if (m_private->ports[1] != nullptr) {
if (m_private->ports[1] != null) {
free(m_private->ports[1]);
m_private->ports[1] = nullptr;
m_private->ports[1] = null;
}
for (int32_t i=0; i<2; i++) {
m_userBuffer[i].clear();
}
if (m_deviceBuffer) {
free(m_deviceBuffer);
m_deviceBuffer = nullptr;
m_deviceBuffer = null;
}
m_mode = audio::orchestra::mode_unknow;
m_state = audio::orchestra::state::closed;
@ -533,8 +525,8 @@ enum audio::orchestra::error audio::orchestra::api::Jack::startStream() {
if ( m_mode == audio::orchestra::mode_output
|| m_mode == audio::orchestra::mode_duplex) {
result = 1;
ports = jack_get_ports(m_private->client, m_private->deviceName[0].c_str(), nullptr, JackPortIsInput);
if (ports == nullptr) {
ports = jack_get_ports(m_private->client, m_private->deviceName[0].c_str(), null, JackPortIsInput);
if (ports == null) {
ATA_ERROR("error determining available JACK input ports!");
goto unlock;
}
@ -556,8 +548,8 @@ enum audio::orchestra::error audio::orchestra::api::Jack::startStream() {
if ( m_mode == audio::orchestra::mode_input
|| m_mode == audio::orchestra::mode_duplex) {
result = 1;
ports = jack_get_ports(m_private->client, m_private->deviceName[1].c_str(), nullptr, JackPortIsOutput);
if (ports == nullptr) {
ports = jack_get_ports(m_private->client, m_private->deviceName[1].c_str(), null, JackPortIsOutput);
if (ports == null) {
ATA_ERROR("error determining available JACK output ports!");
goto unlock;
}
@ -597,8 +589,7 @@ enum audio::orchestra::error audio::orchestra::api::Jack::stopStream() {
|| m_mode == audio::orchestra::mode_duplex) {
if (m_private->drainCounter == 0) {
m_private->drainCounter = 2;
std::unique_lock<std::mutex> lck(m_mutex);
m_private->condition.wait(lck);
m_private->m_semaphore.wait();
}
}
jack_deactivate(m_private->client);
@ -618,17 +609,6 @@ enum audio::orchestra::error audio::orchestra::api::Jack::abortStream() {
return stopStream();
}
// This function will be called by a spawned thread when the user
// callback function signals that the stream should be stopped or
// aborted. It is necessary to handle it this way because the
// callbackEvent() function must return before the jack_deactivate()
// function will return.
static void jackStopStream(void* _userData) {
ethread::setName("Jack_stopStream");
audio::orchestra::api::Jack* myClass = reinterpret_cast<audio::orchestra::api::Jack*>(_userData);
myClass->stopStream();
}
bool audio::orchestra::api::Jack::callbackEvent(uint64_t _nframes) {
if ( m_state == audio::orchestra::state::stopped
|| m_state == audio::orchestra::state::stopping) {
@ -646,22 +626,22 @@ bool audio::orchestra::api::Jack::callbackEvent(uint64_t _nframes) {
if (m_private->drainCounter > 3) {
m_state = audio::orchestra::state::stopping;
if (m_private->internalDrain == true) {
new std::thread(jackStopStream, this);
ETK_NEW(ethread::Thread, [&](){stopStream();}, "Jack_stopStream");
} else {
m_private->condition.notify_one();
m_private->m_semaphore.post();
}
return true;
}
// Invoke user callback first, to get fresh output data.
if (m_private->drainCounter == 0) {
audio::Time streamTime = getStreamTime();
std::vector<enum audio::orchestra::status> status;
etk::Vector<enum audio::orchestra::status> status;
if (m_mode != audio::orchestra::mode_input && m_private->xrun[0] == true) {
status.push_back(audio::orchestra::status::underflow);
status.pushBack(audio::orchestra::status::underflow);
m_private->xrun[0] = false;
}
if (m_mode != audio::orchestra::mode_output && m_private->xrun[1] == true) {
status.push_back(audio::orchestra::status::overflow);
status.pushBack(audio::orchestra::status::overflow);
m_private->xrun[1] = false;
}
int32_t cbReturnValue = m_callback(&m_userBuffer[1][0],
@ -673,7 +653,7 @@ bool audio::orchestra::api::Jack::callbackEvent(uint64_t _nframes) {
if (cbReturnValue == 2) {
m_state = audio::orchestra::state::stopping;
m_private->drainCounter = 2;
new std::thread(jackStopStream, this);
ETK_NEW(ethread::Thread, [&](){stopStream();}, "Jack_stopStream2");
return true;
}
else if (cbReturnValue == 1) {

3
audio/orchestra/api/Jack.hpp
View File

@ -19,7 +19,7 @@ namespace audio {
public:
Jack();
virtual ~Jack();
const std::string& getCurrentApi() {
const etk::String& getCurrentApi() {
return audio::orchestra::typeJack;
}
uint32_t getDeviceCount();
@ -36,7 +36,6 @@ namespace audio {
bool callbackEvent(uint64_t _nframes);
private:
static int32_t jackXrun(void* _userData);
static void jackCloseStream(void* _userData);
static void jackShutdown(void* _userData);
static int32_t jackCallbackHandler(jack_nframes_t _nframes, void* _userData);
private:

79
audio/orchestra/api/Pulse.cpp
View File

@ -8,19 +8,20 @@
#if defined(ORCHESTRA_BUILD_PULSE)
#include <climits>
extern "C" {
#include <limits.h>
#include <stdio.h>
}
#include <audio/orchestra/Interface.hpp>
#include <audio/orchestra/debug.hpp>
#include <pulse/error.h>
#include <pulse/simple.h>
#include <cstdio>
#include <ethread/tools.hpp>
#include <audio/orchestra/api/PulseDeviceList.hpp>
#include <audio/orchestra/api/Pulse.hpp>
ememory::SharedPtr<audio::orchestra::Api> audio::orchestra::api::Pulse::create() {
return ememory::SharedPtr<audio::orchestra::api::Pulse>(new audio::orchestra::api::Pulse());
return ememory::SharedPtr<audio::orchestra::api::Pulse>(ETK_NEW(audio::orchestra::api::Pulse));
}
@ -53,9 +54,9 @@ namespace audio {
class PulsePrivate {
public:
pa_simple* handle;
ememory::SharedPtr<std::thread> thread;
ememory::SharedPtr<ethread::Thread> thread;
bool threadRunning;
std::condition_variable runnable_cv;
ethread::Semaphore m_semaphore;
bool runnable;
PulsePrivate() :
handle(0),
@ -68,7 +69,7 @@ namespace audio {
}
}
audio::orchestra::api::Pulse::Pulse() :
m_private(new audio::orchestra::api::PulsePrivate()) {
m_private(ETK_NEW(audio::orchestra::api::PulsePrivate)) {
}
@ -80,7 +81,7 @@ audio::orchestra::api::Pulse::~Pulse() {
uint32_t audio::orchestra::api::Pulse::getDeviceCount() {
#if 1
std::vector<audio::orchestra::DeviceInfo> list = audio::orchestra::api::pulse::getDeviceList();
etk::Vector<audio::orchestra::DeviceInfo> list = audio::orchestra::api::pulse::getDeviceList();
return list.size();
#else
return 1;
@ -88,7 +89,7 @@ uint32_t audio::orchestra::api::Pulse::getDeviceCount() {
}
audio::orchestra::DeviceInfo audio::orchestra::api::Pulse::getDeviceInfo(uint32_t _device) {
std::vector<audio::orchestra::DeviceInfo> list = audio::orchestra::api::pulse::getDeviceList();
etk::Vector<audio::orchestra::DeviceInfo> list = audio::orchestra::api::pulse::getDeviceList();
if (_device >= list.size()) {
ATA_ERROR("Request device out of IDs:" << _device << " >= " << list.size());
return audio::orchestra::DeviceInfo();
@ -96,10 +97,7 @@ audio::orchestra::DeviceInfo audio::orchestra::api::Pulse::getDeviceInfo(uint32_
return list[_device];
}
static void pulseaudio_callback(void* _userData) {
audio::orchestra::api::Pulse* myClass = reinterpret_cast<audio::orchestra::api::Pulse*>(_userData);
myClass->callbackEvent();
}
void audio::orchestra::api::Pulse::callbackEvent() {
ethread::setName("Pulse IO-" + m_name);
@ -113,15 +111,15 @@ enum audio::orchestra::error audio::orchestra::api::Pulse::closeStream() {
m_mutex.lock();
if (m_state == audio::orchestra::state::stopped) {
m_private->runnable = true;
m_private->runnable_cv.notify_one();;
m_private->m_semaphore.post();;
}
m_mutex.unlock();
m_mutex.unLock();
m_private->thread->join();
if (m_mode == audio::orchestra::mode_output) {
pa_simple_flush(m_private->handle, nullptr);
pa_simple_flush(m_private->handle, null);
}
pa_simple_free(m_private->handle);
m_private->handle = nullptr;
m_private->handle = null;
m_userBuffer[0].clear();
m_userBuffer[1].clear();
m_state = audio::orchestra::state::closed;
@ -131,12 +129,11 @@ enum audio::orchestra::error audio::orchestra::api::Pulse::closeStream() {
void audio::orchestra::api::Pulse::callbackEventOneCycle() {
if (m_state == audio::orchestra::state::stopped) {
std::unique_lock<std::mutex> lck(m_mutex);
while (!m_private->runnable) {
m_private->runnable_cv.wait(lck);
m_private->m_semaphore.wait();
}
if (m_state != audio::orchestra::state::running) {
m_mutex.unlock();
m_mutex.unLock();
return;
}
}
@ -145,7 +142,7 @@ void audio::orchestra::api::Pulse::callbackEventOneCycle() {
return;
}
audio::Time streamTime = getStreamTime();
std::vector<enum audio::orchestra::status> status;
etk::Vector<enum audio::orchestra::status> status;
int32_t doStopStream = m_callback(&m_userBuffer[audio::orchestra::modeToIdTable(audio::orchestra::mode_input)][0],
streamTime,
&m_userBuffer[audio::orchestra::modeToIdTable(audio::orchestra::mode_output)][0],
@ -160,7 +157,7 @@ void audio::orchestra::api::Pulse::callbackEventOneCycle() {
void *pulse_in = m_doConvertBuffer[audio::orchestra::modeToIdTable(audio::orchestra::mode_input)] ? m_deviceBuffer : &m_userBuffer[audio::orchestra::modeToIdTable(audio::orchestra::mode_input)][0];
void *pulse_out = m_doConvertBuffer[audio::orchestra::modeToIdTable(audio::orchestra::mode_output)] ? m_deviceBuffer : &m_userBuffer[audio::orchestra::modeToIdTable(audio::orchestra::mode_output)][0];
if (m_state != audio::orchestra::state::running) {
goto unlock;
goto unLock;
}
int32_t pa_error;
size_t bytes;
@ -194,8 +191,8 @@ void audio::orchestra::api::Pulse::callbackEventOneCycle() {
m_convertInfo[audio::orchestra::modeToIdTable(audio::orchestra::mode_input)]);
}
}
unlock:
m_mutex.unlock();
unLock:
m_mutex.unLock();
audio::orchestra::Api::tickStreamTime();
if (doStopStream == 1) {
stopStream();
@ -218,8 +215,8 @@ enum audio::orchestra::error audio::orchestra::api::Pulse::startStream() {
m_mutex.lock();
m_state = audio::orchestra::state::running;
m_private->runnable = true;
m_private->runnable_cv.notify_one();
m_mutex.unlock();
m_private->m_semaphore.post();
m_mutex.unLock();
return audio::orchestra::error_none;
}
@ -234,18 +231,18 @@ enum audio::orchestra::error audio::orchestra::api::Pulse::stopStream() {
}
m_state = audio::orchestra::state::stopped;
m_mutex.lock();
if ( m_private != nullptr
&& m_private->handle != nullptr
if ( m_private != null
&& m_private->handle != null
&& m_mode == audio::orchestra::mode_output) {
int32_t pa_error;
if (pa_simple_drain(m_private->handle, &pa_error) < 0) {
ATA_ERROR("error draining output device, " << pa_strerror(pa_error) << ".");
m_mutex.unlock();
m_mutex.unLock();
return audio::orchestra::error_systemError;
}
}
m_state = audio::orchestra::state::stopped;
m_mutex.unlock();
m_mutex.unLock();
return audio::orchestra::error_none;
}
@ -260,18 +257,18 @@ enum audio::orchestra::error audio::orchestra::api::Pulse::abortStream() {
}
m_state = audio::orchestra::state::stopped;
m_mutex.lock();
if ( m_private != nullptr
&& m_private->handle != nullptr
if ( m_private != null
&& m_private->handle != null
&& m_mode == audio::orchestra::mode_output) {
int32_t pa_error;
if (pa_simple_flush(m_private->handle, &pa_error) < 0) {
ATA_ERROR("error flushing output device, " << pa_strerror(pa_error) << ".");
m_mutex.unlock();
m_mutex.unLock();
return audio::orchestra::error_systemError;
}
}
m_state = audio::orchestra::state::stopped;
m_mutex.unlock();
m_mutex.unLock();
return audio::orchestra::error_none;
}
@ -356,7 +353,7 @@ bool audio::orchestra::api::Pulse::open(uint32_t _device,
bufferBytes *= *_bufferSize;
if (m_deviceBuffer) free(m_deviceBuffer);
m_deviceBuffer = (char *) calloc(bufferBytes, 1);
if (m_deviceBuffer == nullptr) {
if (m_deviceBuffer == null) {
ATA_ERROR("error allocating device buffer memory.");
goto error;
}
@ -370,15 +367,15 @@ bool audio::orchestra::api::Pulse::open(uint32_t _device,
int32_t error;
switch (_mode) {
case audio::orchestra::mode_input:
m_private->handle = pa_simple_new(nullptr, "orchestra", PA_STREAM_RECORD, nullptr, "Record", &ss, nullptr, nullptr, &error);
if (m_private->handle == nullptr) {
m_private->handle = pa_simple_new(null, "orchestra", PA_STREAM_RECORD, null, "Record", &ss, null, null, &error);
if (m_private->handle == null) {
ATA_ERROR("error connecting input to PulseAudio server.");
goto error;
}
break;
case audio::orchestra::mode_output:
m_private->handle = pa_simple_new(nullptr, "orchestra", PA_STREAM_PLAYBACK, nullptr, "Playback", &ss, nullptr, nullptr, &error);
if (m_private->handle == nullptr) {
m_private->handle = pa_simple_new(null, "orchestra", PA_STREAM_PLAYBACK, null, "Playback", &ss, null, null, &error);
if (m_private->handle == null) {
ATA_ERROR("error connecting output to PulseAudio server.");
goto error;
}
@ -393,8 +390,8 @@ bool audio::orchestra::api::Pulse::open(uint32_t _device,
}
if (m_private->threadRunning == false) {
m_private->threadRunning = true;
m_private->thread = ememory::makeShared<std::thread>(&pulseaudio_callback, this);
if (m_private->thread == nullptr) {
m_private->thread = ememory::makeShared<ethread::Thread>([&](){callbackEvent();}, "pulseCallback");
if (m_private->thread == null) {
ATA_ERROR("error creating thread.");
goto error;
}

4
audio/orchestra/api/Pulse.hpp
View File

@ -17,7 +17,7 @@ namespace audio {
public:
Pulse();
virtual ~Pulse();
const std::string& getCurrentApi() {
const etk::String& getCurrentApi() {
return audio::orchestra::typePulse;
}
uint32_t getDeviceCount();
@ -34,7 +34,7 @@ namespace audio {
void callbackEvent();
private:
ememory::SharedPtr<PulsePrivate> m_private;
std::vector<audio::orchestra::DeviceInfo> m_devices;
etk::Vector<audio::orchestra::DeviceInfo> m_devices;
void saveDeviceInfo();
bool open(uint32_t _device,
audio::orchestra::mode _mode,

139
audio/orchestra/api/PulseDeviceList.cpp
View File

@ -6,10 +6,11 @@
*/
#if defined(ORCHESTRA_BUILD_PULSE)
#include <cstdio>
#include <cstring>
#include <pulse/pulseaudio.hpp>
extern "C" {
#include <stdio.h>
#include <string.h>
}
#include <pulse/pulseaudio.h>
#include <audio/orchestra/api/PulseDeviceList.hpp>
#include <audio/orchestra/debug.hpp>
#include <audio/Time.hpp>
@ -105,101 +106,101 @@ static audio::format getFormatFromPulseFormat(enum pa_sample_format _format) {
return audio::format_unknow;
}
static std::vector<audio::channel> getChannelOrderFromPulseChannel(const struct pa_channel_map& _map) {
std::vector<audio::channel> out;
static etk::Vector<audio::channel> getChannelOrderFromPulseChannel(const struct pa_channel_map& _map) {
etk::Vector<audio::channel> out;
for (int32_t iii=0; iii<_map.channels; ++iii) {
switch(_map.map[iii]) {
default:
case PA_CHANNEL_POSITION_MAX:
case PA_CHANNEL_POSITION_INVALID:
out.push_back(audio::channel_unknow);
out.pushBack(audio::channel_unknow);
break;
case PA_CHANNEL_POSITION_MONO:
case PA_CHANNEL_POSITION_FRONT_CENTER:
out.push_back(audio::channel_frontCenter);
out.pushBack(audio::channel_frontCenter);
break;
case PA_CHANNEL_POSITION_FRONT_LEFT:
out.push_back(audio::channel_frontLeft);
out.pushBack(audio::channel_frontLeft);
break;
case PA_CHANNEL_POSITION_FRONT_RIGHT:
out.push_back(audio::channel_frontRight);
out.pushBack(audio::channel_frontRight);
break;
case PA_CHANNEL_POSITION_REAR_CENTER:
out.push_back(audio::channel_rearCenter);
out.pushBack(audio::channel_rearCenter);
break;
case PA_CHANNEL_POSITION_REAR_LEFT:
out.push_back(audio::channel_rearLeft);
out.pushBack(audio::channel_rearLeft);
break;
case PA_CHANNEL_POSITION_REAR_RIGHT:
out.push_back(audio::channel_rearRight);
out.pushBack(audio::channel_rearRight);
break;
case PA_CHANNEL_POSITION_LFE:
out.push_back(audio::channel_lfe);
out.pushBack(audio::channel_lfe);
break;
case PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER:
out.push_back(audio::channel_centerLeft);
out.pushBack(audio::channel_centerLeft);
break;
case PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER:
out.push_back(audio::channel_centerRight);
out.pushBack(audio::channel_centerRight);
break;
case PA_CHANNEL_POSITION_SIDE_LEFT:
out.push_back(audio::channel_topCenterLeft);
out.pushBack(audio::channel_topCenterLeft);
break;
case PA_CHANNEL_POSITION_SIDE_RIGHT:
out.push_back(audio::channel_topCenterRight);
out.pushBack(audio::channel_topCenterRight);
break;
case PA_CHANNEL_POSITION_TOP_CENTER:
case PA_CHANNEL_POSITION_TOP_FRONT_CENTER:
out.push_back(audio::channel_topFrontCenter);
out.pushBack(audio::channel_topFrontCenter);
break;
case PA_CHANNEL_POSITION_TOP_FRONT_LEFT:
out.push_back(audio::channel_topFrontLeft);
out.pushBack(audio::channel_topFrontLeft);
break;
case PA_CHANNEL_POSITION_TOP_FRONT_RIGHT:
out.push_back(audio::channel_topFrontRight);
out.pushBack(audio::channel_topFrontRight);
break;
case PA_CHANNEL_POSITION_TOP_REAR_LEFT:
out.push_back(audio::channel_topRearLeft);
out.pushBack(audio::channel_topRearLeft);
break;
case PA_CHANNEL_POSITION_TOP_REAR_RIGHT:
out.push_back(audio::channel_topRearRight);
out.pushBack(audio::channel_topRearRight);
break;
case PA_CHANNEL_POSITION_TOP_REAR_CENTER:
out.push_back(audio::channel_topRearCenter);
out.pushBack(audio::channel_topRearCenter);
break;
case PA_CHANNEL_POSITION_AUX0: out.push_back(audio::channel_aux0); break;
case PA_CHANNEL_POSITION_AUX1: out.push_back(audio::channel_aux1); break;
case PA_CHANNEL_POSITION_AUX2: out.push_back(audio::channel_aux2); break;
case PA_CHANNEL_POSITION_AUX3: out.push_back(audio::channel_aux3); break;
case PA_CHANNEL_POSITION_AUX4: out.push_back(audio::channel_aux4); break;
case PA_CHANNEL_POSITION_AUX5: out.push_back(audio::channel_aux5); break;
case PA_CHANNEL_POSITION_AUX6: out.push_back(audio::channel_aux6); break;
case PA_CHANNEL_POSITION_AUX7: out.push_back(audio::channel_aux7); break;
case PA_CHANNEL_POSITION_AUX8: out.push_back(audio::channel_aux8); break;
case PA_CHANNEL_POSITION_AUX9: out.push_back(audio::channel_aux9); break;
case PA_CHANNEL_POSITION_AUX10: out.push_back(audio::channel_aux10); break;
case PA_CHANNEL_POSITION_AUX11: out.push_back(audio::channel_aux11); break;
case PA_CHANNEL_POSITION_AUX12: out.push_back(audio::channel_aux12); break;
case PA_CHANNEL_POSITION_AUX13: out.push_back(audio::channel_aux13); break;
case PA_CHANNEL_POSITION_AUX14: out.push_back(audio::channel_aux14); break;
case PA_CHANNEL_POSITION_AUX15: out.push_back(audio::channel_aux15); break;
case PA_CHANNEL_POSITION_AUX16: out.push_back(audio::channel_aux16); break;
case PA_CHANNEL_POSITION_AUX17: out.push_back(audio::channel_aux17); break;
case PA_CHANNEL_POSITION_AUX18: out.push_back(audio::channel_aux18); break;
case PA_CHANNEL_POSITION_AUX19: out.push_back(audio::channel_aux19); break;
case PA_CHANNEL_POSITION_AUX20: out.push_back(audio::channel_aux20); break;
case PA_CHANNEL_POSITION_AUX21: out.push_back(audio::channel_aux21); break;
case PA_CHANNEL_POSITION_AUX22: out.push_back(audio::channel_aux22); break;
case PA_CHANNEL_POSITION_AUX23: out.push_back(audio::channel_aux23); break;
case PA_CHANNEL_POSITION_AUX24: out.push_back(audio::channel_aux24); break;
case PA_CHANNEL_POSITION_AUX25: out.push_back(audio::channel_aux25); break;
case PA_CHANNEL_POSITION_AUX26: out.push_back(audio::channel_aux26); break;
case PA_CHANNEL_POSITION_AUX27: out.push_back(audio::channel_aux27); break;
case PA_CHANNEL_POSITION_AUX28: out.push_back(audio::channel_aux28); break;
case PA_CHANNEL_POSITION_AUX29: out.push_back(audio::channel_aux29); break;
case PA_CHANNEL_POSITION_AUX30: out.push_back(audio::channel_aux30); break;
case PA_CHANNEL_POSITION_AUX31: out.push_back(audio::channel_aux31); break;
case PA_CHANNEL_POSITION_AUX0: out.pushBack(audio::channel_aux0); break;
case PA_CHANNEL_POSITION_AUX1: out.pushBack(audio::channel_aux1); break;
case PA_CHANNEL_POSITION_AUX2: out.pushBack(audio::channel_aux2); break;
case PA_CHANNEL_POSITION_AUX3: out.pushBack(audio::channel_aux3); break;
case PA_CHANNEL_POSITION_AUX4: out.pushBack(audio::channel_aux4); break;
case PA_CHANNEL_POSITION_AUX5: out.pushBack(audio::channel_aux5); break;
case PA_CHANNEL_POSITION_AUX6: out.pushBack(audio::channel_aux6); break;
case PA_CHANNEL_POSITION_AUX7: out.pushBack(audio::channel_aux7); break;
case PA_CHANNEL_POSITION_AUX8: out.pushBack(audio::channel_aux8); break;
case PA_CHANNEL_POSITION_AUX9: out.pushBack(audio::channel_aux9); break;
case PA_CHANNEL_POSITION_AUX10: out.pushBack(audio::channel_aux10); break;
case PA_CHANNEL_POSITION_AUX11: out.pushBack(audio::channel_aux11); break;
case PA_CHANNEL_POSITION_AUX12: out.pushBack(audio::channel_aux12); break;
case PA_CHANNEL_POSITION_AUX13: out.pushBack(audio::channel_aux13); break;
case PA_CHANNEL_POSITION_AUX14: out.pushBack(audio::channel_aux14); break;
case PA_CHANNEL_POSITION_AUX15: out.pushBack(audio::channel_aux15); break;
case PA_CHANNEL_POSITION_AUX16: out.pushBack(audio::channel_aux16); break;
case PA_CHANNEL_POSITION_AUX17: out.pushBack(audio::channel_aux17); break;
case PA_CHANNEL_POSITION_AUX18: out.pushBack(audio::channel_aux18); break;
case PA_CHANNEL_POSITION_AUX19: out.pushBack(audio::channel_aux19); break;
case PA_CHANNEL_POSITION_AUX20: out.pushBack(audio::channel_aux20); break;
case PA_CHANNEL_POSITION_AUX21: out.pushBack(audio::channel_aux21); break;
case PA_CHANNEL_POSITION_AUX22: out.pushBack(audio::channel_aux22); break;
case PA_CHANNEL_POSITION_AUX23: out.pushBack(audio::channel_aux23); break;
case PA_CHANNEL_POSITION_AUX24: out.pushBack(audio::channel_aux24); break;
case PA_CHANNEL_POSITION_AUX25: out.pushBack(audio::channel_aux25); break;
case PA_CHANNEL_POSITION_AUX26: out.pushBack(audio::channel_aux26); break;
case PA_CHANNEL_POSITION_AUX27: out.pushBack(audio::channel_aux27); break;
case PA_CHANNEL_POSITION_AUX28: out.pushBack(audio::channel_aux28); break;
case PA_CHANNEL_POSITION_AUX29: out.pushBack(audio::channel_aux29); break;
case PA_CHANNEL_POSITION_AUX30: out.pushBack(audio::channel_aux30); break;
case PA_CHANNEL_POSITION_AUX31: out.pushBack(audio::channel_aux31); break;
}
}
@ -207,7 +208,7 @@ static std::vector<audio::channel> getChannelOrderFromPulseChannel(const struct
}
// Callback on getting data from pulseaudio:
static void callbackGetSinkList(pa_context* _contex, const pa_sink_info* _info, int _eol, void* _userdata) {
std::vector<audio::orchestra::DeviceInfo>* list = static_cast<std::vector<audio::orchestra::DeviceInfo>*>(_userdata);
etk::Vector<audio::orchestra::DeviceInfo>* list = static_cast<etk::Vector<audio::orchestra::DeviceInfo>*>(_userdata);
// If eol is set to a positive number, you're at the end of the list
if (_eol > 0) {
return;
@ -217,17 +218,17 @@ static void callbackGetSinkList(pa_context* _contex, const pa_sink_info* _info,
info.input = false;
info.name = _info->name;
info.desc = _info->description;
info.sampleRates.push_back(_info->sample_spec.rate);
info.nativeFormats.push_back(getFormatFromPulseFormat(_info->sample_spec.format));
info.sampleRates.pushBack(_info->sample_spec.rate);
info.nativeFormats.pushBack(getFormatFromPulseFormat(_info->sample_spec.format));
info.channels = getChannelOrderFromPulseChannel(_info->channel_map);
ATA_VERBOSE("plop=" << _info->index << " " << _info->name);
//ATA_DEBUG(" ports=" << _info->n_ports);
list->push_back(info);
list->pushBack(info);
}
// allback to get data from pulseaudio:
static void callbackGetSourceList(pa_context* _contex, const pa_source_info* _info, int _eol, void* _userdata) {
std::vector<audio::orchestra::DeviceInfo>* list = static_cast<std::vector<audio::orchestra::DeviceInfo>*>(_userdata);
etk::Vector<audio::orchestra::DeviceInfo>* list = static_cast<etk::Vector<audio::orchestra::DeviceInfo>*>(_userdata);
if (_eol > 0) {
return;
}
@ -236,18 +237,18 @@ static void callbackGetSourceList(pa_context* _contex, const pa_source_info* _in
info.input = true;
info.name = _info->name;
info.desc = _info->description;
info.sampleRates.push_back(_info->sample_spec.rate);
info.nativeFormats.push_back(getFormatFromPulseFormat(_info->sample_spec.format));
info.sampleRates.pushBack(_info->sample_spec.rate);
info.nativeFormats.pushBack(getFormatFromPulseFormat(_info->sample_spec.format));
info.channels = getChannelOrderFromPulseChannel(_info->channel_map);
ATA_VERBOSE("plop=" << _info->index << " " << _info->name);
list->push_back(info);
list->pushBack(info);
}
// to not update all the time ...
static std::vector<audio::orchestra::DeviceInfo> pulseAudioListOfDevice;
static etk::Vector<audio::orchestra::DeviceInfo> pulseAudioListOfDevice;
static audio::Time pulseAudioListOfDeviceTime;
std::vector<audio::orchestra::DeviceInfo> audio::orchestra::api::pulse::getDeviceList() {
etk::Vector<audio::orchestra::DeviceInfo> audio::orchestra::api::pulse::getDeviceList() {
audio::Duration delta = audio::Time::now() - pulseAudioListOfDeviceTime;
if (delta < audio::Duration(30,0)) {
return pulseAudioListOfDevice;
@ -258,7 +259,7 @@ std::vector<audio::orchestra::DeviceInfo> audio::orchestra::api::pulse::getDevic
pa_operation* pulseAudioOperation;
pa_context* pulseAudioContex;
pa_context_flags_t pulseAudioFlags = PA_CONTEXT_NOAUTOSPAWN;
std::vector<audio::orchestra::DeviceInfo>& out = pulseAudioListOfDevice;
etk::Vector<audio::orchestra::DeviceInfo>& out = pulseAudioListOfDevice;
out.clear();
// We'll need these state variables to keep track of our requests
int state = 0;
@ -276,7 +277,7 @@ std::vector<audio::orchestra::DeviceInfo> audio::orchestra::api::pulse::getDevic
// We can't do anything until PA is ready, so just iterate the mainloop
// and continue
if (pulseAudioReady == 0) {
pa_mainloop_iterate(pulseAudioMainLoop, 1, nullptr);
pa_mainloop_iterate(pulseAudioMainLoop, 1, null);
continue;
}
// We couldn't get a connection to the server, so exit out
@ -330,7 +331,7 @@ std::vector<audio::orchestra::DeviceInfo> audio::orchestra::api::pulse::getDevic
}
// Iterate the main loop ..
if (playLoop == true) {
pa_mainloop_iterate(pulseAudioMainLoop, 1, nullptr);
pa_mainloop_iterate(pulseAudioMainLoop, 1, null);
}
}
// TODO: need to do it better ...

2
audio/orchestra/api/PulseDeviceList.hpp
View File

@ -14,7 +14,7 @@ namespace audio {
namespace orchestra {
namespace api {
namespace pulse {
std::vector<audio::orchestra::DeviceInfo> getDeviceList();
etk::Vector<audio::orchestra::DeviceInfo> getDeviceList();
}
}
}

10
audio/orchestra/base.hpp
View File

@ -6,11 +6,11 @@
*/
#pragma once
#include <thread>
#include <condition_variable>
#include <mutex>
#include <chrono>
#include <functional>
#include <ethread/Thread.hpp>
#include <ethread/Semaphore.hpp>
#include <ethread/Mutex.hpp>
#include <echrono/Steady.hpp>
#include <etk/Function.hpp>
#include <ememory/memory.hpp>
#include <audio/channel.hpp>
#include <audio/format.hpp>

4
audio/orchestra/mode.cpp
View File

@ -20,7 +20,7 @@ int32_t audio::orchestra::modeToIdTable(enum mode _mode) {
return 0;
}
std::ostream& audio::operator <<(std::ostream& _os, enum audio::orchestra::mode _obj) {
etk::Stream& audio::operator <<(etk::Stream& _os, enum audio::orchestra::mode _obj) {
switch (_obj) {
case audio::orchestra::mode_unknow:
_os << "unknow";
@ -36,4 +36,4 @@ std::ostream& audio::operator <<(std::ostream& _os, enum audio::orchestra::mode
break;
}
return _os;
}
}

3
audio/orchestra/mode.hpp
View File

@ -7,6 +7,7 @@
#pragma once
#include <etk/types.hpp>
#include <etk/Stream.hpp>
namespace audio {
namespace orchestra {
@ -18,6 +19,6 @@ namespace audio {
};
int32_t modeToIdTable(enum mode _mode);
}
std::ostream& operator <<(std::ostream& _os, enum audio::orchestra::mode _obj);
etk::Stream& operator <<(etk::Stream& _os, enum audio::orchestra::mode _obj);
}

10
audio/orchestra/status.cpp
View File

@ -13,20 +13,20 @@ static const char* listValue[] = {
"underflow"
};
std::ostream& audio::orchestra::operator <<(std::ostream& _os, enum audio::orchestra::status _obj) {
etk::Stream& audio::orchestra::operator <<(etk::Stream& _os, enum audio::orchestra::status _obj) {
_os << listValue[int32_t(_obj)];
return _os;
}
std::ostream& audio::orchestra::operator <<(std::ostream& _os, const std::vector<enum audio::orchestra::status>& _obj) {
_os << std::string("{");
etk::Stream& audio::orchestra::operator <<(etk::Stream& _os, const etk::Vector<enum audio::orchestra::status>& _obj) {
_os << etk::String("{");
for (size_t iii=0; iii<_obj.size(); ++iii) {
if (iii!=0) {
_os << std::string(";");
_os << etk::String(";");
}
_os << _obj[iii];
}
_os << std::string("}");
_os << etk::String("}");
return _os;
}

5
audio/orchestra/status.hpp
View File

@ -7,6 +7,7 @@
#pragma once
#include <etk/types.hpp>
#include <etk/Vector.hpp>
namespace audio {
namespace orchestra {
@ -15,8 +16,8 @@ namespace audio {
overflow, //!< Internal buffer has more data than they can accept
underflow //!< The internal buffer is empty
};
std::ostream& operator <<(std::ostream& _os, enum audio::orchestra::status _obj);
std::ostream& operator <<(std::ostream& _os, const std::vector<enum audio::orchestra::status>& _obj);
etk::Stream& operator <<(etk::Stream& _os, enum audio::orchestra::status _obj);
etk::Stream& operator <<(etk::Stream& _os, const etk::Vector<enum audio::orchestra::status>& _obj);
}
}

26
audio/orchestra/type.cpp
View File

@ -7,19 +7,15 @@
#include <audio/orchestra/type.hpp>
#include <audio/orchestra/debug.hpp>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <climits>
const std::string audio::orchestra::typeUndefined = "undefined";
const std::string audio::orchestra::typeAlsa = "alsa";
const std::string audio::orchestra::typePulse = "pulse";
const std::string audio::orchestra::typeOss = "oss";
const std::string audio::orchestra::typeJack = "jack";
const std::string audio::orchestra::typeCoreOSX = "coreOSX";
const std::string audio::orchestra::typeCoreIOS = "coreIOS";
const std::string audio::orchestra::typeAsio = "asio";
const std::string audio::orchestra::typeDs = "ds";
const std::string audio::orchestra::typeJava = "java";
const std::string audio::orchestra::typeDummy = "dummy";
const etk::String audio::orchestra::typeUndefined = "undefined";
const etk::String audio::orchestra::typeAlsa = "alsa";
const etk::String audio::orchestra::typePulse = "pulse";
const etk::String audio::orchestra::typeOss = "oss";
const etk::String audio::orchestra::typeJack = "jack";
const etk::String audio::orchestra::typeCoreOSX = "coreOSX";
const etk::String audio::orchestra::typeCoreIOS = "coreIOS";
const etk::String audio::orchestra::typeAsio = "asio";
const etk::String audio::orchestra::typeDs = "ds";
const etk::String audio::orchestra::typeJava = "java";
const etk::String audio::orchestra::typeDummy = "dummy";

22
audio/orchestra/type.hpp
View File

@ -14,17 +14,17 @@ namespace audio {
/**
* @brief Audio API specifier arguments.
*/
extern const std::string typeUndefined; //!< Error API.
extern const std::string typeAlsa; //!< LINUX The Advanced Linux Sound Architecture.
extern const std::string typePulse; //!< LINUX The Linux PulseAudio.
extern const std::string typeOss; //!< LINUX The Linux Open Sound System.
extern const std::string typeJack; //!< UNIX The Jack Low-Latency Audio Server.
extern const std::string typeCoreOSX; //!< Macintosh OSX Core Audio.
extern const std::string typeCoreIOS; //!< Macintosh iOS Core Audio.
extern const std::string typeAsio; //!< WINDOWS The Steinberg Audio Stream I/O.
extern const std::string typeDs; //!< WINDOWS The Microsoft Direct Sound.
extern const std::string typeJava; //!< ANDROID Interface.
extern const std::string typeDummy; //!< Empty wrapper (non-functional).
extern const etk::String typeUndefined; //!< Error API.
extern const etk::String typeAlsa; //!< LINUX The Advanced Linux Sound Architecture.
extern const etk::String typePulse; //!< LINUX The Linux PulseAudio.
extern const etk::String typeOss; //!< LINUX The Linux Open Sound System.
extern const etk::String typeJack; //!< UNIX The Jack Low-Latency Audio Server.
extern const etk::String typeCoreOSX; //!< Macintosh OSX Core Audio.
extern const etk::String typeCoreIOS; //!< Macintosh iOS Core Audio.
extern const etk::String typeAsio; //!< WINDOWS The Steinberg Audio Stream I/O.
extern const etk::String typeDs; //!< WINDOWS The Microsoft Direct Sound.
extern const etk::String typeJava; //!< ANDROID Interface.
extern const etk::String typeDummy; //!< Empty wrapper (non-functional).
}
}

2
lutin_audio-orchestra.py
View File

@ -1,6 +1,6 @@
#!/usr/bin/python
import lutin.tools as tools
import lutin.debug as debug
import realog.debug as debug
def get_type():

2
tools/lutin_orchestra-in.py
View File

@ -1,5 +1,5 @@
#!/usr/bin/python
import lutin.debug as debug
import realog.debug as debug
import lutin.tools as tools

2
tools/lutin_orchestra-list.py
View File

@ -1,5 +1,5 @@
#!/usr/bin/python
import lutin.debug as debug
import realog.debug as debug
import lutin.tools as tools

2
tools/lutin_orchestra-out.py
View File

@ -1,5 +1,5 @@
#!/usr/bin/python
import lutin.debug as debug
import realog.debug as debug
import lutin.tools as tools

6
tools/orchestra-in.cpp
View File

@ -13,11 +13,11 @@ int main(int _argc, const char **_argv) {
// the only one init for etk:
etk::init(_argc, _argv);
for (int32_t iii=0; iii<_argc ; ++iii) {
std::string data = _argv[iii];
etk::String data = _argv[iii];
if ( data == "-h"
|| data == "--help") {
std::cout << "Help : " << std::endl;
std::cout << " ./xxx ---" << std::endl;
TEST_PRINT("Help : ");
TEST_PRINT(" ./xxx ---");
exit(0);
}
}

8
tools/orchestra-list.cpp
View File

@ -13,16 +13,16 @@ int main(int _argc, const char **_argv) {
// the only one init for etk:
etk::init(_argc, _argv);
for (int32_t iii=0; iii<_argc ; ++iii) {
std::string data = _argv[iii];
etk::String data = _argv[iii];
if ( data == "-h"
|| data == "--help") {
std::cout << "Help : " << std::endl;
std::cout << " ./xxx ---" << std::endl;
TEST_PRINT("Help : ");
TEST_PRINT(" ./xxx ---");
exit(0);
}
}
audio::orchestra::Interface interface;
std::vector<std::string> apis = interface.getListApi();
etk::Vector<etk::String> apis = interface.getListApi();
TEST_PRINT("Find : " << apis.size() << " apis.");
for (auto &it : apis) {
interface.instanciate(it);

6
tools/orchestra-out.cpp
View File

@ -13,11 +13,11 @@ int main(int _argc, const char **_argv) {
// the only one init for etk:
etk::init(_argc, _argv);
for (int32_t iii=0; iii<_argc ; ++iii) {
std::string data = _argv[iii];
etk::String data = _argv[iii];
if ( data == "-h"
|| data == "--help") {
std::cout << "Help : " << std::endl;
std::cout << " ./xxx ---" << std::endl;
TEST_PRINT("Help : ");
TEST_PRINT(" ./xxx ---");
exit(0);
}
}

2
version.txt
View File

@ -1 +1 @@
0.4.0
1.0.0