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

[STYLE] remove (void) in () to be c++ coherent

Browse Source
This commit is contained in:
Edouard DUPIN
2014-05-15 21:37:39 +02:00
parent 490e993c6f
commit bb547a72d9
30 changed files with 252 additions and 252 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
airtaudio/api/Alsa.cpp
View File

@@ -15,7 +15,7 @@
#include <airtaudio/debug.h>
#include <limits.h>
airtaudio::Api* airtaudio::api::Alsa::Create(void) {
airtaudio::Api* airtaudio::api::Alsa::Create() {
return new airtaudio::api::Alsa();
}
@@ -29,7 +29,7 @@ struct AlsaHandle {
std::condition_variable runnable_cv;
bool runnable;
AlsaHandle(void) :
AlsaHandle() :
synchronized(false),
runnable(false) {
xrun[0] = false;
@@ -39,17 +39,17 @@ struct AlsaHandle {
static void alsaCallbackHandler(void * _ptr);
airtaudio::api::Alsa::Alsa(void) {
airtaudio::api::Alsa::Alsa() {
// Nothing to do here.
}
airtaudio::api::Alsa::~Alsa(void) {
airtaudio::api::Alsa::~Alsa() {
if (m_stream.state != STREAM_CLOSED) {
closeStream();
}
}
uint32_t airtaudio::api::Alsa::getDeviceCount(void) {
uint32_t airtaudio::api::Alsa::getDeviceCount() {
unsigned nDevices = 0;
int32_t result, subdevice, card;
char name[64];
@@ -349,7 +349,7 @@ probeParameters:
return info;
}
void airtaudio::api::Alsa::saveDeviceInfo(void) {
void airtaudio::api::Alsa::saveDeviceInfo() {
m_devices.clear();
uint32_t nDevices = getDeviceCount();
m_devices.resize(nDevices);
@@ -773,7 +773,7 @@ error:
return false;
}
enum airtaudio::errorType airtaudio::api::Alsa::closeStream(void) {
enum airtaudio::errorType airtaudio::api::Alsa::closeStream() {
if (m_stream.state == STREAM_CLOSED) {
ATA_ERROR("airtaudio::api::Alsa::closeStream(): no open stream to close!");
return airtaudio::errorWarning;
@@ -826,7 +826,7 @@ enum airtaudio::errorType airtaudio::api::Alsa::closeStream(void) {
return airtaudio::errorNone;
}
enum airtaudio::errorType airtaudio::api::Alsa::startStream(void) {
enum airtaudio::errorType airtaudio::api::Alsa::startStream() {
// This method calls snd_pcm_prepare if the device isn't already in that state.
if (verifyStream() != airtaudio::errorNone) {
return airtaudio::errorFail;
@@ -872,7 +872,7 @@ unlock:
return airtaudio::errorSystemError;
}
enum airtaudio::errorType airtaudio::api::Alsa::stopStream(void) {
enum airtaudio::errorType airtaudio::api::Alsa::stopStream() {
if (verifyStream() != airtaudio::errorNone) {
return airtaudio::errorFail;
}
@@ -913,7 +913,7 @@ unlock:
return airtaudio::errorSystemError;
}
enum airtaudio::errorType airtaudio::api::Alsa::abortStream(void) {
enum airtaudio::errorType airtaudio::api::Alsa::abortStream() {
if (verifyStream() != airtaudio::errorNone) {
return airtaudio::errorFail;
}
@@ -950,7 +950,7 @@ unlock:
return airtaudio::errorSystemError;
}
void airtaudio::api::Alsa::callbackEvent(void) {
void airtaudio::api::Alsa::callbackEvent() {
AlsaHandle *apiInfo = (AlsaHandle *) m_stream.apiHandle;
if (m_stream.state == STREAM_STOPPED) {
std::unique_lock<std::mutex> lck(m_stream.mutex);

18
airtaudio/api/Alsa.h
View File

@@ -13,27 +13,27 @@ namespace airtaudio {
namespace api {
class Alsa: public airtaudio::Api {
public:
static airtaudio::Api* Create(void);
static airtaudio::Api* Create();
public:
Alsa();
~Alsa();
airtaudio::api::type getCurrentApi(void) {
airtaudio::api::type getCurrentApi() {
return airtaudio::api::LINUX_ALSA;
}
uint32_t getDeviceCount(void);
uint32_t getDeviceCount();
airtaudio::DeviceInfo getDeviceInfo(uint32_t _device);
enum airtaudio::errorType closeStream(void);
enum airtaudio::errorType startStream(void);
enum airtaudio::errorType stopStream(void);
enum airtaudio::errorType abortStream(void);
enum airtaudio::errorType closeStream();
enum airtaudio::errorType startStream();
enum airtaudio::errorType stopStream();
enum airtaudio::errorType abortStream();
// This function is intended for internal use only. It must be
// public because it is called by the internal callback handler,
// which is not a member of RtAudio. External use of this function
// will most likely produce highly undesireable results!
void callbackEvent(void);
void callbackEvent();
private:
std::vector<airtaudio::DeviceInfo> m_devices;
void saveDeviceInfo(void);
void saveDeviceInfo();
bool probeDeviceOpen(uint32_t _device,
airtaudio::api::StreamMode _mode,
uint32_t _channels,

16
airtaudio/api/Android.cpp
View File

@@ -12,13 +12,13 @@
#include <airtaudio/debug.h>
#include <limits.h>
airtaudio::Api* airtaudio::api::Android::Create(void) {
airtaudio::Api* airtaudio::api::Android::Create() {
ATA_INFO("Create Android device ... ");
return new airtaudio::api::Android();
}
airtaudio::api::Android::Android(void) {
airtaudio::api::Android::Android() {
ATA_INFO("new Android");
// On android, we set a static device ...
ATA_INFO("get context");
@@ -75,11 +75,11 @@ airtaudio::api::Android::Android(void) {
ATA_INFO("Create Android interface (end)");
}
airtaudio::api::Android::~Android(void) {
airtaudio::api::Android::~Android() {
ATA_INFO("Destroy Android interface");
}
uint32_t airtaudio::api::Android::getDeviceCount(void) {
uint32_t airtaudio::api::Android::getDeviceCount() {
//ATA_INFO("Get device count:"<< m_devices.size());
return m_devices.size();
}
@@ -89,19 +89,19 @@ airtaudio::DeviceInfo airtaudio::api::Android::getDeviceInfo(uint32_t _device) {
return m_devices[_device];
}
enum airtaudio::errorType airtaudio::api::Android::closeStream(void) {
enum airtaudio::errorType airtaudio::api::Android::closeStream() {
ATA_INFO("Clese Stream");
// Can not close the stream now...
return airtaudio::errorNone;
}
enum airtaudio::errorType airtaudio::api::Android::startStream(void) {
enum airtaudio::errorType airtaudio::api::Android::startStream() {
ATA_INFO("Start Stream");
// Can not close the stream now...
return airtaudio::errorNone;
}
enum airtaudio::errorType airtaudio::api::Android::stopStream(void) {
enum airtaudio::errorType airtaudio::api::Android::stopStream() {
ATA_INFO("Stop stream");
ewol::Context& tmpContext = ewol::getContext();
tmpContext.audioCloseDevice(0);
@@ -109,7 +109,7 @@ enum airtaudio::errorType airtaudio::api::Android::stopStream(void) {
return airtaudio::errorNone;
}
enum airtaudio::errorType airtaudio::api::Android::abortStream(void) {
enum airtaudio::errorType airtaudio::api::Android::abortStream() {
ATA_INFO("Abort Stream");
ewol::Context& tmpContext = ewol::getContext();
tmpContext.audioCloseDevice(0);

22
airtaudio/api/Android.h
View File

@@ -11,27 +11,27 @@ namespace airtaudio {
namespace api {
class Android: public airtaudio::Api {
public:
static airtaudio::Api* Create(void);
static airtaudio::Api* Create();
public:
Android(void);
~Android(void);
airtaudio::api::type getCurrentApi(void) {
Android();
~Android();
airtaudio::api::type getCurrentApi() {
return airtaudio::api::ANDROID_JAVA;
}
uint32_t getDeviceCount(void);
uint32_t getDeviceCount();
airtaudio::DeviceInfo getDeviceInfo(uint32_t _device);
enum airtaudio::errorType closeStream(void);
enum airtaudio::errorType startStream(void);
enum airtaudio::errorType stopStream(void);
enum airtaudio::errorType abortStream(void);
enum airtaudio::errorType closeStream();
enum airtaudio::errorType startStream();
enum airtaudio::errorType stopStream();
enum airtaudio::errorType abortStream();
// This function is intended for internal use only. It must be
// public because it is called by the internal callback handler,
// which is not a member of RtAudio. External use of this function
// will most likely produce highly undesireable results!
void callbackEvent(void);
void callbackEvent();
private:
std::vector<airtaudio::DeviceInfo> m_devices;
void saveDeviceInfo(void);
void saveDeviceInfo();
bool probeDeviceOpen(uint32_t _device,
airtaudio::api::StreamMode _mode,
uint32_t _channels,

20
airtaudio/api/Asio.cpp
View File

@@ -12,7 +12,7 @@
#include <airtaudio/Interface.h>
#include <airtaudio/debug.h>
airtaudio::Api* airtaudio::api::Asio::Create(void) {
airtaudio::Api* airtaudio::api::Asio::Create() {
return new airtaudio::api::Asio();
}
@@ -50,7 +50,7 @@ struct AsioHandle {
bool internalDrain; // Indicates if stop is initiated from callback or not.
ASIOBufferInfo *bufferInfos;
HANDLE condition;
AsioHandle(void) :
AsioHandle() :
drainCounter(0),
internalDrain(false),
bufferInfos(0) {
@@ -63,7 +63,7 @@ static const char* getAsioErrorString(ASIOError _result);
static void sampleRateChanged(ASIOSampleRate _sRate);
static long asioMessages(long _selector, long _value, void* _message, double* _opt);
airtaudio::api::Asio::Asio(void) {
airtaudio::api::Asio::Asio() {
// 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).
@@ -79,7 +79,7 @@ airtaudio::api::Asio::Asio(void) {
driverInfo.sysRef = GetForegroundWindow();
}
airtaudio::api::Asio::~Asio(void) {
airtaudio::api::Asio::~Asio() {
if (m_stream.state != STREAM_CLOSED) {
closeStream();
}
@@ -88,7 +88,7 @@ airtaudio::api::Asio::~Asio(void) {
}
}
uint32_t airtaudio::api::Asio::getDeviceCount(void) {
uint32_t airtaudio::api::Asio::getDeviceCount() {
return (uint32_t) drivers.asioGetNumDev();
}
@@ -200,7 +200,7 @@ static void bufferSwitch(long _index, ASIOBool _processNow) {
object->callbackEvent(_index);
}
void airtaudio::api::Asio::saveDeviceInfo(void) {
void airtaudio::api::Asio::saveDeviceInfo() {
m_devices.clear();
uint32_t nDevices = getDeviceCount();
m_devices.resize(nDevices);
@@ -563,7 +563,7 @@ error:
return false;
}
enum airtaudio::errorType airtaudio::api::Asio::closeStream(void) {
enum airtaudio::errorType airtaudio::api::Asio::closeStream() {
if (m_stream.state == STREAM_CLOSED) {
ATA_ERROR("airtaudio::api::Asio::closeStream(): no open stream to close!");
return airtaudio::errorWarning;
@@ -600,7 +600,7 @@ enum airtaudio::errorType airtaudio::api::Asio::closeStream(void) {
bool stopThreadCalled = false;
enum airtaudio::errorType airtaudio::api::Asio::startStream(void) {
enum airtaudio::errorType airtaudio::api::Asio::startStream() {
if (verifyStream() != airtaudio::errorNone) {
return airtaudio::errorFail;
}
@@ -627,7 +627,7 @@ unlock:
return airtaudio::errorSystemError;
}
enum airtaudio::errorType airtaudio::api::Asio::stopStream(void) {
enum airtaudio::errorType airtaudio::api::Asio::stopStream() {
if (verifyStream() != airtaudio::errorNone) {
return airtaudio::errorFail;
}
@@ -653,7 +653,7 @@ enum airtaudio::errorType airtaudio::api::Asio::stopStream(void) {
return airtaudio::errorSystemError;
}
enum airtaudio::errorType airtaudio::api::Asio::abortStream(void) {
enum airtaudio::errorType airtaudio::api::Asio::abortStream() {
if (verifyStream() != airtaudio::errorNone) {
return airtaudio::errorFail;
}

18
airtaudio/api/Asio.h
View File

@@ -13,20 +13,20 @@ namespace airtaudio {
namespace api {
class Asio: public airtaudio::Api {
public:
static airtaudio::Api* Create(void);
static airtaudio::Api* Create();
public:
Asio();
~Asio();
airtaudio::api::type getCurrentApi(void) {
airtaudio::api::type getCurrentApi() {
return airtaudio::WINDOWS_ASIO;
}
uint32_t getDeviceCount(void);
uint32_t getDeviceCount();
airtaudio::DeviceInfo getDeviceInfo(uint32_t _device);
enum airtaudio::errorType closeStream(void);
enum airtaudio::errorType startStream(void);
enum airtaudio::errorType stopStream(void);
enum airtaudio::errorType abortStream(void);
long getStreamLatency(void);
enum airtaudio::errorType closeStream();
enum airtaudio::errorType startStream();
enum airtaudio::errorType stopStream();
enum airtaudio::errorType abortStream();
long getStreamLatency();
// This function is intended for internal use only. It must be
// public because it is called by the internal callback handler,
// which is not a member of RtAudio. External use of this function
@@ -34,7 +34,7 @@ namespace airtaudio {
bool callbackEvent(long _bufferIndex);
private:
std::vector<airtaudio::DeviceInfo> m_devices;
void saveDeviceInfo(void);
void saveDeviceInfo();
bool m_coInitialized;
bool probeDeviceOpen(uint32_t _device,
airtaudio::api::StreamMode _mode,

22
airtaudio/api/Core.cpp
View File

@@ -18,7 +18,7 @@
#include <airtaudio/Interface.h>
#include <airtaudio/debug.h>
airtaudio::Api* airtaudio::api::Core::Create(void) {
airtaudio::Api* airtaudio::api::Core::Create() {
return new airtaudio::api::Core();
}
@@ -52,7 +52,7 @@ struct CoreHandle {
std::condition_variable condition;
int32_t drainCounter; // Tracks callback counts when draining
bool internalDrain; // Indicates if stop is initiated from callback or not.
CoreHandle(void) :
CoreHandle() :
deviceBuffer(0),
drainCounter(0),
internalDrain(false) {
@@ -65,7 +65,7 @@ struct CoreHandle {
}
};
airtaudio::api::Core::Core(void) {
airtaudio::api::Core::Core() {
#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
@@ -89,7 +89,7 @@ airtaudio::api::Core::Core(void) {
#endif
}
airtaudio::api::Core::~Core(void) {
airtaudio::api::Core::~Core() {
// The subclass destructor gets called before the base class
// destructor, so close an existing stream before deallocating
// apiDeviceId memory.
@@ -98,7 +98,7 @@ airtaudio::api::Core::~Core(void) {
}
}
uint32_t airtaudio::api::Core::getDeviceCount(void) {
uint32_t airtaudio::api::Core::getDeviceCount() {
// Find out how many audio devices there are, if any.
uint32_t dataSize;
AudioObjectPropertyAddress propertyAddress = {
@@ -114,7 +114,7 @@ uint32_t airtaudio::api::Core::getDeviceCount(void) {
return dataSize / sizeof(AudioDeviceID);
}
uint32_t airtaudio::api::Core::getDefaultInputDevice(void) {
uint32_t airtaudio::api::Core::getDefaultInputDevice() {
uint32_t nDevices = getDeviceCount();
if (nDevices <= 1) {
return 0;
@@ -158,7 +158,7 @@ uint32_t airtaudio::api::Core::getDefaultInputDevice(void) {
return 0;
}
uint32_t airtaudio::api::Core::getDefaultOutputDevice(void) {
uint32_t airtaudio::api::Core::getDefaultOutputDevice() {
uint32_t nDevices = getDeviceCount();
if (nDevices <= 1) {
return 0;
@@ -921,7 +921,7 @@ error:
return false;
}
enum airtaudio::errorType airtaudio::api::Core::closeStream(void) {
enum airtaudio::errorType airtaudio::api::Core::closeStream() {
if (m_stream.state == STREAM_CLOSED) {
ATA_ERROR("airtaudio::api::Core::closeStream(): no open stream to close!");
return airtaudio::errorWarning;
@@ -969,7 +969,7 @@ enum airtaudio::errorType airtaudio::api::Core::closeStream(void) {
return airtaudio::errorNone;
}
enum airtaudio::errorType airtaudio::api::Core::startStream(void) {
enum airtaudio::errorType airtaudio::api::Core::startStream() {
if (verifyStream() != airtaudio::errorNone) {
return airtaudio::errorFail;
}
@@ -1006,7 +1006,7 @@ unlock:
return airtaudio::errorSystemError;
}
enum airtaudio::errorType airtaudio::api::Core::stopStream(void) {
enum airtaudio::errorType airtaudio::api::Core::stopStream() {
if (verifyStream() != airtaudio::errorNone) {
return airtaudio::errorFail;
}
@@ -1046,7 +1046,7 @@ unlock:
return airtaudio::errorSystemError;
}
enum airtaudio::errorType airtaudio::api::Core::abortStream(void) {
enum airtaudio::errorType airtaudio::api::Core::abortStream() {
if (verifyStream() != airtaudio::errorNone) {
return airtaudio::errorFail;
}

20
airtaudio/api/Core.h
View File

@@ -15,22 +15,22 @@ namespace airtaudio {
namespace api {
class Core: public airtaudio::Api {
public:
static airtaudio::Api* Create(void);
static airtaudio::Api* Create();
public:
Core();
~Core();
airtaudio::api::type getCurrentApi(void) {
airtaudio::api::type getCurrentApi() {
return airtaudio::api::MACOSX_CORE;
}
uint32_t getDeviceCount(void);
uint32_t getDeviceCount();
airtaudio::DeviceInfo getDeviceInfo(uint32_t _device);
uint32_t getDefaultOutputDevice(void);
uint32_t getDefaultInputDevice(void);
enum airtaudio::errorType closeStream(void);
enum airtaudio::errorType startStream(void);
enum airtaudio::errorType stopStream(void);
enum airtaudio::errorType abortStream(void);
long getStreamLatency(void);
uint32_t getDefaultOutputDevice();
uint32_t getDefaultInputDevice();
enum airtaudio::errorType closeStream();
enum airtaudio::errorType startStream();
enum airtaudio::errorType stopStream();
enum airtaudio::errorType abortStream();
long getStreamLatency();
// This function is intended for internal use only. It must be
// public because it is called by the internal callback handler,
// which is not a member of RtAudio. External use of this function

22
airtaudio/api/CoreIos.h
View File

@@ -12,27 +12,27 @@ namespace airtaudio {
class CoreIosPrivate;
class CoreIos: public airtaudio::Api {
public:
static airtaudio::Api* Create(void);
static airtaudio::Api* Create();
public:
CoreIos(void);
~CoreIos(void);
airtaudio::api::type getCurrentApi(void) {
CoreIos();
~CoreIos();
airtaudio::api::type getCurrentApi() {
return airtaudio::api::IOS_CORE;
}
uint32_t getDeviceCount(void);
uint32_t getDeviceCount();
airtaudio::DeviceInfo getDeviceInfo(uint32_t _device);
enum airtaudio::errorType closeStream(void);
enum airtaudio::errorType startStream(void);
enum airtaudio::errorType stopStream(void);
enum airtaudio::errorType abortStream(void);
enum airtaudio::errorType closeStream();
enum airtaudio::errorType startStream();
enum airtaudio::errorType stopStream();
enum airtaudio::errorType abortStream();
// This function is intended for internal use only. It must be
// public because it is called by the internal callback handler,
// which is not a member of RtAudio. External use of this function
// will most likely produce highly undesireable results!
void callbackEvent(void);
void callbackEvent();
private:
std::vector<airtaudio::DeviceInfo> m_devices;
void saveDeviceInfo(void);
void saveDeviceInfo();
bool probeDeviceOpen(uint32_t _device,
airtaudio::api::StreamMode _mode,
uint32_t _channels,

26
airtaudio/api/Ds.cpp
View File

@@ -11,7 +11,7 @@
#include <airtaudio/Interface.h>
#include <airtaudio/debug.h>
airtaudio::Api* airtaudio::api::Ds::Create(void) {
airtaudio::Api* airtaudio::api::Ds::Create() {
return new airtaudio::api::Ds();
}
@@ -67,7 +67,7 @@ struct DsHandle {
DWORD dsPointerLeadTime[2]; // the number of bytes ahead of the safe pointer to lead by.
HANDLE condition;
DsHandle(void) :
DsHandle() :
drainCounter(0),
internalDrain(false) {
id[0] = 0;
@@ -97,7 +97,7 @@ struct DsDevice {
bool validId[2];
bool found;
std::string name;
DsDevice(void) :
DsDevice() :
found(false) {
validId[0] = false;
validId[1] = false;
@@ -109,7 +109,7 @@ struct DsProbeData {
std::vector<struct DsDevice>* dsDevices;
};
airtaudio::api::Ds::Ds(void) {
airtaudio::api::Ds::Ds() {
// Dsound will run both-threaded. If CoInitialize fails, then just
// accept whatever the mainline chose for a threading model.
m_coInitialized = false;
@@ -119,7 +119,7 @@ airtaudio::api::Ds::Ds(void) {
}
}
airtaudio::api::Ds::~Ds(void) {
airtaudio::api::Ds::~Ds() {
if (m_coInitialized) {
CoUninitialize(); // balanced call.
}
@@ -129,17 +129,17 @@ airtaudio::api::Ds::~Ds(void) {
}
// The DirectSound default output is always the first device.
uint32_t airtaudio::api::Ds::getDefaultOutputDevice(void) {
uint32_t airtaudio::api::Ds::getDefaultOutputDevice() {
return 0;
}
// The DirectSound default input is always the first input device,
// which is the first capture device enumerated.
uint32_t airtaudio::api::Ds::getDefaultInputDevice(void) {
uint32_t airtaudio::api::Ds::getDefaultInputDevice() {
return 0;
}
uint32_t airtaudio::api::Ds::getDeviceCount(void) {
uint32_t airtaudio::api::Ds::getDeviceCount() {
// Set query flag for previously found devices to false, so that we
// can check for any devices that have disappeared.
for (uint32_t i=0; i<dsDevices.size(); i++) {
@@ -848,7 +848,7 @@ error:
return false;
}
enum airtaudio::errorType airtaudio::api::Ds::closeStream(void) {
enum airtaudio::errorType airtaudio::api::Ds::closeStream() {
if (m_stream.state == STREAM_CLOSED) {
ATA_ERROR("airtaudio::api::Ds::closeStream(): no open stream to close!");
return airtaudio::errorWarning;
@@ -895,7 +895,7 @@ enum airtaudio::errorType airtaudio::api::Ds::closeStream(void) {
m_stream.state = STREAM_CLOSED;
}
enum airtaudio::errorType airtaudio::api::Ds::startStream(void) {
enum airtaudio::errorType airtaudio::api::Ds::startStream() {
if (verifyStream() != airtaudio::errorNone) {
return airtaudio::errorFail;
}
@@ -944,7 +944,7 @@ unlock:
return airtaudio::errorNone;
}
enum airtaudio::errorType airtaudio::api::Ds::stopStream(void) {
enum airtaudio::errorType airtaudio::api::Ds::stopStream() {
if (verifyStream() != airtaudio::errorNone) {
return airtaudio::errorFail;
}
@@ -1025,7 +1025,7 @@ unlock:
return airtaudio::errorNone;
}
enum airtaudio::errorType airtaudio::api::Ds::abortStream(void) {
enum airtaudio::errorType airtaudio::api::Ds::abortStream() {
if (verifyStream() != airtaudio::errorNone) {
return airtaudio::errorFail;
}
@@ -1038,7 +1038,7 @@ enum airtaudio::errorType airtaudio::api::Ds::abortStream(void) {
return stopStream();
}
void airtaudio::api::Ds::callbackEvent(void) {
void airtaudio::api::Ds::callbackEvent() {
if (m_stream.state == STREAM_STOPPED || m_stream.state == STREAM_STOPPING) {
Sleep(50); // sleep 50 milliseconds
return;

26
airtaudio/api/Ds.h
View File

@@ -13,27 +13,27 @@ namespace airtaudio {
namespace api {
class Ds: public airtaudio::Api {
public:
static airtaudio::Api* Create(void);
static airtaudio::Api* Create();
public:
Ds(void);
~Ds(void);
airtaudio::api::type getCurrentApi(void) {
Ds();
~Ds();
airtaudio::api::type getCurrentApi() {
return airtaudio::api::WINDOWS_DS;
}
uint32_t getDeviceCount(void);
uint32_t getDefaultOutputDevice(void);
uint32_t getDefaultInputDevice(void);
uint32_t getDeviceCount();
uint32_t getDefaultOutputDevice();
uint32_t getDefaultInputDevice();
airtaudio::DeviceInfo getDeviceInfo(uint32_t _device);
enum airtaudio::errorType closeStream(void);
enum airtaudio::errorType startStream(void);
enum airtaudio::errorType stopStream(void);
enum airtaudio::errorType abortStream(void);
long getStreamLatency(void);
enum airtaudio::errorType closeStream();
enum airtaudio::errorType startStream();
enum airtaudio::errorType stopStream();
enum airtaudio::errorType abortStream();
long getStreamLatency();
// This function is intended for internal use only. It must be
// public because it is called by the internal callback handler,
// which is not a member of RtAudio. External use of this function
// will most likely produce highly undesireable results!
void callbackEvent(void);
void callbackEvent();
private:
bool m_coInitialized;
bool m_buffersRolling;

16
airtaudio/api/Dummy.cpp
View File

@@ -10,39 +10,39 @@
#include <airtaudio/api/Dummy.h>
#include <airtaudio/debug.h>
airtaudio::Api* airtaudio::api::Dummy::Create(void) {
airtaudio::Api* airtaudio::api::Dummy::Create() {
return new airtaudio::api::Dummy();
}
airtaudio::api::Dummy::Dummy(void) {
airtaudio::api::Dummy::Dummy() {
m_errorText = "airtaudio::api::Dummy: This class provides no functionality.";
error(airtaudio::errorWarning);
}
uint32_t airtaudio::api::Dummy::getDeviceCount(void) {
uint32_t airtaudio::api::Dummy::getDeviceCount() {
return 0;
}
rtaudio::DeviceInfo airtaudio::api::Dummy::getDeviceInfo(uint32_t _device) {
(void)_device;
()_device;
rtaudio::DeviceInfo info;
return info;
}
enum airtaudio::errorType airtaudio::api::Dummy::closeStream(void) {
enum airtaudio::errorType airtaudio::api::Dummy::closeStream() {
return airtaudio::errorNone;
}
enum airtaudio::errorType airtaudio::api::Dummy::startStream(void) {
enum airtaudio::errorType airtaudio::api::Dummy::startStream() {
return airtaudio::errorNone;
}
enum airtaudio::errorType airtaudio::api::Dummy::stopStream(void) {
enum airtaudio::errorType airtaudio::api::Dummy::stopStream() {
return airtaudio::errorNone;
}
enum airtaudio::errorType airtaudio::api::Dummy::abortStream(void) {
enum airtaudio::errorType airtaudio::api::Dummy::abortStream() {
return airtaudio::errorNone;
}

16
airtaudio/api/Dummy.h
View File

@@ -15,18 +15,18 @@ namespace airtaudio {
namespace api {
class Dummy: public airtaudio::Api {
public:
static airtaudio::Api* Create(void);
static airtaudio::Api* Create();
public:
Dummy(void);
airtaudio::api::type getCurrentApi(void) {
Dummy();
airtaudio::api::type getCurrentApi() {
return airtaudio::api::RTAUDIO_DUMMY;
}
uint32_t getDeviceCount(void);
uint32_t getDeviceCount();
airtaudio::DeviceInfo getDeviceInfo(uint32_t _device);
enum airtaudio::errorType closeStream(void);
enum airtaudio::errorType startStream(void);
enum airtaudio::errorType stopStream(void);
enum airtaudio::errorType abortStream(void);
enum airtaudio::errorType closeStream();
enum airtaudio::errorType startStream();
enum airtaudio::errorType stopStream();
enum airtaudio::errorType abortStream();
private:
bool probeDeviceOpen(uint32_t _device,
airtaudio::api::StreamMode _mode,

18
airtaudio/api/Jack.cpp
View File

@@ -15,7 +15,7 @@
#include <airtaudio/debug.h>
#include <string.h>
airtaudio::Api* airtaudio::api::Jack::Create(void) {
airtaudio::Api* airtaudio::api::Jack::Create() {
return new airtaudio::api::Jack();
}
@@ -64,7 +64,7 @@ struct JackHandle {
int32_t drainCounter; // Tracks callback counts when draining
bool internalDrain; // Indicates if stop is initiated from callback or not.
JackHandle(void) :
JackHandle() :
client(0),
drainCounter(0),
internalDrain(false) {
@@ -75,17 +75,17 @@ struct JackHandle {
}
};
airtaudio::api::Jack::Jack(void) {
airtaudio::api::Jack::Jack() {
// Nothing to do here.
}
airtaudio::api::Jack::~Jack(void) {
airtaudio::api::Jack::~Jack() {
if (m_stream.state != STREAM_CLOSED) {
closeStream();
}
}
uint32_t airtaudio::api::Jack::getDeviceCount(void) {
uint32_t airtaudio::api::Jack::getDeviceCount() {
// See if we can become a jack client.
jack_options_t options = (jack_options_t) (JackNoStartServer); //JackNullOption;
jack_status_t *status = NULL;
@@ -489,7 +489,7 @@ error:
return false;
}
enum airtaudio::errorType airtaudio::api::Jack::closeStream(void) {
enum airtaudio::errorType airtaudio::api::Jack::closeStream() {
if (m_stream.state == STREAM_CLOSED) {
ATA_ERROR("airtaudio::api::Jack::closeStream(): no open stream to close!");
return airtaudio::errorWarning;
@@ -526,7 +526,7 @@ enum airtaudio::errorType airtaudio::api::Jack::closeStream(void) {
return airtaudio::errorNone;
}
enum airtaudio::errorType airtaudio::api::Jack::startStream(void) {
enum airtaudio::errorType airtaudio::api::Jack::startStream() {
if (verifyStream() != airtaudio::errorNone) {
return airtaudio::errorFail;
}
@@ -597,7 +597,7 @@ unlock:
return airtaudio::errorSystemError;
}
enum airtaudio::errorType airtaudio::api::Jack::stopStream(void) {
enum airtaudio::errorType airtaudio::api::Jack::stopStream() {
if (verifyStream() != airtaudio::errorNone) {
return airtaudio::errorFail;
}
@@ -619,7 +619,7 @@ enum airtaudio::errorType airtaudio::api::Jack::stopStream(void) {
return airtaudio::errorNone;
}
enum airtaudio::errorType airtaudio::api::Jack::abortStream(void) {
enum airtaudio::errorType airtaudio::api::Jack::abortStream() {
if (verifyStream() != airtaudio::errorNone) {
return airtaudio::errorFail;
}

20
airtaudio/api/Jack.h
View File

@@ -13,20 +13,20 @@ namespace airtaudio {
namespace api {
class Jack: public airtaudio::Api {
public:
static airtaudio::Api* Create(void);
static airtaudio::Api* Create();
public:
Jack(void);
~Jack(void);
airtaudio::api::type getCurrentApi(void) {
Jack();
~Jack();
airtaudio::api::type getCurrentApi() {
return airtaudio::api::UNIX_JACK;
}
uint32_t getDeviceCount(void);
uint32_t getDeviceCount();
airtaudio::DeviceInfo getDeviceInfo(uint32_t _device);
enum airtaudio::errorType closeStream(void);
enum airtaudio::errorType startStream(void);
enum airtaudio::errorType stopStream(void);
enum airtaudio::errorType abortStream(void);
long getStreamLatency(void);
enum airtaudio::errorType closeStream();
enum airtaudio::errorType startStream();
enum airtaudio::errorType stopStream();
enum airtaudio::errorType abortStream();
long getStreamLatency();
// This function is intended for internal use only. It must be
// public because it is called by the internal callback handler,
// which is not a member of RtAudio. External use of this function

20
airtaudio/api/Oss.cpp
View File

@@ -19,7 +19,7 @@
#include <errno.h>
#include <math.h>
airtaudio::Api* airtaudio::api::Oss::Create(void) {
airtaudio::Api* airtaudio::api::Oss::Create() {
return new airtaudio::api::Oss();
}
@@ -32,7 +32,7 @@ struct OssHandle {
bool xrun[2];
bool triggered;
std::condition_variable runnable;
OssHandle(void):
OssHandle():
triggered(false) {
id[0] = 0;
id[1] = 0;
@@ -41,17 +41,17 @@ struct OssHandle {
}
};
airtaudio::api::Oss::Oss(void) {
airtaudio::api::Oss::Oss() {
// Nothing to do here.
}
airtaudio::api::Oss::~Oss(void) {
airtaudio::api::Oss::~Oss() {
if (m_stream.state != STREAM_CLOSED) {
closeStream();
}
}
uint32_t airtaudio::api::Oss::getDeviceCount(void) {
uint32_t airtaudio::api::Oss::getDeviceCount() {
int32_t mixerfd = open("/dev/mixer", O_RDWR, 0);
if (mixerfd == -1) {
ATA_ERROR("airtaudio::api::Oss::getDeviceCount: error opening '/dev/mixer'.");
@@ -546,7 +546,7 @@ error:
return false;
}
enum airtaudio::errorType airtaudio::api::Oss::closeStream(void) {
enum airtaudio::errorType airtaudio::api::Oss::closeStream() {
if (m_stream.state == STREAM_CLOSED) {
ATA_ERROR("airtaudio::api::Oss::closeStream(): no open stream to close!");
return airtaudio::errorWarning;
@@ -592,7 +592,7 @@ enum airtaudio::errorType airtaudio::api::Oss::closeStream(void) {
return airtaudio::errorNone;
}
enum airtaudio::errorType airtaudio::api::Oss::startStream(void) {
enum airtaudio::errorType airtaudio::api::Oss::startStream() {
if (verifyStream() != airtaudio::errorNone) {
return airtaudio::errorFail;
}
@@ -609,7 +609,7 @@ enum airtaudio::errorType airtaudio::api::Oss::startStream(void) {
handle->runnable.notify_one();
}
enum airtaudio::errorType airtaudio::api::Oss::stopStream(void) {
enum airtaudio::errorType airtaudio::api::Oss::stopStream() {
if (verifyStream() != airtaudio::errorNone) {
return airtaudio::errorFail;
}
@@ -673,7 +673,7 @@ unlock:
return airtaudio::errorSystemError;
}
enum airtaudio::errorType airtaudio::api::Oss::abortStream(void) {
enum airtaudio::errorType airtaudio::api::Oss::abortStream() {
if (verifyStream() != airtaudio::errorNone) {
return airtaudio::errorFail;
}
@@ -713,7 +713,7 @@ unlock:
return airtaudio::errorSystemError;
}
void airtaudio::api::Oss::callbackEvent(void) {
void airtaudio::api::Oss::callbackEvent() {
OssHandle *handle = (OssHandle *) m_stream.apiHandle;
if (m_stream.state == STREAM_STOPPED) {
std::unique_lock<std::mutex> lck(m_stream.mutex);

20
airtaudio/api/Oss.h
View File

@@ -13,24 +13,24 @@ namespace airtaudio {
namespace api {
class Oss: public airtaudio::Api {
public:
static airtaudio::Api* Create(void);
static airtaudio::Api* Create();
public:
Oss(void);
~Oss(void);
airtaudio::api::type getCurrentApi(void) {
Oss();
~Oss();
airtaudio::api::type getCurrentApi() {
return airtaudio::api::LINUX_OSS;
}
uint32_t getDeviceCount(void);
uint32_t getDeviceCount();
airtaudio::DeviceInfo getDeviceInfo(uint32_t _device);
enum airtaudio::errorType closeStream(void);
enum airtaudio::errorType startStream(void);
enum airtaudio::errorType stopStream(void);
enum airtaudio::errorType abortStream(void);
enum airtaudio::errorType closeStream();
enum airtaudio::errorType startStream();
enum airtaudio::errorType stopStream();
enum airtaudio::errorType abortStream();
// This function is intended for internal use only. It must be
// public because it is called by the internal callback handler,
// which is not a member of RtAudio. External use of this function
// will most likely produce highly undesireable results!
void callbackEvent(void);
void callbackEvent();
private:
bool probeDeviceOpen(uint32_t _device,
airtaudio::api::StreamMode _mode,

18
airtaudio/api/Pulse.cpp
View File

@@ -20,7 +20,7 @@
#include <pulse/simple.h>
#include <cstdio>
airtaudio::Api* airtaudio::api::Pulse::Create(void) {
airtaudio::Api* airtaudio::api::Pulse::Create() {
return new airtaudio::api::Pulse();
}
@@ -53,7 +53,7 @@ struct PulseAudioHandle {
std::thread* thread;
std::condition_variable runnable_cv;
bool runnable;
PulseAudioHandle(void) :
PulseAudioHandle() :
s_play(0),
s_rec(0),
runnable(false) {
@@ -61,13 +61,13 @@ struct PulseAudioHandle {
}
};
airtaudio::api::Pulse::~Pulse(void) {
airtaudio::api::Pulse::~Pulse() {
if (m_stream.state != STREAM_CLOSED) {
closeStream();
}
}
uint32_t airtaudio::api::Pulse::getDeviceCount(void) {
uint32_t airtaudio::api::Pulse::getDeviceCount() {
return 1;
}
@@ -96,7 +96,7 @@ static void pulseaudio_callback(void* _user) {
}
}
enum airtaudio::errorType airtaudio::api::Pulse::closeStream(void) {
enum airtaudio::errorType airtaudio::api::Pulse::closeStream() {
PulseAudioHandle *pah = static_cast<PulseAudioHandle *>(m_stream.apiHandle);
m_stream.callbackInfo.isRunning = false;
if (pah) {
@@ -130,7 +130,7 @@ enum airtaudio::errorType airtaudio::api::Pulse::closeStream(void) {
return airtaudio::errorNone;
}
void airtaudio::api::Pulse::callbackEvent(void) {
void airtaudio::api::Pulse::callbackEvent() {
PulseAudioHandle *pah = static_cast<PulseAudioHandle *>(m_stream.apiHandle);
if (m_stream.state == STREAM_STOPPED) {
std::unique_lock<std::mutex> lck(m_stream.mutex);
@@ -208,7 +208,7 @@ unlock:
return;
}
enum airtaudio::errorType airtaudio::api::Pulse::startStream(void) {
enum airtaudio::errorType airtaudio::api::Pulse::startStream() {
PulseAudioHandle *pah = static_cast<PulseAudioHandle *>(m_stream.apiHandle);
if (m_stream.state == STREAM_CLOSED) {
ATA_ERROR("airtaudio::api::Pulse::startStream(): the stream is not open!");
@@ -226,7 +226,7 @@ enum airtaudio::errorType airtaudio::api::Pulse::startStream(void) {
return airtaudio::errorNone;
}
enum airtaudio::errorType airtaudio::api::Pulse::stopStream(void) {
enum airtaudio::errorType airtaudio::api::Pulse::stopStream() {
PulseAudioHandle *pah = static_cast<PulseAudioHandle *>(m_stream.apiHandle);
if (m_stream.state == STREAM_CLOSED) {
ATA_ERROR("airtaudio::api::Pulse::stopStream(): the stream is not open!");
@@ -251,7 +251,7 @@ enum airtaudio::errorType airtaudio::api::Pulse::stopStream(void) {
return airtaudio::errorNone;
}
enum airtaudio::errorType airtaudio::api::Pulse::abortStream(void) {
enum airtaudio::errorType airtaudio::api::Pulse::abortStream() {
PulseAudioHandle *pah = static_cast<PulseAudioHandle*>(m_stream.apiHandle);
if (m_stream.state == STREAM_CLOSED) {
ATA_ERROR("airtaudio::api::Pulse::abortStream(): the stream is not open!");

20
airtaudio/api/Pulse.h
View File

@@ -13,26 +13,26 @@ namespace airtaudio {
namespace api {
class Pulse: public airtaudio::Api {
public:
static airtaudio::Api* Create(void);
static airtaudio::Api* Create();
public:
~Pulse(void);
airtaudio::api::type getCurrentApi(void) {
~Pulse();
airtaudio::api::type getCurrentApi() {
return airtaudio::api::LINUX_PULSE;
}
uint32_t getDeviceCount(void);
uint32_t getDeviceCount();
airtaudio::DeviceInfo getDeviceInfo(uint32_t _device);
enum airtaudio::errorType closeStream(void);
enum airtaudio::errorType startStream(void);
enum airtaudio::errorType stopStream(void);
enum airtaudio::errorType abortStream(void);
enum airtaudio::errorType closeStream();
enum airtaudio::errorType startStream();
enum airtaudio::errorType stopStream();
enum airtaudio::errorType abortStream();
// This function is intended for internal use only. It must be
// public because it is called by the internal callback handler,
// which is not a member of RtAudio. External use of this function
// will most likely produce highly undesireable results!
void callbackEvent(void);
void callbackEvent();
private:
std::vector<airtaudio::DeviceInfo> m_devices;
void saveDeviceInfo(void);
void saveDeviceInfo();
bool probeDeviceOpen(uint32_t _device,
airtaudio::api::StreamMode _mode,
uint32_t _channels,