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

[DEV] start remove some uneeded element in the airtaudio lib

Browse Source
This commit is contained in:
Edouard DUPIN 2015-02-05 23:31:22 +01:00
parent 6de9bac0fc
commit 3629886590
28 changed files with 353 additions and 860 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

479
airtaudio/Api.cpp
View File

@ -74,29 +74,29 @@ airtaudio::Api::~Api() {
enum airtaudio::errorType airtaudio::Api::openStream(airtaudio::StreamParameters *oParams,
airtaudio::StreamParameters *iParams,
airtaudio::format format,
audio::format format,
uint32_t sampleRate,
uint32_t *bufferFrames,
airtaudio::AirTAudioCallback callback,
airtaudio::StreamOptions *options) {
if (m_stream.state != airtaudio::api::STREAM_CLOSED) {
ATA_ERROR("airtaudio::Api::openStream: a stream is already open!");
ATA_ERROR("a stream is already open!");
return airtaudio::errorInvalidUse;
}
if (oParams && oParams->nChannels < 1) {
ATA_ERROR("airtaudio::Api::openStream: a non-nullptr output StreamParameters structure cannot have an nChannels value less than one.");
ATA_ERROR("a non-nullptr output StreamParameters structure cannot have an nChannels value less than one.");
return airtaudio::errorInvalidUse;
}
if (iParams && iParams->nChannels < 1) {
ATA_ERROR("airtaudio::Api::openStream: a non-nullptr input StreamParameters structure cannot have an nChannels value less than one.");
ATA_ERROR("a non-nullptr input StreamParameters structure cannot have an nChannels value less than one.");
return airtaudio::errorInvalidUse;
}
if (oParams == nullptr && iParams == nullptr) {
ATA_ERROR("airtaudio::Api::openStream: input and output StreamParameters structures are both nullptr!");
ATA_ERROR("input and output StreamParameters structures are both nullptr!");
return airtaudio::errorInvalidUse;
}
if (formatBytes(format) == 0) {
ATA_ERROR("airtaudio::Api::openStream: 'format' parameter value is undefined.");
if (audio::getFormatBytes(format) == 0) {
ATA_ERROR("'format' parameter value is undefined.");
return airtaudio::errorInvalidUse;
}
uint32_t nDevices = getDeviceCount();
@ -104,7 +104,7 @@ enum airtaudio::errorType airtaudio::Api::openStream(airtaudio::StreamParameters
if (oParams) {
oChannels = oParams->nChannels;
if (oParams->deviceId >= nDevices) {
ATA_ERROR("airtaudio::Api::openStream: output device parameter value is invalid.");
ATA_ERROR("output device parameter value is invalid.");
return airtaudio::errorInvalidUse;
}
}
@ -112,7 +112,7 @@ enum airtaudio::errorType airtaudio::Api::openStream(airtaudio::StreamParameters
if (iParams) {
iChannels = iParams->nChannels;
if (iParams->deviceId >= nDevices) {
ATA_ERROR("airtaudio::Api::openStream: input device parameter value is invalid.");
ATA_ERROR("input device parameter value is invalid.");
return airtaudio::errorInvalidUse;
}
}
@ -177,7 +177,7 @@ bool airtaudio::Api::probeDeviceOpen(uint32_t /*device*/,
uint32_t /*channels*/,
uint32_t /*firstChannel*/,
uint32_t /*sampleRate*/,
airtaudio::format /*format*/,
audio::format /*format*/,
uint32_t * /*bufferSize*/,
airtaudio::StreamOptions * /*options*/) {
// MUST be implemented in subclasses!
@ -241,7 +241,7 @@ uint32_t airtaudio::Api::getStreamSampleRate() {
enum airtaudio::errorType airtaudio::Api::verifyStream() {
if (m_stream.state == airtaudio::api::STREAM_CLOSED) {
ATA_ERROR("airtaudio::Api:: a stream is not open!");
ATA_ERROR("a stream is not open!");
return airtaudio::errorInvalidUse;
}
return airtaudio::errorNone;
@ -253,7 +253,7 @@ void airtaudio::Api::clearStreamInfo() {
m_stream.sampleRate = 0;
m_stream.bufferSize = 0;
m_stream.nBuffers = 0;
m_stream.userFormat = 0;
m_stream.userFormat = audio::format_unknow;
m_stream.userInterleaved = true;
m_stream.streamTime = 0.0;
m_stream.apiHandle = 0;
@ -268,38 +268,19 @@ void airtaudio::Api::clearStreamInfo() {
m_stream.nUserChannels[iii] = 0;
m_stream.nDeviceChannels[iii] = 0;
m_stream.channelOffset[iii] = 0;
m_stream.deviceFormat[iii] = 0;
m_stream.deviceFormat[iii] = audio::format_unknow;
m_stream.latency[iii] = 0;
m_stream.userBuffer[iii] = 0;
m_stream.convertInfo[iii].channels = 0;
m_stream.convertInfo[iii].inJump = 0;
m_stream.convertInfo[iii].outJump = 0;
m_stream.convertInfo[iii].inFormat = 0;
m_stream.convertInfo[iii].outFormat = 0;
m_stream.convertInfo[iii].inFormat = audio::format_unknow;
m_stream.convertInfo[iii].outFormat = audio::format_unknow;
m_stream.convertInfo[iii].inOffset.clear();
m_stream.convertInfo[iii].outOffset.clear();
}
}
uint32_t airtaudio::Api::formatBytes(airtaudio::format _format)
{
if (_format == airtaudio::SINT16) {
return 2;
} else if ( _format == airtaudio::SINT32
|| _format == airtaudio::FLOAT32) {
return 4;
} else if (_format == airtaudio::FLOAT64) {
return 8;
} else if (_format == airtaudio::SINT24) {
return 3;
} else if (_format == airtaudio::SINT8) {
return 1;
}
ATA_ERROR("airtaudio::Api::formatBytes: undefined format.");
// TODO : airtaudio::errorWarning;
return 0;
}
void airtaudio::Api::setConvertInfo(airtaudio::api::StreamMode _mode, uint32_t _firstChannel) {
if (_mode == airtaudio::api::INPUT) { // convert device to user buffer
m_stream.convertInfo[_mode].inJump = m_stream.nDeviceChannels[1];
@ -386,431 +367,19 @@ void airtaudio::Api::convertBuffer(char *_outBuffer, char *_inBuffer, airtaudio:
if ( _outBuffer == m_stream.deviceBuffer
&& m_stream.mode == airtaudio::api::DUPLEX
&& m_stream.nDeviceChannels[0] < m_stream.nDeviceChannels[1]) {
memset(_outBuffer, 0, m_stream.bufferSize * _info.outJump * formatBytes(_info.outFormat));
memset(_outBuffer, 0, m_stream.bufferSize * _info.outJump * audio::getFormatBytes(_info.outFormat));
}
int32_t jjj;
if (_info.outFormat == airtaudio::FLOAT64) {
double scale;
double *out = (double *)_outBuffer;
if (_info.inFormat == airtaudio::SINT8) {
signed char *in = (signed char *)_inBuffer;
scale = 1.0 / 127.5;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (double) in[_info.inOffset[jjj]];
out[_info.outOffset[jjj]] += 0.5;
out[_info.outOffset[jjj]] *= scale;
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::SINT16) {
int16_t *in = (int16_t *)_inBuffer;
scale = 1.0 / 32767.5;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (double) in[_info.inOffset[jjj]];
out[_info.outOffset[jjj]] += 0.5;
out[_info.outOffset[jjj]] *= scale;
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::SINT24) {
int24_t *in = (int24_t *)_inBuffer;
scale = 1.0 / 8388607.5;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (double) (in[_info.inOffset[jjj]].asInt());
out[_info.outOffset[jjj]] += 0.5;
out[_info.outOffset[jjj]] *= scale;
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::SINT32) {
int32_t *in = (int32_t *)_inBuffer;
scale = 1.0 / 2147483647.5;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (double) in[_info.inOffset[jjj]];
out[_info.outOffset[jjj]] += 0.5;
out[_info.outOffset[jjj]] *= scale;
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::FLOAT32) {
float *in = (float *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (double) in[_info.inOffset[jjj]];
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::FLOAT64) {
// Channel compensation and/or (de)interleaving only.
double *in = (double *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = in[_info.inOffset[jjj]];
}
in += _info.inJump;
out += _info.outJump;
}
}
}
else if (_info.outFormat == airtaudio::FLOAT32) {
float scale;
float *out = (float *)_outBuffer;
if (_info.inFormat == airtaudio::SINT8) {
signed char *in = (signed char *)_inBuffer;
scale = (float) (1.0 / 127.5);
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (float) in[_info.inOffset[jjj]];
out[_info.outOffset[jjj]] += 0.5;
out[_info.outOffset[jjj]] *= scale;
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::SINT16) {
int16_t *in = (int16_t *)_inBuffer;
scale = (float) (1.0 / 32767.5);
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (float) in[_info.inOffset[jjj]];
out[_info.outOffset[jjj]] += 0.5;
out[_info.outOffset[jjj]] *= scale;
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::SINT24) {
int24_t *in = (int24_t *)_inBuffer;
scale = (float) (1.0 / 8388607.5);
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (float) (in[_info.inOffset[jjj]].asInt());
out[_info.outOffset[jjj]] += 0.5;
out[_info.outOffset[jjj]] *= scale;
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::SINT32) {
int32_t *in = (int32_t *)_inBuffer;
scale = (float) (1.0 / 2147483647.5);
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (float) in[_info.inOffset[jjj]];
out[_info.outOffset[jjj]] += 0.5;
out[_info.outOffset[jjj]] *= scale;
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::FLOAT32) {
// Channel compensation and/or (de)interleaving only.
float *in = (float *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = in[_info.inOffset[jjj]];
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::FLOAT64) {
double *in = (double *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (float) in[_info.inOffset[jjj]];
}
in += _info.inJump;
out += _info.outJump;
}
}
}
else if (_info.outFormat == airtaudio::SINT32) {
int32_t *out = (int32_t *)_outBuffer;
if (_info.inFormat == airtaudio::SINT8) {
signed char *in = (signed char *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (int32_t) in[_info.inOffset[jjj]];
out[_info.outOffset[jjj]] <<= 24;
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::SINT16) {
int16_t *in = (int16_t *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (int32_t) in[_info.inOffset[jjj]];
out[_info.outOffset[jjj]] <<= 16;
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::SINT24) {
int24_t *in = (int24_t *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (int32_t) in[_info.inOffset[jjj]].asInt();
out[_info.outOffset[jjj]] <<= 8;
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::SINT32) {
// Channel compensation and/or (de)interleaving only.
int32_t *in = (int32_t *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = in[_info.inOffset[jjj]];
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::FLOAT32) {
float *in = (float *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (int32_t) (in[_info.inOffset[jjj]] * 2147483647.5 - 0.5);
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::FLOAT64) {
double *in = (double *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (int32_t) (in[_info.inOffset[jjj]] * 2147483647.5 - 0.5);
}
in += _info.inJump;
out += _info.outJump;
}
}
}
else if (_info.outFormat == airtaudio::SINT24) {
int24_t *out = (int24_t *)_outBuffer;
if (_info.inFormat == airtaudio::SINT8) {
signed char *in = (signed char *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (int32_t) (in[_info.inOffset[jjj]] << 16);
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::SINT16) {
int16_t *in = (int16_t *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (int32_t) (in[_info.inOffset[jjj]] << 8);
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::SINT24) {
// Channel compensation and/or (de)interleaving only.
int24_t *in = (int24_t *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = in[_info.inOffset[jjj]];
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::SINT32) {
int32_t *in = (int32_t *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (int32_t) (in[_info.inOffset[jjj]] >> 8);
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::FLOAT32) {
float *in = (float *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (int32_t) (in[_info.inOffset[jjj]] * 8388607.5 - 0.5);
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::FLOAT64) {
double *in = (double *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (int32_t) (in[_info.inOffset[jjj]] * 8388607.5 - 0.5);
}
in += _info.inJump;
out += _info.outJump;
}
}
}
else if (_info.outFormat == airtaudio::SINT16) {
int16_t *out = (int16_t *)_outBuffer;
if (_info.inFormat == airtaudio::SINT8) {
signed char *in = (signed char *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (int16_t) in[_info.inOffset[jjj]];
out[_info.outOffset[jjj]] <<= 8;
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::SINT16) {
// Channel compensation and/or (de)interleaving only.
int16_t *in = (int16_t *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = in[_info.inOffset[jjj]];
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::SINT24) {
int24_t *in = (int24_t *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (int16_t) (in[_info.inOffset[jjj]].asInt() >> 8);
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::SINT32) {
int32_t *in = (int32_t *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (int16_t) ((in[_info.inOffset[jjj]] >> 16) & 0x0000ffff);
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::FLOAT32) {
float *in = (float *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (int16_t) (in[_info.inOffset[jjj]] * 32767.5 - 0.5);
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::FLOAT64) {
double *in = (double *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (int16_t) (in[_info.inOffset[jjj]] * 32767.5 - 0.5);
}
in += _info.inJump;
out += _info.outJump;
}
}
}
else if (_info.outFormat == airtaudio::SINT8) {
signed char *out = (signed char *)_outBuffer;
if (_info.inFormat == airtaudio::SINT8) {
// Channel compensation and/or (de)interleaving only.
signed char *in = (signed char *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = in[_info.inOffset[jjj]];
}
in += _info.inJump;
out += _info.outJump;
}
}
if (_info.inFormat == airtaudio::SINT16) {
int16_t *in = (int16_t *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (signed char) ((in[_info.inOffset[jjj]] >> 8) & 0x00ff);
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::SINT24) {
int24_t *in = (int24_t *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (signed char) (in[_info.inOffset[jjj]].asInt() >> 16);
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::SINT32) {
int32_t *in = (int32_t *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (signed char) ((in[_info.inOffset[jjj]] >> 24) & 0x000000ff);
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::FLOAT32) {
float *in = (float *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (signed char) (in[_info.inOffset[jjj]] * 127.5 - 0.5);
}
in += _info.inJump;
out += _info.outJump;
}
}
else if (_info.inFormat == airtaudio::FLOAT64) {
double *in = (double *)_inBuffer;
for (uint32_t iii=0; iii<m_stream.bufferSize; ++iii) {
for (jjj=0; jjj<_info.channels; ++jjj) {
out[_info.outOffset[jjj]] = (signed char) (in[_info.inOffset[jjj]] * 127.5 - 0.5);
}
in += _info.inJump;
out += _info.outJump;
}
}
if (_info.outFormat != _info.outFormat) {
ATA_CRITICAL("not manage anymore the format changing ...");
}
}
void airtaudio::Api::byteSwapBuffer(char *_buffer, uint32_t _samples, airtaudio::format _format) {
void airtaudio::Api::byteSwapBuffer(char *_buffer, uint32_t _samples, audio::format _format) {
char val;
char *ptr;
ptr = _buffer;
if (_format == airtaudio::SINT16) {
if (_format == audio::format_int16) {
for (uint32_t iii=0; iii<_samples; ++iii) {
// Swap 1st and 2nd bytes.
val = *(ptr);
@ -820,8 +389,8 @@ void airtaudio::Api::byteSwapBuffer(char *_buffer, uint32_t _samples, airtaudio:
// Increment 2 bytes.
ptr += 2;
}
} else if ( _format == airtaudio::SINT32
|| _format == airtaudio::FLOAT32) {
} else if ( _format == audio::format_int32
|| _format == audio::format_float) {
for (uint32_t iii=0; iii<_samples; ++iii) {
// Swap 1st and 4th bytes.
val = *(ptr);
@ -837,7 +406,7 @@ void airtaudio::Api::byteSwapBuffer(char *_buffer, uint32_t _samples, airtaudio:
// Increment 3 more bytes.
ptr += 3;
}
} else if (_format == airtaudio::SINT24) {
} else if (_format == audio::format_int24) {
for (uint32_t iii=0; iii<_samples; ++iii) {
// Swap 1st and 3rd bytes.
val = *(ptr);
@ -847,7 +416,7 @@ void airtaudio::Api::byteSwapBuffer(char *_buffer, uint32_t _samples, airtaudio:
// Increment 2 more bytes.
ptr += 2;
}
} else if (_format == airtaudio::FLOAT64) {
} else if (_format == audio::format_double) {
for (uint32_t iii=0; iii<_samples; ++iii) {
// Swap 1st and 8th bytes
val = *(ptr);

15
airtaudio/Api.h
View File

@ -56,7 +56,7 @@ namespace airtaudio {
struct ConvertInfo {
int32_t channels;
int32_t inJump, outJump;
airtaudio::format inFormat, outFormat;
audio::format inFormat, outFormat;
std::vector<int> inOffset;
std::vector<int> outOffset;
};
@ -81,8 +81,8 @@ namespace airtaudio {
uint32_t nDeviceChannels[2]; // Playback and record channels, respectively.
uint32_t channelOffset[2]; // Playback and record, respectively.
uint64_t latency[2]; // Playback and record, respectively.
airtaudio::format userFormat;
airtaudio::format deviceFormat[2]; // Playback and record, respectively.
audio::format userFormat;
audio::format deviceFormat[2]; // Playback and record, respectively.
std::mutex mutex;
airtaudio::CallbackInfo callbackInfo;
airtaudio::api::ConvertInfo convertInfo[2];
@ -122,7 +122,7 @@ namespace airtaudio {
virtual uint32_t getDefaultOutputDevice();
enum airtaudio::errorType openStream(airtaudio::StreamParameters *_outputParameters,
airtaudio::StreamParameters *_inputParameters,
airtaudio::format _format,
audio::format _format,
uint32_t _sampleRate,
uint32_t *_bufferFrames,
airtaudio::AirTAudioCallback _callback,
@ -156,7 +156,7 @@ namespace airtaudio {
uint32_t _channels,
uint32_t _firstChannel,
uint32_t _sampleRate,
airtaudio::format _format,
audio::format _format,
uint32_t *_bufferSize,
airtaudio::StreamOptions *_options);
@ -178,10 +178,7 @@ namespace airtaudio {
void convertBuffer(char *_outBuffer, char *_inBuffer, airtaudio::api::ConvertInfo& _info);
//! Protected common method used to perform byte-swapping on buffers.
void byteSwapBuffer(char *_buffer, uint32_t _samples, airtaudio::format _format);
//! Protected common method that returns the number of bytes for a given format.
uint32_t formatBytes(airtaudio::format _format);
void byteSwapBuffer(char *_buffer, uint32_t _samples, audio::format _format);
//! Protected common method that sets up the parameters for buffer conversion.
void setConvertInfo(airtaudio::api::StreamMode _mode, uint32_t _firstChannel);

4
airtaudio/DeviceInfo.h
View File

@ -23,7 +23,7 @@ namespace airtaudio {
bool isDefaultOutput; //!< true if this is the default output device.
bool isDefaultInput; //!< true if this is the default input device.
std::vector<uint32_t> sampleRates; //!< Supported sample rates (queried from list of standard rates).
airtaudio::format nativeFormats; //!< Bit mask of supported data formats.
std::vector<audio::format> nativeFormats; //!< Bit mask of supported data formats.
// Default constructor.
DeviceInfo() :
probed(false),
@ -32,7 +32,7 @@ namespace airtaudio {
duplexChannels(0),
isDefaultOutput(false),
isDefaultInput(false),
nativeFormats(0) {}
nativeFormats() {}
};
};

2
airtaudio/Interface.cpp
View File

@ -147,7 +147,7 @@ airtaudio::Interface::~Interface() {
enum airtaudio::errorType airtaudio::Interface::openStream(
airtaudio::StreamParameters* _outputParameters,
airtaudio::StreamParameters* _inputParameters,
airtaudio::format _format,
audio::format _format,
uint32_t _sampleRate,
uint32_t* _bufferFrames,
airtaudio::AirTAudioCallback _callback,

4
airtaudio/Interface.h
View File

@ -164,7 +164,7 @@ namespace airtaudio {
* and starting channel number. For output-only streams, this
* argument should be nullptr. The device ID is an index value between
* 0 and getDeviceCount() - 1.
* @param _format An airtaudio::format specifying the desired sample data format.
* @param _format An audio::format specifying the desired sample data format.
* @param _sampleRate The desired sample rate (sample frames per second).
* @param *_bufferFrames A pointer to a value indicating the desired
* internal buffer size in sample frames. The actual value
@ -187,7 +187,7 @@ namespace airtaudio {
*/
enum airtaudio::errorType openStream(airtaudio::StreamParameters *_outputParameters,
airtaudio::StreamParameters *_inputParameters,
airtaudio::format _format,
audio::format _format,
uint32_t _sampleRate,
uint32_t *_bufferFrames,
airtaudio::AirTAudioCallback _callback,

86
airtaudio/api/Alsa.cpp
View File

@ -308,33 +308,33 @@ probeParameters:
}
// Probe the supported data formats ... we don't care about endian-ness just yet
snd_pcm_format_t format;
info.nativeFormats = 0;
info.nativeFormats.clear();
format = SND_PCM_FORMAT_S8;
if (snd_pcm_hw_params_test_format(phandle, params, format) == 0) {
info.nativeFormats |= airtaudio::SINT8;
info.nativeFormats.push_back(audio::format_int8);
}
format = SND_PCM_FORMAT_S16;
if (snd_pcm_hw_params_test_format(phandle, params, format) == 0) {
info.nativeFormats |= airtaudio::SINT16;
info.nativeFormats.push_back(audio::format_int16);
}
format = SND_PCM_FORMAT_S24;
if (snd_pcm_hw_params_test_format(phandle, params, format) == 0) {
info.nativeFormats |= airtaudio::SINT24;
info.nativeFormats.push_back(audio::format_int24);
}
format = SND_PCM_FORMAT_S32;
if (snd_pcm_hw_params_test_format(phandle, params, format) == 0) {
info.nativeFormats |= airtaudio::SINT32;
info.nativeFormats.push_back(audio::format_int32);
}
format = SND_PCM_FORMAT_FLOAT;
if (snd_pcm_hw_params_test_format(phandle, params, format) == 0) {
info.nativeFormats |= airtaudio::FLOAT32;
info.nativeFormats.push_back(audio::format_float);
}
format = SND_PCM_FORMAT_FLOAT64;
if (snd_pcm_hw_params_test_format(phandle, params, format) == 0) {
info.nativeFormats |= airtaudio::FLOAT64;
info.nativeFormats.push_back(audio::format_double);
}
// Check that we have at least one supported format
if (info.nativeFormats == 0) {
if (info.nativeFormats.size() == 0) {
ATA_ERROR("airtaudio::api::Alsa::getDeviceInfo: pcm device (" << name << ") data format not supported by RtAudio.");
// TODO : Return airtaudio::errorWarning;
return info;
@ -366,7 +366,7 @@ bool airtaudio::api::Alsa::probeDeviceOpen(uint32_t _device,
uint32_t _channels,
uint32_t _firstChannel,
uint32_t _sampleRate,
airtaudio::format _format,
audio::format _format,
uint32_t *_bufferSize,
airtaudio::StreamOptions *_options) {
// I'm not using the "plug" interface ... too much inconsistent behavior.
@ -487,60 +487,28 @@ foundDevice:
// Determine how to set the device format.
m_stream.userFormat = _format;
snd_pcm_format_t deviceFormat = SND_PCM_FORMAT_UNKNOWN;
if (_format == airtaudio::SINT8) {
if (_format == audio::format_int8) {
deviceFormat = SND_PCM_FORMAT_S8;
} else if (_format == airtaudio::SINT16) {
} else if (_format == audio::format_int16) {
deviceFormat = SND_PCM_FORMAT_S16;
} else if (_format == airtaudio::SINT24) {
} else if (_format == audio::format_int24) {
deviceFormat = SND_PCM_FORMAT_S24;
} else if (_format == airtaudio::SINT32) {
} else if (_format == audio::format_int32) {
deviceFormat = SND_PCM_FORMAT_S32;
} else if (_format == airtaudio::FLOAT32) {
} else if (_format == audio::format_float) {
deviceFormat = SND_PCM_FORMAT_FLOAT;
} else if (_format == airtaudio::FLOAT64) {
} else if (_format == audio::format_double) {
deviceFormat = SND_PCM_FORMAT_FLOAT64;
}
if (snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat) == 0) {
m_stream.deviceFormat[_mode] = _format;
goto setFormat;
} else {
// If we get here, no supported format was found.
snd_pcm_close(phandle);
ATA_ERROR("pcm device " << _device << " data format not supported: " << _format);
// TODO : display list of all supported format ..
return false;
}
// The user requested format is not natively supported by the device.
deviceFormat = SND_PCM_FORMAT_FLOAT64;
if (snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat) == 0) {
m_stream.deviceFormat[_mode] = airtaudio::FLOAT64;
goto setFormat;
}
deviceFormat = SND_PCM_FORMAT_FLOAT;
if (snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat) == 0) {
m_stream.deviceFormat[_mode] = airtaudio::FLOAT32;
goto setFormat;
}
deviceFormat = SND_PCM_FORMAT_S32;
if (snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat) == 0) {
m_stream.deviceFormat[_mode] = airtaudio::SINT32;
goto setFormat;
}
deviceFormat = SND_PCM_FORMAT_S24;
if (snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat) == 0) {
m_stream.deviceFormat[_mode] = airtaudio::SINT24;
goto setFormat;
}
deviceFormat = SND_PCM_FORMAT_S16;
if (snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat) == 0) {
m_stream.deviceFormat[_mode] = airtaudio::SINT16;
goto setFormat;
}
deviceFormat = SND_PCM_FORMAT_S8;
if (snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat) == 0) {
m_stream.deviceFormat[_mode] = airtaudio::SINT8;
goto setFormat;
}
// If we get here, no supported format was found.
snd_pcm_close(phandle);
ATA_ERROR("airtaudio::api::Alsa::probeDeviceOpen: pcm device " << _device << " data format not supported by RtAudio.");
return false;
setFormat:
result = snd_pcm_hw_params_set_format(phandle, hw_params, deviceFormat);
if (result < 0) {
snd_pcm_close(phandle);
@ -683,7 +651,7 @@ setFormat:
phandle = 0;
// Allocate necessary internal buffers.
uint64_t bufferBytes;
bufferBytes = m_stream.nUserChannels[_mode] * *_bufferSize * formatBytes(m_stream.userFormat);
bufferBytes = m_stream.nUserChannels[_mode] * *_bufferSize * audio::getFormatBytes(m_stream.userFormat);
m_stream.userBuffer[_mode] = (char *) calloc(bufferBytes, 1);
if (m_stream.userBuffer[_mode] == nullptr) {
ATA_ERROR("airtaudio::api::Alsa::probeDeviceOpen: error allocating user buffer memory.");
@ -691,10 +659,10 @@ setFormat:
}
if (m_stream.doConvertBuffer[_mode]) {
bool makeBuffer = true;
bufferBytes = m_stream.nDeviceChannels[_mode] * formatBytes(m_stream.deviceFormat[_mode]);
bufferBytes = m_stream.nDeviceChannels[_mode] * audio::getFormatBytes(m_stream.deviceFormat[_mode]);
if (_mode == INPUT) {
if (m_stream.mode == OUTPUT && m_stream.deviceBuffer) {
uint64_t bytesOut = m_stream.nDeviceChannels[0] * formatBytes(m_stream.deviceFormat[0]);
uint64_t bytesOut = m_stream.nDeviceChannels[0] * audio::getFormatBytes(m_stream.deviceFormat[0]);
if (bufferBytes <= bytesOut) {
makeBuffer = false;
}
@ -1001,7 +969,7 @@ void airtaudio::api::Alsa::callbackEvent() {
int32_t channels;
snd_pcm_t **handle;
snd_pcm_sframes_t frames;
airtaudio::format format;
audio::format format;
handle = (snd_pcm_t **) apiInfo->handles;
if ( m_stream.mode == airtaudio::api::INPUT
|| m_stream.mode == airtaudio::api::DUPLEX) {
@ -1020,7 +988,7 @@ void airtaudio::api::Alsa::callbackEvent() {
result = snd_pcm_readi(handle[1], buffer, m_stream.bufferSize);
} else {
void *bufs[channels];
size_t offset = m_stream.bufferSize * formatBytes(format);
size_t offset = m_stream.bufferSize * audio::getFormatBytes(format);
for (int32_t i=0; i<channels; i++)
bufs[i] = (void *) (buffer + (i * offset));
result = snd_pcm_readn(handle[1], bufs, m_stream.bufferSize);
@ -1082,7 +1050,7 @@ tryOutput:
result = snd_pcm_writei(handle[0], buffer, m_stream.bufferSize);
} else {
void *bufs[channels];
size_t offset = m_stream.bufferSize * formatBytes(format);
size_t offset = m_stream.bufferSize * audio::getFormatBytes(format);
for (int32_t i=0; i<channels; i++) {
bufs[i] = (void *) (buffer + (i * offset));
}

2
airtaudio/api/Alsa.h
View File

@ -39,7 +39,7 @@ namespace airtaudio {
uint32_t _channels,
uint32_t _firstChannel,
uint32_t _sampleRate,
airtaudio::format _format,
audio::format _format,
uint32_t *_bufferSize,
airtaudio::StreamOptions *_options);
};

20
airtaudio/api/Android.cpp
View File

@ -56,23 +56,7 @@ airtaudio::api::Android::Android() {
tmp.isDefaultInput = true;
tmp.duplexChannels = etk::string_to_int32_t(listProperty[3]);
}
std::vector<std::string> listFormat = etk::split(listProperty[4], ',');
tmp.nativeFormats = 0;
for(size_t fff=0; fff<listFormat.size(); ++fff) {
if (listFormat[fff] == "float") {
tmp.nativeFormats |= FLOAT32;
} else if (listFormat[fff] == "double") {
tmp.nativeFormats |= FLOAT64;
} else if (listFormat[fff] == "s32") {
tmp.nativeFormats |= SINT32;
} else if (listFormat[fff] == "s24") {
tmp.nativeFormats |= SINT24;
} else if (listFormat[fff] == "s16") {
tmp.nativeFormats |= SINT16;
} else if (listFormat[fff] == "s8") {
tmp.nativeFormats |= SINT8;
}
}
tmp.nativeFormats = audio::getListFormatFromString(listProperty[4]);
m_devices.push_back(tmp);
}
ATA_INFO("Create Android interface (end)");
@ -162,7 +146,7 @@ bool airtaudio::api::Android::probeDeviceOpen(uint32_t _device,
uint32_t _channels,
uint32_t _firstChannel,
uint32_t _sampleRate,
airtaudio::format _format,
audio::format _format,
uint32_t *_bufferSize,
airtaudio::StreamOptions *_options) {
ATA_INFO("Probe : device=" << _device << " channels=" << _channels << " firstChannel=" << _firstChannel << " sampleRate=" << _sampleRate);

2
airtaudio/api/Android.h
View File

@ -37,7 +37,7 @@ namespace airtaudio {
uint32_t _channels,
uint32_t _firstChannel,
uint32_t _sampleRate,
airtaudio::format _format,
audio::format _format,
uint32_t *_bufferSize,
airtaudio::StreamOptions *_options);
private:

94
airtaudio/api/Asio.cpp
View File

@ -73,7 +73,7 @@ airtaudio::api::Asio::Asio() {
m_coInitialized = false;
HRESULT hr = CoInitialize(nullptr);
if (FAILED(hr)) {
ATA_ERROR("airtaudio::api::Asio::ASIO requires a single-threaded appartment. Call CoInitializeEx(0,COINIT_APARTMENTTHREADED)");
ATA_ERROR("requires a single-threaded appartment. Call CoInitializeEx(0,COINIT_APARTMENTTHREADED)");
}
m_coInitialized = true;
drivers.removeCurrentDriver();
@ -101,17 +101,17 @@ rtaudio::DeviceInfo airtaudio::api::Asio::getDeviceInfo(uint32_t _device) {
// Get device ID
uint32_t nDevices = getDeviceCount();
if (nDevices == 0) {
ATA_ERROR("airtaudio::api::Asio::getDeviceInfo: no devices found!");
ATA_ERROR("no devices found!");
return info;
}
if (_device >= nDevices) {
ATA_ERROR("airtaudio::api::Asio::getDeviceInfo: device ID is invalid!");
ATA_ERROR("device ID is invalid!");
return info;
}
// If a stream is already open, we cannot probe other devices. Thus, use the saved results.
if (m_stream.state != STREAM_CLOSED) {
if (_device >= m_devices.size()) {
ATA_ERROR("airtaudio::api::Asio::getDeviceInfo: device ID was not present before stream was opened.");
ATA_ERROR("device ID was not present before stream was opened.");
return info;
}
return m_devices[ _device ];
@ -119,17 +119,17 @@ rtaudio::DeviceInfo airtaudio::api::Asio::getDeviceInfo(uint32_t _device) {
char driverName[32];
ASIOError result = drivers.asioGetDriverName((int) _device, driverName, 32);
if (result != ASE_OK) {
ATA_ERROR("airtaudio::api::Asio::getDeviceInfo: unable to get driver name (" << getAsioErrorString(result) << ").");
ATA_ERROR("unable to get driver name (" << getAsioErrorString(result) << ").");
return info;
}
info.name = driverName;
if (!drivers.loadDriver(driverName)) {
ATA_ERROR("airtaudio::api::Asio::getDeviceInfo: unable to load driver (" << driverName << ").");
ATA_ERROR("unable to load driver (" << driverName << ").");
return info;
}
result = ASIOInit(&driverInfo);
if (result != ASE_OK) {
ATA_ERROR("airtaudio::api::Asio::getDeviceInfo: error (" << getAsioErrorString(result) << ") initializing driver (" << driverName << ").");
ATA_ERROR("error (" << getAsioErrorString(result) << ") initializing driver (" << driverName << ").");
return info;
}
// Determine the device channel information.
@ -137,7 +137,7 @@ rtaudio::DeviceInfo airtaudio::api::Asio::getDeviceInfo(uint32_t _device) {
result = ASIOGetChannels(&inputChannels, &outputChannels);
if (result != ASE_OK) {
drivers.removeCurrentDriver();
ATA_ERROR("airtaudio::api::Asio::getDeviceInfo: error (" << getAsioErrorString(result) << ") getting channel count (" << driverName << ").");
ATA_ERROR("error (" << getAsioErrorString(result) << ") getting channel count (" << driverName << ").");
return info;
}
info.outputChannels = outputChannels;
@ -163,25 +163,25 @@ rtaudio::DeviceInfo airtaudio::api::Asio::getDeviceInfo(uint32_t _device) {
result = ASIOGetChannelInfo(&channelInfo);
if (result != ASE_OK) {
drivers.removeCurrentDriver();
ATA_ERROR("airtaudio::api::Asio::getDeviceInfo: error (" << getAsioErrorString(result) << ") getting driver channel info (" << driverName << ").");
ATA_ERROR("error (" << getAsioErrorString(result) << ") getting driver channel info (" << driverName << ").");
return info;
}
info.nativeFormats = 0;
info.nativeFormats.clear();
if ( channelInfo.type == ASIOSTInt16MSB
|| channelInfo.type == ASIOSTInt16LSB) {
info.nativeFormats |= SINT16;
info.nativeFormats.push_back(audio::format_int16);
} else if ( channelInfo.type == ASIOSTInt32MSB
|| channelInfo.type == ASIOSTInt32LSB) {
info.nativeFormats |= SINT32;
info.nativeFormats.push_back(audio::format_int32);
} else if ( channelInfo.type == ASIOSTFloat32MSB
|| channelInfo.type == ASIOSTFloat32LSB) {
info.nativeFormats |= FLOAT32;
info.nativeFormats.push_back(audio::format_float);
} else if ( channelInfo.type == ASIOSTFloat64MSB
|| channelInfo.type == ASIOSTFloat64LSB) {
info.nativeFormats |= FLOAT64;
info.nativeFormats.push_back(audio::format_double);
} else if ( channelInfo.type == ASIOSTInt24MSB
|| channelInfo.type == ASIOSTInt24LSB) {
info.nativeFormats |= SINT24;
info.nativeFormats.push_back(audio::format_int24);
}
if (info.outputChannels > 0){
if (getDefaultOutputDevice() == _device) {
@ -217,20 +217,20 @@ bool airtaudio::api::Asio::probeDeviceOpen(uint32_t _device,
uint32_t _channels,
uint32_t _firstChannel,
uint32_t _sampleRate,
airtaudio::format _format,
audio::format _format,
uint32_t* _bufferSize,
airtaudio::StreamOptions *_options) {
// For ASIO, a duplex stream MUST use the same driver.
if ( _mode == INPUT
&& m_stream.mode == OUTPUT
&& m_stream.device[0] != _device) {
ATA_ERROR("airtaudio::api::Asio::probeDeviceOpen: an ASIO duplex stream must use the same device for input and output!");
ATA_ERROR("an ASIO duplex stream must use the same device for input and output!");
return false;
}
char driverName[32];
ASIOError result = drivers.asioGetDriverName((int) _device, driverName, 32);
if (result != ASE_OK) {
ATA_ERROR("airtaudio::api::Asio::probeDeviceOpen: unable to get driver name (" << getAsioErrorString(result) << ").");
ATA_ERROR("unable to get driver name (" << getAsioErrorString(result) << ").");
return false;
}
// Only load the driver once for duplex stream.
@ -242,12 +242,12 @@ bool airtaudio::api::Asio::probeDeviceOpen(uint32_t _device,
// save the results for use by getDeviceInfo().
this->saveDeviceInfo();
if (!drivers.loadDriver(driverName)) {
ATA_ERROR("airtaudio::api::Asio::probeDeviceOpen: unable to load driver (" << driverName << ").");
ATA_ERROR("unable to load driver (" << driverName << ").");
return false;
}
result = ASIOInit(&driverInfo);
if (result != ASE_OK) {
ATA_ERROR("airtaudio::api::Asio::probeDeviceOpen: error (" << getAsioErrorString(result) << ") initializing driver (" << driverName << ").");
ATA_ERROR("error (" << getAsioErrorString(result) << ") initializing driver (" << driverName << ").");
return false;
}
}
@ -256,7 +256,7 @@ bool airtaudio::api::Asio::probeDeviceOpen(uint32_t _device,
result = ASIOGetChannels(&inputChannels, &outputChannels);
if (result != ASE_OK) {
drivers.removeCurrentDriver();
ATA_ERROR("airtaudio::api::Asio::probeDeviceOpen: error (" << getAsioErrorString(result) << ") getting channel count (" << driverName << ").");
ATA_ERROR("error (" << getAsioErrorString(result) << ") getting channel count (" << driverName << ").");
return false;
}
if ( ( _mode == OUTPUT
@ -264,7 +264,7 @@ bool airtaudio::api::Asio::probeDeviceOpen(uint32_t _device,
|| ( _mode == INPUT
&& (_channels+_firstChannel) > (uint32_t) inputChannels)) {
drivers.removeCurrentDriver();
ATA_ERROR("airtaudio::api::Asio::probeDeviceOpen: driver (" << driverName << ") does not support requested channel count (" << _channels << ") + offset (" << _firstChannel << ").");
ATA_ERROR("driver (" << driverName << ") does not support requested channel count (" << _channels << ") + offset (" << _firstChannel << ").");
return false;
}
m_stream.nDeviceChannels[_mode] = _channels;
@ -274,7 +274,7 @@ bool airtaudio::api::Asio::probeDeviceOpen(uint32_t _device,
result = ASIOCanSampleRate((ASIOSampleRate) _sampleRate);
if (result != ASE_OK) {
drivers.removeCurrentDriver();
ATA_ERROR("airtaudio::api::Asio::probeDeviceOpen: driver (" << driverName << ") does not support requested sample rate (" << _sampleRate << ").");
ATA_ERROR("driver (" << driverName << ") does not support requested sample rate (" << _sampleRate << ").");
return false;
}
// Get the current sample rate
@ -282,7 +282,7 @@ bool airtaudio::api::Asio::probeDeviceOpen(uint32_t _device,
result = ASIOGetSampleRate(&currentRate);
if (result != ASE_OK) {
drivers.removeCurrentDriver();
ATA_ERROR("airtaudio::api::Asio::probeDeviceOpen: driver (" << driverName << ") error getting sample rate.");
ATA_ERROR("driver (" << driverName << ") error getting sample rate.");
return false;
}
// Set the sample rate only if necessary
@ -290,7 +290,7 @@ bool airtaudio::api::Asio::probeDeviceOpen(uint32_t _device,
result = ASIOSetSampleRate((ASIOSampleRate) _sampleRate);
if (result != ASE_OK) {
drivers.removeCurrentDriver();
ATA_ERROR("airtaudio::api::Asio::probeDeviceOpen: driver (" << driverName << ") error setting sample rate (" << _sampleRate << ").");
ATA_ERROR("driver (" << driverName << ") error setting sample rate (" << _sampleRate << ").");
return false;
}
}
@ -305,7 +305,7 @@ bool airtaudio::api::Asio::probeDeviceOpen(uint32_t _device,
result = ASIOGetChannelInfo(&channelInfo);
if (result != ASE_OK) {
drivers.removeCurrentDriver();
ATA_ERROR("airtaudio::api::Asio::probeDeviceOpen: driver (" << driverName << ") error (" << getAsioErrorString(result) << ") getting data format.");
ATA_ERROR("driver (" << driverName << ") error (" << getAsioErrorString(result) << ") getting data format.");
return false;
}
// Assuming WINDOWS host is always little-endian.
@ -345,7 +345,7 @@ bool airtaudio::api::Asio::probeDeviceOpen(uint32_t _device,
}
if (m_stream.deviceFormat[_mode] == 0) {
drivers.removeCurrentDriver();
ATA_ERROR("airtaudio::api::Asio::probeDeviceOpen: driver (" << driverName << ") data format not supported by RtAudio.");
ATA_ERROR("driver (" << driverName << ") data format not supported by RtAudio.");
return false;
}
// Set the buffer size. For a duplex stream, this will end up
@ -355,7 +355,7 @@ bool airtaudio::api::Asio::probeDeviceOpen(uint32_t _device,
result = ASIOGetBufferSize(&minSize, &maxSize, &preferSize, &granularity);
if (result != ASE_OK) {
drivers.removeCurrentDriver();
ATA_ERROR("airtaudio::api::Asio::probeDeviceOpen: driver (" << driverName << ") error (" << getAsioErrorString(result) << ") getting buffer size.");
ATA_ERROR("driver (" << driverName << ") error (" << getAsioErrorString(result) << ") getting buffer size.");
return false;
}
if (*_bufferSize < (uint32_t) minSize) {
@ -397,7 +397,7 @@ bool airtaudio::api::Asio::probeDeviceOpen(uint32_t _device,
&& m_stream.mode == OUTPUT
&& m_stream.bufferSize != *_bufferSize) {
drivers.removeCurrentDriver();
ATA_ERROR("airtaudio::api::Asio::probeDeviceOpen: input/output buffersize discrepancy!");
ATA_ERROR("input/output buffersize discrepancy!");
return false;
}
m_stream.bufferSize = *_bufferSize;
@ -416,7 +416,7 @@ bool airtaudio::api::Asio::probeDeviceOpen(uint32_t _device,
handle = new AsioHandle;
if (handle == nullptr) {
drivers.removeCurrentDriver();
ATA_ERROR("airtaudio::api::Asio::probeDeviceOpen: error allocating AsioHandle memory.");
ATA_ERROR("error allocating AsioHandle memory.");
return false;
}
handle->bufferInfos = 0;
@ -444,7 +444,7 @@ bool airtaudio::api::Asio::probeDeviceOpen(uint32_t _device,
uint32_t i, nChannels = m_stream.nDeviceChannels[0] + m_stream.nDeviceChannels[1];
handle->bufferInfos = (ASIOBufferInfo *) malloc(nChannels * sizeof(ASIOBufferInfo));
if (handle->bufferInfos == nullptr) {
ATA_ERROR("airtaudio::api::Asio::probeDeviceOpen: error allocating bufferInfo memory for driver (" << driverName << ").");
ATA_ERROR("error allocating bufferInfo memory for driver (" << driverName << ").");
goto error;
}
ASIOBufferInfo *infos;
@ -466,7 +466,7 @@ bool airtaudio::api::Asio::probeDeviceOpen(uint32_t _device,
asioCallbacks.bufferSwitchTimeInfo = nullptr;
result = ASIOCreateBuffers(handle->bufferInfos, nChannels, m_stream.bufferSize, &asioCallbacks);
if (result != ASE_OK) {
ATA_ERROR("airtaudio::api::Asio::probeDeviceOpen: driver (" << driverName << ") error (" << getAsioErrorString(result) << ") creating buffers.");
ATA_ERROR("driver (" << driverName << ") error (" << getAsioErrorString(result) << ") creating buffers.");
goto error;
}
buffersAllocated = true;
@ -484,7 +484,7 @@ bool airtaudio::api::Asio::probeDeviceOpen(uint32_t _device,
bufferBytes = m_stream.nUserChannels[_mode] * *_bufferSize * formatBytes(m_stream.userFormat);
m_stream.userBuffer[_mode] = (char *) calloc(bufferBytes, 1);
if (m_stream.userBuffer[_mode] == nullptr) {
ATA_ERROR("airtaudio::api::Asio::probeDeviceOpen: error allocating user buffer memory.");
ATA_ERROR("error allocating user buffer memory.");
goto error;
}
if (m_stream.doConvertBuffer[_mode]) {
@ -506,7 +506,7 @@ bool airtaudio::api::Asio::probeDeviceOpen(uint32_t _device,
}
m_stream.deviceBuffer = (char *) calloc(bufferBytes, 1);
if (m_stream.deviceBuffer == nullptr) {
ATA_ERROR("airtaudio::api::Asio::probeDeviceOpen: error allocating device buffer memory.");
ATA_ERROR("error allocating device buffer memory.");
goto error;
}
}
@ -526,7 +526,7 @@ bool airtaudio::api::Asio::probeDeviceOpen(uint32_t _device,
// Determine device latencies
result = ASIOGetLatencies(&inputLatency, &outputLatency);
if (result != ASE_OK) {
ATA_ERROR("airtaudio::api::Asio::probeDeviceOpen: driver (" << driverName << ") error (" << getAsioErrorString(result) << ") getting latency.");
ATA_ERROR("driver (" << driverName << ") error (" << getAsioErrorString(result) << ") getting latency.");
} else {
m_stream.latency[0] = outputLatency;
m_stream.latency[1] = inputLatency;
@ -568,7 +568,7 @@ error:
enum airtaudio::errorType airtaudio::api::Asio::closeStream() {
if (m_stream.state == STREAM_CLOSED) {
ATA_ERROR("airtaudio::api::Asio::closeStream(): no open stream to close!");
ATA_ERROR("no open stream to close!");
return airtaudio::errorWarning;
}
if (m_stream.state == STREAM_RUNNING) {
@ -608,13 +608,13 @@ enum airtaudio::errorType airtaudio::api::Asio::startStream() {
return airtaudio::errorFail;
}
if (m_stream.state == STREAM_RUNNING) {
ATA_ERROR("airtaudio::api::Asio::startStream(): the stream is already running!");
ATA_ERROR("the stream is already running!");
return airtaudio::errorWarning;
}
AsioHandle *handle = (AsioHandle *) m_stream.apiHandle;
ASIOError result = ASIOStart();
if (result != ASE_OK) {
ATA_ERROR("airtaudio::api::Asio::startStream: error (" << getAsioErrorString(result) << ") starting device.");
ATA_ERROR("error (" << getAsioErrorString(result) << ") starting device.");
goto unlock;
}
handle->drainCounter = 0;
@ -635,7 +635,7 @@ enum airtaudio::errorType airtaudio::api::Asio::stopStream() {
return airtaudio::errorFail;
}
if (m_stream.state == STREAM_STOPPED) {
ATA_ERROR("airtaudio::api::Asio::stopStream(): the stream is already stopped!");
ATA_ERROR("the stream is already stopped!");
return airtaudio::errorWarning;
}
AsioHandle *handle = (AsioHandle *) m_stream.apiHandle;
@ -648,7 +648,7 @@ enum airtaudio::errorType airtaudio::api::Asio::stopStream() {
m_stream.state = STREAM_STOPPED;
ASIOError result = ASIOStop();
if (result != ASE_OK) {
ATA_ERROR("airtaudio::api::Asio::stopStream: error (" << getAsioErrorString(result) << ") stopping device.");
ATA_ERROR("error (" << getAsioErrorString(result) << ") stopping device.");
}
if (result == ASE_OK) {
return airtaudio::errorNone;
@ -661,7 +661,7 @@ enum airtaudio::errorType airtaudio::api::Asio::abortStream() {
return airtaudio::errorFail;
}
if (m_stream.state == STREAM_STOPPED) {
ATA_ERROR("airtaudio::api::Asio::abortStream(): the stream is already stopped!");
ATA_ERROR("the stream is already stopped!");
error(airtaudio::errorWarning);
return;
}
@ -694,7 +694,7 @@ bool airtaudio::api::Asio::callbackEvent(long bufferIndex) {
return true;
}
if (m_stream.state == STREAM_CLOSED) {
ATA_ERROR("airtaudio::api::Asio::callbackEvent(): the stream is closed ... this shouldn't happen!");
ATA_ERROR("the stream is closed ... this shouldn't happen!");
return false;
}
CallbackInfo *info = (CallbackInfo *) &m_stream.callbackInfo;
@ -842,9 +842,9 @@ static void sampleRateChanged(ASIOSampleRate _sRate) {
RtApi* object = (RtApi*)asioCallbackInfo->object;
enum airtaudio::errorType ret = object->stopStream()
if (ret != airtaudio::errorNone) {
ATA_ERROR("airtaudio::api::Asio:: sampleRateChanged() error!");
ATA_ERROR("error stop stream!");
} else {
ATA_ERROR("airtaudio::api::Asio:: driver reports sample rate changed to " << _sRate << " ... stream stopped!!!");
ATA_ERROR("driver reports sample rate changed to " << _sRate << " ... stream stopped!!!");
}
}
@ -871,7 +871,7 @@ static long asioMessages(long _selector, long _value, void* _message, double* _o
// done by completely destruct is. I.e. ASIOStop(),
// ASIODisposeBuffers(), Destruction Afterwards you initialize the
// driver again.
ATA_ERROR("airtaudio::api::Asio:: driver reset requested!!!");
ATA_ERROR("driver reset requested!!!");
ret = 1L;
break;
case kAsioResyncRequest:
@ -882,7 +882,7 @@ static long asioMessages(long _selector, long _value, void* _message, double* _o
// which could lose data because the Mutex was held too long by
// another thread. However a driver can issue it in other
// situations, too.
// ATA_ERROR("airtaudio::api::Asio:: driver resync requested!!!");
// ATA_ERROR("driver resync requested!!!");
asioXRun = true;
ret = 1L;
break;
@ -891,7 +891,7 @@ static long asioMessages(long _selector, long _value, void* _message, double* _o
// latencies changed. Beware, it this does not mean that the
// buffer sizes have changed! You might need to update internal
// delay data.
ATA_ERROR("airtaudio::api::Asio:: driver latency may have changed!!!");
ATA_ERROR("driver latency may have changed!!!");
ret = 1L;
break;
case kAsioEngineVersion:

2
airtaudio/api/Asio.h
View File

@ -41,7 +41,7 @@ namespace airtaudio {
uint32_t _channels,
uint32_t _firstChannel,
uint32_t _sampleRate,
airtaudio::format _format,
audio::format _format,
uint32_t *_bufferSize,
airtaudio::StreamOptions *_options);
};

116
airtaudio/api/Core.cpp
View File

@ -86,7 +86,7 @@ airtaudio::api::Core::Core() {
sizeof(CFRunLoopRef),
&theRunLoop);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::RtApiCore: error setting run loop property!");
ATA_ERROR("error setting run loop property!");
}
#endif
}
@ -110,7 +110,7 @@ uint32_t airtaudio::api::Core::getDeviceCount() {
};
OSStatus result = AudioObjectGetPropertyDataSize(kAudioObjectSystemObject, &propertyAddress, 0, nullptr, &dataSize);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::getDeviceCount: OS-X error getting device info!");
ATA_ERROR("OS-X error getting device info!");
return 0;
}
return dataSize / sizeof(AudioDeviceID);
@ -135,7 +135,7 @@ uint32_t airtaudio::api::Core::getDefaultInputDevice() {
&dataSize,
&id);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::getDefaultInputDevice: OS-X system error getting device.");
ATA_ERROR("OS-X system error getting device.");
return 0;
}
dataSize *= nDevices;
@ -148,7 +148,7 @@ uint32_t airtaudio::api::Core::getDefaultInputDevice() {
&dataSize,
(void*)&deviceList);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::getDefaultInputDevice: OS-X system error getting device IDs.");
ATA_ERROR("OS-X system error getting device IDs.");
return 0;
}
for (uint32_t iii=0; iii<nDevices; iii++) {
@ -156,7 +156,7 @@ uint32_t airtaudio::api::Core::getDefaultInputDevice() {
return iii;
}
}
ATA_ERROR("airtaudio::api::Core::getDefaultInputDevice: No default device found!");
ATA_ERROR("No default device found!");
return 0;
}
@ -179,7 +179,7 @@ uint32_t airtaudio::api::Core::getDefaultOutputDevice() {
&dataSize,
&id);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::getDefaultOutputDevice: OS-X system error getting device.");
ATA_ERROR("OS-X system error getting device.");
return 0;
}
dataSize = sizeof(AudioDeviceID) * nDevices;
@ -192,7 +192,7 @@ uint32_t airtaudio::api::Core::getDefaultOutputDevice() {
&dataSize,
(void*)&deviceList);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::getDefaultOutputDevice: OS-X system error getting device IDs.");
ATA_ERROR("OS-X system error getting device IDs.");
return 0;
}
for (uint32_t iii=0; iii<nDevices; iii++) {
@ -200,7 +200,7 @@ uint32_t airtaudio::api::Core::getDefaultOutputDevice() {
return iii;
}
}
ATA_ERROR("airtaudio::api::Core::getDefaultOutputDevice: No default device found!");
ATA_ERROR("No default device found!");
return 0;
}
@ -210,11 +210,11 @@ airtaudio::DeviceInfo airtaudio::api::Core::getDeviceInfo(uint32_t _device) {
// Get device ID
uint32_t nDevices = getDeviceCount();
if (nDevices == 0) {
ATA_ERROR("airtaudio::api::Core::getDeviceInfo: no devices found!");
ATA_ERROR("no devices found!");
return info;
}
if (_device >= nDevices) {
ATA_ERROR("airtaudio::api::Core::getDeviceInfo: device ID is invalid!");
ATA_ERROR("device ID is invalid!");
return info;
}
AudioDeviceID deviceList[ nDevices ];
@ -231,7 +231,7 @@ airtaudio::DeviceInfo airtaudio::api::Core::getDeviceInfo(uint32_t _device) {
&dataSize,
(void*)&deviceList);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::getDeviceInfo: OS-X system error getting device IDs.");
ATA_ERROR("OS-X system error getting device IDs.");
return info;
}
AudioDeviceID id = deviceList[ _device ];
@ -242,7 +242,7 @@ airtaudio::DeviceInfo airtaudio::api::Core::getDeviceInfo(uint32_t _device) {
property.mSelector = kAudioObjectPropertyManufacturer;
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, &cfname);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::probeDeviceInfo: system error (" << getErrorCode(result) << ") getting device manufacturer.");
ATA_ERROR("system error (" << getErrorCode(result) << ") getting device manufacturer.");
return info;
}
//const char *mname = CFStringGetCStringPtr(cfname, CFStringGetSystemEncoding());
@ -256,7 +256,7 @@ airtaudio::DeviceInfo airtaudio::api::Core::getDeviceInfo(uint32_t _device) {
property.mSelector = kAudioObjectPropertyName;
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, &cfname);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::probeDeviceInfo: system error (" << getErrorCode(result) << ") getting device name.");
ATA_ERROR("system error (" << getErrorCode(result) << ") getting device name.");
return info;
}
//const char *name = CFStringGetCStringPtr(cfname, CFStringGetSystemEncoding());
@ -274,20 +274,20 @@ airtaudio::DeviceInfo airtaudio::api::Core::getDeviceInfo(uint32_t _device) {
dataSize = 0;
result = AudioObjectGetPropertyDataSize(id, &property, 0, nullptr, &dataSize);
if (result != noErr || dataSize == 0) {
ATA_ERROR("airtaudio::api::Core::getDeviceInfo: system error (" << getErrorCode(result) << ") getting output stream configuration info for device (" << _device << ").");
ATA_ERROR("system error (" << getErrorCode(result) << ") getting output stream configuration info for device (" << _device << ").");
return info;
}
// Allocate the AudioBufferList.
bufferList = (AudioBufferList *) malloc(dataSize);
if (bufferList == nullptr) {
ATA_ERROR("airtaudio::api::Core::getDeviceInfo: memory error allocating output AudioBufferList.");
ATA_ERROR("memory error allocating output AudioBufferList.");
return info;
}
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, bufferList);
if ( result != noErr
|| dataSize == 0) {
free(bufferList);
ATA_ERROR("airtaudio::api::Core::getDeviceInfo: system error (" << getErrorCode(result) << ") getting output stream configuration for device (" << _device << ").");
ATA_ERROR("system error (" << getErrorCode(result) << ") getting output stream configuration for device (" << _device << ").");
return info;
}
// Get output channel information.
@ -301,19 +301,19 @@ airtaudio::DeviceInfo airtaudio::api::Core::getDeviceInfo(uint32_t _device) {
result = AudioObjectGetPropertyDataSize(id, &property, 0, nullptr, &dataSize);
if ( result != noErr
|| dataSize == 0) {
ATA_ERROR("airtaudio::api::Core::getDeviceInfo: system error (" << getErrorCode(result) << ") getting input stream configuration info for device (" << _device << ").");
ATA_ERROR("system error (" << getErrorCode(result) << ") getting input stream configuration info for device (" << _device << ").");
return info;
}
// Allocate the AudioBufferList.
bufferList = (AudioBufferList *) malloc(dataSize);
if (bufferList == nullptr) {
ATA_ERROR("airtaudio::api::Core::getDeviceInfo: memory error allocating input AudioBufferList.");
ATA_ERROR("memory error allocating input AudioBufferList.");
return info;
}
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, bufferList);
if (result != noErr || dataSize == 0) {
free(bufferList);
ATA_ERROR("airtaudio::api::Core::getDeviceInfo: system error (" << getErrorCode(result) << ") getting input stream configuration for device (" << _device << ").");
ATA_ERROR("system error (" << getErrorCode(result) << ") getting input stream configuration for device (" << _device << ").");
return info;
}
// Get input channel information.
@ -338,14 +338,14 @@ airtaudio::DeviceInfo airtaudio::api::Core::getDeviceInfo(uint32_t _device) {
result = AudioObjectGetPropertyDataSize(id, &property, 0, nullptr, &dataSize);
if ( result != kAudioHardwareNoError
|| dataSize == 0) {
ATA_ERROR("airtaudio::api::Core::getDeviceInfo: system error (" << getErrorCode(result) << ") getting sample rate info.");
ATA_ERROR("system error (" << getErrorCode(result) << ") getting sample rate info.");
return info;
}
uint32_t nRanges = dataSize / sizeof(AudioValueRange);
AudioValueRange rangeList[ nRanges ];
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, &rangeList);
if (result != kAudioHardwareNoError) {
ATA_ERROR("airtaudio::api::Core::getDeviceInfo: system error (" << getErrorCode(result) << ") getting sample rates.");
ATA_ERROR("system error (" << getErrorCode(result) << ") getting sample rates.");
return info;
}
double minimumRate = 100000000.0, maximumRate = 0.0;
@ -364,13 +364,13 @@ airtaudio::DeviceInfo airtaudio::api::Core::getDeviceInfo(uint32_t _device) {
}
}
if (info.sampleRates.size() == 0) {
ATA_ERROR("airtaudio::api::Core::probeDeviceInfo: No supported sample rates found for device (" << _device << ").");
ATA_ERROR("No supported sample rates found for device (" << _device << ").");
return info;
}
// 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 = FLOAT32;
info.nativeFormats.push_back(audio::format_float);
if (info.outputChannels > 0) {
if (getDefaultOutputDevice() == _device) {
info.isDefaultOutput = true;
@ -438,19 +438,19 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
uint32_t _channels,
uint32_t _firstChannel,
uint32_t _sampleRate,
airtaudio::format _format,
audio::format _format,
uint32_t *_bufferSize,
airtaudio::StreamOptions *_options) {
// Get device ID
uint32_t nDevices = getDeviceCount();
if (nDevices == 0) {
// This should not happen because a check is made before this function is called.
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: no devices found!");
ATA_ERROR("no devices found!");
return false;
}
if (_device >= nDevices) {
// This should not happen because a check is made before this function is called.
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: device ID is invalid!");
ATA_ERROR("device ID is invalid!");
return false;
}
AudioDeviceID deviceList[ nDevices ];
@ -467,7 +467,7 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
&dataSize,
(void *) &deviceList);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: OS-X system error getting device IDs.");
ATA_ERROR("OS-X system error getting device IDs.");
return false;
}
AudioDeviceID id = deviceList[ _device ];
@ -486,19 +486,19 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
result = AudioObjectGetPropertyDataSize(id, &property, 0, nullptr, &dataSize);
if ( result != noErr
|| dataSize == 0) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: system error (" << getErrorCode(result) << ") getting stream configuration info for device (" << _device << ").");
ATA_ERROR("system error (" << getErrorCode(result) << ") getting stream configuration info for device (" << _device << ").");
return false;
}
// Allocate the AudioBufferList.
bufferList = (AudioBufferList *) malloc(dataSize);
if (bufferList == nullptr) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: memory error allocating AudioBufferList.");
ATA_ERROR("memory error allocating AudioBufferList.");
return false;
}
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, bufferList);
if ( result != noErr
|| dataSize == 0) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: system error (" << getErrorCode(result) << ") getting stream configuration for device (" << _device << ").");
ATA_ERROR("system error (" << getErrorCode(result) << ") getting stream configuration for device (" << _device << ").");
return false;
}
// Search for one or more streams that contain the desired number of
@ -521,7 +521,7 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
}
if (deviceChannels < (_channels + _firstChannel)) {
free(bufferList);
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: the device (" << _device << ") does not support the requested channel count.");
ATA_ERROR("the device (" << _device << ") does not support the requested channel count.");
return false;
}
// Look for a single stream meeting our needs.
@ -573,7 +573,7 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
property.mSelector = kAudioDevicePropertyBufferFrameSizeRange;
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, &bufferRange);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: system error (" << getErrorCode(result) << ") getting buffer size range for device (" << _device << ").");
ATA_ERROR("system error (" << getErrorCode(result) << ") getting buffer size range for device (" << _device << ").");
return false;
}
if (bufferRange.mMinimum > *_bufferSize) {
@ -592,7 +592,7 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
property.mSelector = kAudioDevicePropertyBufferFrameSize;
result = AudioObjectSetPropertyData(id, &property, 0, nullptr, dataSize, &theSize);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: system error (" << getErrorCode(result) << ") setting the buffer size for device (" << _device << ").");
ATA_ERROR("system error (" << getErrorCode(result) << ") setting the buffer size for device (" << _device << ").");
return false;
}
// If attempting to setup a duplex stream, the bufferSize parameter
@ -601,7 +601,7 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
if ( m_stream.mode == OUTPUT
&& _mode == INPUT
&& *_bufferSize != m_stream.bufferSize) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: system error setting buffer size for duplex stream on device (" << _device << ").");
ATA_ERROR("system error setting buffer size for duplex stream on device (" << _device << ").");
return false;
}
m_stream.bufferSize = *_bufferSize;
@ -614,14 +614,14 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
property.mSelector = kAudioDevicePropertyHogMode;
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, &hog_pid);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: system error (" << getErrorCode(result) << ") getting 'hog' state!");
ATA_ERROR("system error (" << getErrorCode(result) << ") getting 'hog' state!");
return false;
}
if (hog_pid != getpid()) {
hog_pid = getpid();
result = AudioObjectSetPropertyData(id, &property, 0, nullptr, dataSize, &hog_pid);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: system error (" << getErrorCode(result) << ") setting 'hog' state!");
ATA_ERROR("system error (" << getErrorCode(result) << ") setting 'hog' state!");
return false;
}
}
@ -632,7 +632,7 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
property.mSelector = kAudioDevicePropertyNominalSampleRate;
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, &nominalRate);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: system error (" << getErrorCode(result) << ") getting current sample rate.");
ATA_ERROR("system error (" << getErrorCode(result) << ") getting current sample rate.");
return false;
}
// Only change the sample rate if off by more than 1 Hz.
@ -642,13 +642,13 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
AudioObjectPropertyAddress tmp = { kAudioDevicePropertyNominalSampleRate, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
result = AudioObjectAddPropertyListener(id, &tmp, rateListener, (void *) &reportedRate);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: system error (" << getErrorCode(result) << ") setting sample rate property listener for device (" << _device << ").");
ATA_ERROR("system error (" << getErrorCode(result) << ") setting sample rate property listener for device (" << _device << ").");
return false;
}
nominalRate = (double) _sampleRate;
result = AudioObjectSetPropertyData(id, &property, 0, nullptr, dataSize, &nominalRate);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: system error (" << getErrorCode(result) << ") setting sample rate for device (" << _device << ").");
ATA_ERROR("system error (" << getErrorCode(result) << ") setting sample rate for device (" << _device << ").");
return false;
}
// Now wait until the reported nominal rate is what we just set.
@ -663,7 +663,7 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
// Remove the property listener.
AudioObjectRemovePropertyListener(id, &tmp, rateListener, (void *) &reportedRate);
if (microCounter > 5000000) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: timeout waiting for sample rate update for device (" << _device << ").");
ATA_ERROR("timeout waiting for sample rate update for device (" << _device << ").");
return false;
}
}
@ -674,7 +674,7 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
property.mSelector = kAudioStreamPropertyVirtualFormat;
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, &description);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: system error (" << getErrorCode(result) << ") getting stream format for device (" << _device << ").");
ATA_ERROR("system error (" << getErrorCode(result) << ") getting stream format for device (" << _device << ").");
return false;
}
// Set the sample rate and data format id. However, only make the
@ -692,7 +692,7 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
if (updateFormat) {
result = AudioObjectSetPropertyData(id, &property, 0, nullptr, dataSize, &description);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: system error (" << getErrorCode(result) << ") setting sample rate or data format for device (" << _device << ").");
ATA_ERROR("system error (" << getErrorCode(result) << ") setting sample rate or data format for device (" << _device << ").");
return false;
}
}
@ -700,7 +700,7 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
property.mSelector = kAudioStreamPropertyPhysicalFormat;
result = AudioObjectGetPropertyData(id, &property, 0, nullptr, &dataSize, &description);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: system error (" << getErrorCode(result) << ") getting stream physical format for device (" << _device << ").");
ATA_ERROR("system error (" << getErrorCode(result) << ") getting stream physical format for device (" << _device << ").");
return false;
}
//std::cout << "Current physical stream format:" << std::endl;
@ -752,7 +752,7 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
}
}
if (!setPhysicalFormat) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: system error (" << getErrorCode(result) << ") setting physical data format for device (" << _device << ").");
ATA_ERROR("system error (" << getErrorCode(result) << ") setting physical data format for device (" << _device << ").");
return false;
}
} // done setting virtual/physical formats.
@ -765,7 +765,7 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
if (result == kAudioHardwareNoError) {
m_stream.latency[ _mode ] = latency;
} else {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: system error (" << getErrorCode(result) << ") getting device latency for device (" << _device << ").");
ATA_ERROR("system error (" << getErrorCode(result) << ") getting device latency for device (" << _device << ").");
return false;
}
}
@ -816,7 +816,7 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
if (m_stream.apiHandle == 0) {
handle = new CoreHandle;
if (handle == nullptr) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: error allocating CoreHandle memory.");
ATA_ERROR("error allocating CoreHandle memory.");
return false;
}
m_stream.apiHandle = (void *) handle;
@ -833,7 +833,7 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
m_stream.userBuffer[_mode] = (char *) malloc(bufferBytes * sizeof(char));
memset(m_stream.userBuffer[_mode], 0, bufferBytes * sizeof(char));
if (m_stream.userBuffer[_mode] == nullptr) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: error allocating user buffer memory.");
ATA_ERROR("error allocating user buffer memory.");
goto error;
}
// If possible, we will make use of the CoreAudio stream buffers as
@ -860,7 +860,7 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
}
m_stream.deviceBuffer = (char *) calloc(bufferBytes, 1);
if (m_stream.deviceBuffer == nullptr) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: error allocating device buffer memory.");
ATA_ERROR("error allocating device buffer memory.");
goto error;
}
}
@ -890,7 +890,7 @@ bool airtaudio::api::Core::probeDeviceOpen(uint32_t _device,
result = AudioDeviceAddIOProc(id, callbackHandler, (void *) &m_stream.callbackInfo);
#endif
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::probeDeviceOpen: system error setting callback for device (" << _device << ").");
ATA_ERROR("system error setting callback for device (" << _device << ").");
goto error;
}
if ( m_stream.mode == OUTPUT
@ -925,7 +925,7 @@ error:
enum airtaudio::errorType airtaudio::api::Core::closeStream() {
if (m_stream.state == STREAM_CLOSED) {
ATA_ERROR("airtaudio::api::Core::closeStream(): no open stream to close!");
ATA_ERROR("no open stream to close!");
return airtaudio::errorWarning;
}
CoreHandle *handle = (CoreHandle *) m_stream.apiHandle;
@ -976,7 +976,7 @@ enum airtaudio::errorType airtaudio::api::Core::startStream() {
return airtaudio::errorFail;
}
if (m_stream.state == STREAM_RUNNING) {
ATA_ERROR("airtaudio::api::Core::startStream(): the stream is already running!");
ATA_ERROR("the stream is already running!");
return airtaudio::errorWarning;
}
OSStatus result = noErr;
@ -985,7 +985,7 @@ enum airtaudio::errorType airtaudio::api::Core::startStream() {
|| m_stream.mode == DUPLEX) {
result = AudioDeviceStart(handle->id[0], callbackHandler);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::startStream: system error (" << getErrorCode(result) << ") starting callback procedure on device (" << m_stream.device[0] << ").");
ATA_ERROR("system error (" << getErrorCode(result) << ") starting callback procedure on device (" << m_stream.device[0] << ").");
goto unlock;
}
}
@ -994,7 +994,7 @@ enum airtaudio::errorType airtaudio::api::Core::startStream() {
&& m_stream.device[0] != m_stream.device[1])) {
result = AudioDeviceStart(handle->id[1], callbackHandler);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::startStream: system error starting input callback procedure on device (" << m_stream.device[1] << ").");
ATA_ERROR("system error starting input callback procedure on device (" << m_stream.device[1] << ").");
goto unlock;
}
}
@ -1013,7 +1013,7 @@ enum airtaudio::errorType airtaudio::api::Core::stopStream() {
return airtaudio::errorFail;
}
if (m_stream.state == STREAM_STOPPED) {
ATA_ERROR("airtaudio::api::Core::stopStream(): the stream is already stopped!");
ATA_ERROR("the stream is already stopped!");
return airtaudio::errorWarning;
}
OSStatus result = noErr;
@ -1027,7 +1027,7 @@ enum airtaudio::errorType airtaudio::api::Core::stopStream() {
}
result = AudioDeviceStop(handle->id[0], callbackHandler);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::stopStream: system error (" << getErrorCode(result) << ") stopping callback procedure on device (" << m_stream.device[0] << ").");
ATA_ERROR("system error (" << getErrorCode(result) << ") stopping callback procedure on device (" << m_stream.device[0] << ").");
goto unlock;
}
}
@ -1036,7 +1036,7 @@ enum airtaudio::errorType airtaudio::api::Core::stopStream() {
&& m_stream.device[0] != m_stream.device[1])) {
result = AudioDeviceStop(handle->id[1], callbackHandler);
if (result != noErr) {
ATA_ERROR("airtaudio::api::Core::stopStream: system error (" << getErrorCode(result) << ") stopping input callback procedure on device (" << m_stream.device[1] << ").");
ATA_ERROR("system error (" << getErrorCode(result) << ") stopping input callback procedure on device (" << m_stream.device[1] << ").");
goto unlock;
}
}
@ -1053,7 +1053,7 @@ enum airtaudio::errorType airtaudio::api::Core::abortStream() {
return airtaudio::errorFail;
}
if (m_stream.state == STREAM_STOPPED) {
ATA_ERROR("airtaudio::api::Core::abortStream(): the stream is already stopped!");
ATA_ERROR("the stream is already stopped!");
return airtaudio::errorWarning;
}
CoreHandle* handle = (CoreHandle*)m_stream.apiHandle;
@ -1080,7 +1080,7 @@ bool airtaudio::api::Core::callbackEvent(AudioDeviceID _deviceId,
return true;
}
if (m_stream.state == STREAM_CLOSED) {
ATA_ERROR("airtaudio::api::Core::callbackEvent(): the stream is closed ... this shouldn't happen!");
ATA_ERROR("the stream is closed ... this shouldn't happen!");
return false;
}
CallbackInfo *info = (CallbackInfo *) &m_stream.callbackInfo;

2
airtaudio/api/Core.h
View File

@ -45,7 +45,7 @@ namespace airtaudio {
uint32_t _channels,
uint32_t _firstChannel,
uint32_t _sampleRate,
airtaudio::format _format,
audio::format _format,
uint32_t *_bufferSize,
airtaudio::StreamOptions *_options);
static const char* getErrorCode(OSStatus _code);

2
airtaudio/api/CoreIos.h
View File

@ -38,7 +38,7 @@ namespace airtaudio {
uint32_t _channels,
uint32_t _firstChannel,
uint32_t _sampleRate,
airtaudio::format _format,
audio::format _format,
uint32_t *_bufferSize,
airtaudio::StreamOptions *_options);
public:

9
airtaudio/api/CoreIos.mm
View File

@ -50,7 +50,7 @@ airtaudio::api::CoreIos::CoreIos(void) :
tmp.duplexChannels = 0;
tmp.isDefaultOutput = true;
tmp.isDefaultInput = false;
tmp.nativeFormats = SINT16;
tmp.nativeFormats.push_back(audio::format_int16);
m_devices.push_back(tmp);
// add default input format:
tmp.name = "in";
@ -60,9 +60,8 @@ airtaudio::api::CoreIos::CoreIos(void) :
tmp.duplexChannels = 0;
tmp.isDefaultOutput = false;
tmp.isDefaultInput = true;
tmp.nativeFormats = SINT16;
tmp.nativeFormats.push_back(audio::format_int16);
m_devices.push_back(tmp);
ATA_INFO("Create CoreIOs interface (end)");
}
@ -177,7 +176,7 @@ bool airtaudio::api::CoreIos::probeDeviceOpen(uint32_t _device,
uint32_t _channels,
uint32_t _firstChannel,
uint32_t _sampleRate,
airtaudio::format _format,
audio::format _format,
uint32_t *_bufferSize,
airtaudio::StreamOptions *_options) {
ATA_INFO("Probe : device=" << _device << " channels=" << _channels << " firstChannel=" << _firstChannel << " sampleRate=" << _sampleRate);
@ -215,7 +214,7 @@ bool airtaudio::api::CoreIos::probeDeviceOpen(uint32_t _device,
uint64_t bufferBytes = m_stream.nUserChannels[_mode] * m_stream.bufferSize * formatBytes(m_stream.userFormat);
m_stream.userBuffer[_mode] = (char *) calloc(bufferBytes, 1);
if (m_stream.userBuffer[_mode] == nullptr) {
ATA_ERROR("airtaudio::api::Android::probeDeviceOpen: error allocating user buffer memory.");
ATA_ERROR("error allocating user buffer memory.");
}
setConvertInfo(_mode, _firstChannel);
}

122
airtaudio/api/Ds.cpp
View File

@ -154,14 +154,14 @@ uint32_t airtaudio::api::Ds::getDeviceCount() {
probeInfo.dsDevices = &dsDevices;
HRESULT result = DirectSoundEnumerate((LPDSENUMCALLBACK) deviceQueryCallback, &probeInfo);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::getDeviceCount: error (" << getErrorString(result) << ") enumerating output devices!");
ATA_ERROR("error (" << getErrorString(result) << ") enumerating output devices!");
return 0;
}
// Query DirectSoundCapture devices.
probeInfo.isInput = true;
result = DirectSoundCaptureEnumerate((LPDSENUMCALLBACK) deviceQueryCallback, &probeInfo);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::getDeviceCount: error (" << getErrorString(result) << ") enumerating input devices!");
ATA_ERROR("error (" << getErrorString(result) << ") enumerating input devices!");
return 0;
}
// Clean out any devices that may have disappeared.
@ -185,12 +185,12 @@ rtaudio::DeviceInfo airtaudio::api::Ds::getDeviceInfo(uint32_t _device) {
// Force a query of all devices
getDeviceCount();
if (dsDevices.size() == 0) {
ATA_ERROR("airtaudio::api::Ds::getDeviceInfo: no devices found!");
ATA_ERROR("no devices found!");
return info;
}
}
if (_device >= dsDevices.size()) {
ATA_ERROR("airtaudio::api::Ds::getDeviceInfo: device ID is invalid!");
ATA_ERROR("device ID is invalid!");
return info;
}
HRESULT result;
@ -201,14 +201,14 @@ rtaudio::DeviceInfo airtaudio::api::Ds::getDeviceInfo(uint32_t _device) {
DSCAPS outCaps;
result = DirectSoundCreate(dsDevices[ _device ].id[0], &output, nullptr);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::getDeviceInfo: error (" << getErrorString(result) << ") opening output device (" << dsDevices[ _device ].name << ")!");
ATA_ERROR("error (" << getErrorString(result) << ") opening output device (" << dsDevices[ _device ].name << ")!");
goto probeInput;
}
outCaps.dwSize = sizeof(outCaps);
result = output->GetCaps(&outCaps);
if (FAILED(result)) {
output->Release();
ATA_ERROR("airtaudio::api::Ds::getDeviceInfo: error (" << getErrorString(result) << ") getting capabilities!");
ATA_ERROR("error (" << getErrorString(result) << ") getting capabilities!");
goto probeInput;
}
// Get output channel information.
@ -223,10 +223,10 @@ rtaudio::DeviceInfo airtaudio::api::Ds::getDeviceInfo(uint32_t _device) {
}
// Get format information.
if (outCaps.dwFlags & DSCAPS_PRIMARY16BIT) {
info.nativeFormats |= RTAUDIO_SINT16;
info.nativeFormats.push_back(audio::format_int16);
}
if (outCaps.dwFlags & DSCAPS_PRIMARY8BIT) {
info.nativeFormats |= RTAUDIO_SINT8;
info.nativeFormats.push_back(audio::format_int8);
}
output->Release();
if (getDefaultOutputDevice() == _device) {
@ -241,7 +241,7 @@ probeInput:
LPDIRECTSOUNDCAPTURE input;
result = DirectSoundCaptureCreate(dsDevices[ _device ].id[1], &input, nullptr);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::getDeviceInfo: error (" << getErrorString(result) << ") opening input device (" << dsDevices[ _device ].name << ")!");
ATA_ERROR("error (" << getErrorString(result) << ") opening input device (" << dsDevices[ _device ].name << ")!");
return info;
}
DSCCAPS inCaps;
@ -249,7 +249,7 @@ probeInput:
result = input->GetCaps(&inCaps);
if (FAILED(result)) {
input->Release();
ATA_ERROR("airtaudio::api::Ds::getDeviceInfo: error (" << getErrorString(result) << ") getting object capabilities (" << dsDevices[ _device ].name << ")!");
ATA_ERROR("error (" << getErrorString(result) << ") getting object capabilities (" << dsDevices[ _device ].name << ")!");
return info;
}
// Get input channel information.
@ -403,28 +403,28 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
uint32_t *_bufferSize,
rtaudio::StreamOptions *_options) {
if (_channels + _firstChannel > 2) {
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: DirectSound does not support more than 2 channels per device.");
ATA_ERROR("DirectSound does not support more than 2 channels per device.");
return false;
}
uint32_t nDevices = dsDevices.size();
if (nDevices == 0) {
// This should not happen because a check is made before this function is called.
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: no devices found!");
ATA_ERROR("no devices found!");
return false;
}
if (_device >= nDevices) {
// This should not happen because a check is made before this function is called.
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: device ID is invalid!");
ATA_ERROR("device ID is invalid!");
return false;
}
if (_mode == OUTPUT) {
if (dsDevices[ _device ].validId[0] == false) {
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: device (" << _device << ") does not support output!");
ATA_ERROR("device (" << _device << ") does not support output!");
return false;
}
} else { // _mode == INPUT
if (dsDevices[ _device ].validId[1] == false) {
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: device (" << _device << ") does not support input!");
ATA_ERROR("device (" << _device << ") does not support input!");
return false;
}
}
@ -474,7 +474,7 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
LPDIRECTSOUND output;
result = DirectSoundCreate(dsDevices[ _device ].id[0], &output, nullptr);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: error (" << getErrorString(result) << ") opening output device (" << dsDevices[ _device ].name << ")!");
ATA_ERROR("error (" << getErrorString(result) << ") opening output device (" << dsDevices[ _device ].name << ")!");
return false;
}
DSCAPS outCaps;
@ -482,12 +482,12 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
result = output->GetCaps(&outCaps);
if (FAILED(result)) {
output->Release();
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: error (" << getErrorString(result) << ") getting capabilities (" << dsDevices[ _device ].name << ")!");
ATA_ERROR("error (" << getErrorString(result) << ") getting capabilities (" << dsDevices[ _device ].name << ")!");
return false;
}
// Check channel information.
if (_channels + _firstChannel == 2 && !(outCaps.dwFlags & DSCAPS_PRIMARYSTEREO)) {
ATA_ERROR("airtaudio::api::Ds::getDeviceInfo: the output device (" << dsDevices[ _device ].name << ") does not support stereo playback.");
ATA_ERROR("the output device (" << dsDevices[ _device ].name << ") does not support stereo playback.");
return false;
}
// Check format information. Use 16-bit format unless not
@ -516,7 +516,7 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
result = output->SetCooperativeLevel(hWnd, DSSCL_PRIORITY);
if (FAILED(result)) {
output->Release();
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: error (" << getErrorString(result) << ") setting cooperative level (" << dsDevices[ _device ].name << ")!");
ATA_ERROR("error (" << getErrorString(result) << ") setting cooperative level (" << dsDevices[ _device ].name << ")!");
return false;
}
// Even though we will write to the secondary buffer, we need to
@ -532,14 +532,14 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
result = output->CreateSoundBuffer(&bufferDescription, &buffer, nullptr);
if (FAILED(result)) {
output->Release();
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: error (" << getErrorString(result) << ") accessing primary buffer (" << dsDevices[ _device ].name << ")!");
ATA_ERROR("error (" << getErrorString(result) << ") accessing primary buffer (" << dsDevices[ _device ].name << ")!");
return false;
}
// Set the primary DS buffer sound format.
result = buffer->SetFormat(&waveFormat);
if (FAILED(result)) {
output->Release();
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: error (" << getErrorString(result) << ") setting primary buffer format (" << dsDevices[ _device ].name << ")!");
ATA_ERROR("error (" << getErrorString(result) << ") setting primary buffer format (" << dsDevices[ _device ].name << ")!");
return false;
}
// Setup the secondary DS buffer description.
@ -562,7 +562,7 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
result = output->CreateSoundBuffer(&bufferDescription, &buffer, nullptr);
if (FAILED(result)) {
output->Release();
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: error (" << getErrorString(result) << ") creating secondary buffer (" << dsDevices[ _device ].name << ")!");
ATA_ERROR("error (" << getErrorString(result) << ") creating secondary buffer (" << dsDevices[ _device ].name << ")!");
return false;
}
}
@ -573,7 +573,7 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
if (FAILED(result)) {
output->Release();
buffer->Release();
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: error (" << getErrorString(result) << ") getting buffer settings (" << dsDevices[ _device ].name << ")!");
ATA_ERROR("error (" << getErrorString(result) << ") getting buffer settings (" << dsDevices[ _device ].name << ")!");
return false;
}
dsBufferSize = dsbcaps.dwBufferBytes;
@ -584,7 +584,7 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
if (FAILED(result)) {
output->Release();
buffer->Release();
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: error (" << getErrorString(result) << ") locking buffer (" << dsDevices[ _device ].name << ")!");
ATA_ERROR("error (" << getErrorString(result) << ") locking buffer (" << dsDevices[ _device ].name << ")!");
return false;
}
// Zero the DS buffer
@ -594,7 +594,7 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
if (FAILED(result)) {
output->Release();
buffer->Release();
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: error (" << getErrorString(result) << ") unlocking buffer (" << dsDevices[ _device ].name << ")!");
ATA_ERROR("error (" << getErrorString(result) << ") unlocking buffer (" << dsDevices[ _device ].name << ")!");
return false;
}
ohandle = (void *) output;
@ -604,7 +604,7 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
LPDIRECTSOUNDCAPTURE input;
result = DirectSoundCaptureCreate(dsDevices[ _device ].id[1], &input, nullptr);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: error (" << getErrorString(result) << ") opening input device (" << dsDevices[ _device ].name << ")!");
ATA_ERROR("error (" << getErrorString(result) << ") opening input device (" << dsDevices[ _device ].name << ")!");
return false;
}
DSCCAPS inCaps;
@ -612,12 +612,12 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
result = input->GetCaps(&inCaps);
if (FAILED(result)) {
input->Release();
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: error (" << getErrorString(result) << ") getting input capabilities (" << dsDevices[ _device ].name << ")!");
ATA_ERROR("error (" << getErrorString(result) << ") getting input capabilities (" << dsDevices[ _device ].name << ")!");
return false;
}
// Check channel information.
if (inCaps.dwChannels < _channels + _firstChannel) {
ATA_ERROR("airtaudio::api::Ds::getDeviceInfo: the input device does not support requested input channels.");
ATA_ERROR("the input device does not support requested input channels.");
return false;
}
// Check format information. Use 16-bit format unless user
@ -665,7 +665,7 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
result = input->CreateCaptureBuffer(&bufferDescription, &buffer, nullptr);
if (FAILED(result)) {
input->Release();
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: error (" << getErrorString(result) << ") creating input buffer (" << dsDevices[ _device ].name << ")!");
ATA_ERROR("error (" << getErrorString(result) << ") creating input buffer (" << dsDevices[ _device ].name << ")!");
return false;
}
// Get the buffer size ... might be different from what we specified.
@ -675,7 +675,7 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
if (FAILED(result)) {
input->Release();
buffer->Release();
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: error (" << getErrorString(result) << ") getting buffer settings (" << dsDevices[ _device ].name << ")!");
ATA_ERROR("error (" << getErrorString(result) << ") getting buffer settings (" << dsDevices[ _device ].name << ")!");
return false;
}
dsBufferSize = dscbcaps.dwBufferBytes;
@ -690,7 +690,7 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
if (FAILED(result)) {
input->Release();
buffer->Release();
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: error (" << getErrorString(result) << ") locking input buffer (" << dsDevices[ _device ].name << ")!");
ATA_ERROR("error (" << getErrorString(result) << ") locking input buffer (" << dsDevices[ _device ].name << ")!");
return false;
}
// Zero the buffer
@ -700,7 +700,7 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
if (FAILED(result)) {
input->Release();
buffer->Release();
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: error (" << getErrorString(result) << ") unlocking input buffer (" << dsDevices[ _device ].name << ")!");
ATA_ERROR("error (" << getErrorString(result) << ") unlocking input buffer (" << dsDevices[ _device ].name << ")!");
return false;
}
ohandle = (void *) input;
@ -735,7 +735,7 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
long bufferBytes = m_stream.nUserChannels[_mode] * *_bufferSize * formatBytes(m_stream.userFormat);
m_stream.userBuffer[_mode] = (char *) calloc(bufferBytes, 1);
if (m_stream.userBuffer[_mode] == nullptr) {
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: error allocating user buffer memory.");
ATA_ERROR("error allocating user buffer memory.");
goto error;
}
if (m_stream.doConvertBuffer[_mode]) {
@ -756,7 +756,7 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
}
m_stream.deviceBuffer = (char *) calloc(bufferBytes, 1);
if (m_stream.deviceBuffer == nullptr) {
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: error allocating device buffer memory.");
ATA_ERROR("error allocating device buffer memory.");
goto error;
}
}
@ -765,7 +765,7 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
if (m_stream.apiHandle == 0) {
handle = new DsHandle;
if (handle == nullptr) {
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: error allocating AsioHandle memory.");
ATA_ERROR("error allocating AsioHandle memory.");
goto error;
}
// Create a manual-reset event.
@ -808,7 +808,7 @@ bool airtaudio::api::Ds::probeDeviceOpen(uint32_t _device,
0,
&threadId);
if (m_stream.callbackInfo.thread == 0) {
ATA_ERROR("airtaudio::api::Ds::probeDeviceOpen: error creating callback thread!");
ATA_ERROR("error creating callback thread!");
goto error;
}
// Boost DS thread priority
@ -853,7 +853,7 @@ error:
enum airtaudio::errorType airtaudio::api::Ds::closeStream() {
if (m_stream.state == STREAM_CLOSED) {
ATA_ERROR("airtaudio::api::Ds::closeStream(): no open stream to close!");
ATA_ERROR("no open stream to close!");
return airtaudio::errorWarning;
}
// Stop the callback thread.
@ -903,7 +903,7 @@ enum airtaudio::errorType airtaudio::api::Ds::startStream() {
return airtaudio::errorFail;
}
if (m_stream.state == STREAM_RUNNING) {
ATA_ERROR("airtaudio::api::Ds::startStream(): the stream is already running!");
ATA_ERROR("the stream is already running!");
return airtaudio::errorWarning;
}
DsHandle *handle = (DsHandle *) m_stream.apiHandle;
@ -923,7 +923,7 @@ enum airtaudio::errorType airtaudio::api::Ds::startStream() {
LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0];
result = buffer->Play(0, 0, DSBPLAY_LOOPING);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::startStream: error (" << getErrorString(result) << ") starting output buffer!");
ATA_ERROR("error (" << getErrorString(result) << ") starting output buffer!");
goto unlock;
}
}
@ -932,7 +932,7 @@ enum airtaudio::errorType airtaudio::api::Ds::startStream() {
LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handle->buffer[1];
result = buffer->Start(DSCBSTART_LOOPING);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::startStream: error (" << getErrorString(result) << ") starting input buffer!");
ATA_ERROR("error (" << getErrorString(result) << ") starting input buffer!");
goto unlock;
}
}
@ -952,7 +952,7 @@ enum airtaudio::errorType airtaudio::api::Ds::stopStream() {
return airtaudio::errorFail;
}
if (m_stream.state == STREAM_STOPPED) {
ATA_ERROR("airtaudio::api::Ds::stopStream(): the stream is already stopped!");
ATA_ERROR("the stream is already stopped!");
return airtaudio::errorWarning;
}
HRESULT result = 0;
@ -970,14 +970,14 @@ enum airtaudio::errorType airtaudio::api::Ds::stopStream() {
LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0];
result = buffer->Stop();
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::stopStream: error (" << getErrorString(result) << ") stopping output buffer!");
ATA_ERROR("error (" << getErrorString(result) << ") stopping output buffer!");
goto unlock;
}
// 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, handle->dsBufferSize[0], &audioPtr, &dataLen, nullptr, nullptr, 0);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::stopStream: error (" << getErrorString(result) << ") locking output buffer!");
ATA_ERROR("error (" << getErrorString(result) << ") locking output buffer!");
goto unlock;
}
// Zero the DS buffer
@ -985,7 +985,7 @@ enum airtaudio::errorType airtaudio::api::Ds::stopStream() {
// Unlock the DS buffer
result = buffer->Unlock(audioPtr, dataLen, nullptr, 0);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::stopStream: error (" << getErrorString(result) << ") unlocking output buffer!");
ATA_ERROR("error (" << getErrorString(result) << ") unlocking output buffer!");
goto unlock;
}
// If we start playing again, we must begin at beginning of buffer.
@ -999,14 +999,14 @@ enum airtaudio::errorType airtaudio::api::Ds::stopStream() {
m_stream.state = STREAM_STOPPED;
result = buffer->Stop();
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::stopStream: error (" << getErrorString(result) << ") stopping input buffer!");
ATA_ERROR("error (" << getErrorString(result) << ") stopping input buffer!");
goto unlock;
}
// 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, handle->dsBufferSize[1], &audioPtr, &dataLen, nullptr, nullptr, 0);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::stopStream: error (" << getErrorString(result) << ") locking input buffer!");
ATA_ERROR("error (" << getErrorString(result) << ") locking input buffer!");
goto unlock;
}
// Zero the DS buffer
@ -1014,7 +1014,7 @@ enum airtaudio::errorType airtaudio::api::Ds::stopStream() {
// Unlock the DS buffer
result = buffer->Unlock(audioPtr, dataLen, nullptr, 0);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::stopStream: error (" << getErrorString(result) << ") unlocking input buffer!");
ATA_ERROR("error (" << getErrorString(result) << ") unlocking input buffer!");
goto unlock;
}
// If we start recording again, we must begin at beginning of buffer.
@ -1033,7 +1033,7 @@ enum airtaudio::errorType airtaudio::api::Ds::abortStream() {
return airtaudio::errorFail;
}
if (m_stream.state == STREAM_STOPPED) {
ATA_ERROR("airtaudio::api::Ds::abortStream(): the stream is already stopped!");
ATA_ERROR("the stream is already stopped!");
return airtaudio::errorWarning;
}
DsHandle *handle = (DsHandle *) m_stream.apiHandle;
@ -1047,7 +1047,7 @@ void airtaudio::api::Ds::callbackEvent() {
return;
}
if (m_stream.state == STREAM_CLOSED) {
ATA_ERROR("airtaudio::api::Ds::callbackEvent(): the stream is closed ... this shouldn't happen!");
ATA_ERROR("the stream is closed ... this shouldn't happen!");
return;
}
CallbackInfo *info = (CallbackInfo *) &m_stream.callbackInfo;
@ -1122,23 +1122,23 @@ void airtaudio::api::Ds::callbackEvent() {
DWORD startSafeWritePointer, startSafeReadPointer;
result = dsWriteBuffer->GetCurrentPosition(nullptr, &startSafeWritePointer);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::callbackEvent: error (" << getErrorString(result) << ") getting current write position!");
ATA_ERROR("error (" << getErrorString(result) << ") getting current write position!");
return;
}
result = dsCaptureBuffer->GetCurrentPosition(nullptr, &startSafeReadPointer);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::callbackEvent: error (" << getErrorString(result) << ") getting current read position!");
ATA_ERROR("error (" << getErrorString(result) << ") getting current read position!");
return;
}
while (true) {
result = dsWriteBuffer->GetCurrentPosition(nullptr, &safeWritePointer);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::callbackEvent: error (" << getErrorString(result) << ") getting current write position!");
ATA_ERROR("error (" << getErrorString(result) << ") getting current write position!");
return;
}
result = dsCaptureBuffer->GetCurrentPosition(nullptr, &safeReadPointer);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::callbackEvent: error (" << getErrorString(result) << ") getting current read position!");
ATA_ERROR("error (" << getErrorString(result) << ") getting current read position!");
return;
}
if ( safeWritePointer != startSafeWritePointer
@ -1158,7 +1158,7 @@ void airtaudio::api::Ds::callbackEvent() {
LPDIRECTSOUNDBUFFER dsWriteBuffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0];
result = dsWriteBuffer->GetCurrentPosition(&currentWritePointer, &safeWritePointer);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::callbackEvent: error (" << getErrorString(result) << ") getting current write position!");
ATA_ERROR("error (" << getErrorString(result) << ") getting current write position!");
return;
}
handle->bufferPointer[0] = safeWritePointer + handle->dsPointerLeadTime[0];
@ -1203,7 +1203,7 @@ void airtaudio::api::Ds::callbackEvent() {
// Find out where the read and "safe write" pointers are.
result = dsBuffer->GetCurrentPosition(&currentWritePointer, &safeWritePointer);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::callbackEvent: error (" << getErrorString(result) << ") getting current write position!");
ATA_ERROR("error (" << getErrorString(result) << ") getting current write position!");
return;
}
// We will copy our output buffer into the region between
@ -1252,7 +1252,7 @@ void airtaudio::api::Ds::callbackEvent() {
&bufferSize2,
0);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::callbackEvent: error (" << getErrorString(result) << ") locking buffer during playback!");
ATA_ERROR("error (" << getErrorString(result) << ") locking buffer during playback!");
return;
}
// Copy our buffer into the DS buffer
@ -1263,7 +1263,7 @@ void airtaudio::api::Ds::callbackEvent() {
// Update our buffer offset and unlock sound buffer
dsBuffer->Unlock(buffer1, bufferSize1, buffer2, bufferSize2);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::callbackEvent: error (" << getErrorString(result) << ") unlocking buffer during playback!");
ATA_ERROR("error (" << getErrorString(result) << ") unlocking buffer during playback!");
return;
}
nextWritePointer = (nextWritePointer + bufferSize1 + bufferSize2) % dsBufferSize;
@ -1291,7 +1291,7 @@ void airtaudio::api::Ds::callbackEvent() {
// Find out where the write and "safe read" pointers are.
result = dsBuffer->GetCurrentPosition(&currentReadPointer, &safeReadPointer);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::callbackEvent: error (" << getErrorString(result) << ") getting current read position!");
ATA_ERROR("error (" << getErrorString(result) << ") getting current read position!");
return;
}
if (safeReadPointer < (DWORD)nextReadPointer) {
@ -1351,7 +1351,7 @@ void airtaudio::api::Ds::callbackEvent() {
// Wake up and find out where we are now.
result = dsBuffer->GetCurrentPosition(&currentReadPointer, &safeReadPointer);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::callbackEvent: error (" << getErrorString(result) << ") getting current read position!");
ATA_ERROR("error (" << getErrorString(result) << ") getting current read position!");
return;
}
if (safeReadPointer < (DWORD)nextReadPointer) {
@ -1369,7 +1369,7 @@ void airtaudio::api::Ds::callbackEvent() {
&bufferSize2,
0);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::callbackEvent: error (" << getErrorString(result) << ") locking capture buffer!");
ATA_ERROR("error (" << getErrorString(result) << ") locking capture buffer!");
return;
}
if (m_duplexPrerollBytes <= 0) {
@ -1389,7 +1389,7 @@ void airtaudio::api::Ds::callbackEvent() {
nextReadPointer = (nextReadPointer + bufferSize1 + bufferSize2) % dsBufferSize;
dsBuffer->Unlock(buffer1, bufferSize1, buffer2, bufferSize2);
if (FAILED(result)) {
ATA_ERROR("airtaudio::api::Ds::callbackEvent: error (" << getErrorString(result) << ") unlocking capture buffer!");
ATA_ERROR("error (" << getErrorString(result) << ") unlocking capture buffer!");
return;
}
handle->bufferPointer[1] = nextReadPointer;

2
airtaudio/api/Ds.h
View File

@ -44,7 +44,7 @@ namespace airtaudio {
uint32_t _channels,
uint32_t _firstChannel,
uint32_t _sampleRate,
airtaudio::format _format,
audio::format _format,
uint32_t *_bufferSize,
airtaudio::StreamOptions *_options);
};

6
airtaudio/api/Dummy.cpp
View File

@ -19,7 +19,7 @@ airtaudio::Api* airtaudio::api::Dummy::Create() {
airtaudio::api::Dummy::Dummy() {
m_errorText = "airtaudio::api::Dummy: This class provides no functionality.";
m_errorText = "This class provides no functionality.";
error(airtaudio::errorWarning);
}
@ -28,7 +28,7 @@ uint32_t airtaudio::api::Dummy::getDeviceCount() {
}
rtaudio::DeviceInfo airtaudio::api::Dummy::getDeviceInfo(uint32_t _device) {
()_device;
(void)_device;
rtaudio::DeviceInfo info;
return info;
}
@ -54,7 +54,7 @@ bool airtaudio::api::Dummy::probeDeviceOpen(uint32_t _device,
uint32_t _channels,
uint32_t _firstChannel,
uint32_t _sampleRate,
airtaudio::format _format,
audio::format _format,
uint32_t *_bufferSize,
airtaudio::StreamOptions *_options) {
return false;

2
airtaudio/api/Dummy.h
View File

@ -33,7 +33,7 @@ namespace airtaudio {
uint32_t _channels,
uint32_t _firstChannel,
uint32_t _sampleRate,
airtaudio::format _format,
audio::format _format,
uint32_t *_bufferSize,
airtaudio::StreamOptions *_options);
};

44
airtaudio/api/Jack.cpp
View File

@ -127,7 +127,7 @@ airtaudio::DeviceInfo airtaudio::api::Jack::getDeviceInfo(uint32_t _device) {
jack_status_t *status = nullptr;
jack_client_t *client = jack_client_open("RtApiJackInfo", options, status);
if (client == nullptr) {
ATA_ERROR("airtaudio::api::Jack::getDeviceInfo: Jack server not found or connection error!");
ATA_ERROR("Jack server not found or connection error!");
// TODO : airtaudio::errorWarning;
return info;
}
@ -156,7 +156,7 @@ airtaudio::DeviceInfo airtaudio::api::Jack::getDeviceInfo(uint32_t _device) {
}
if (_device >= nDevices) {
jack_client_close(client);
ATA_ERROR("airtaudio::api::Jack::getDeviceInfo: device ID is invalid!");
ATA_ERROR("device ID is invalid!");
// TODO : airtaudio::errorInvalidUse;
return info;
}
@ -186,7 +186,7 @@ airtaudio::DeviceInfo airtaudio::api::Jack::getDeviceInfo(uint32_t _device) {
}
if (info.outputChannels == 0 && info.inputChannels == 0) {
jack_client_close(client);
ATA_ERROR("airtaudio::api::Jack::getDeviceInfo: error determining Jack input/output channels!");
ATA_ERROR("error determining Jack input/output channels!");
// TODO : airtaudio::errorWarning;
return info;
}
@ -195,7 +195,7 @@ airtaudio::DeviceInfo airtaudio::api::Jack::getDeviceInfo(uint32_t _device) {
info.duplexChannels = (info.outputChannels > info.inputChannels) ? info.inputChannels : info.outputChannels;
}
// Jack always uses 32-bit floats.
info.nativeFormats = airtaudio::FLOAT32;
info.nativeFormats.push_back(audio::format_float);
// Jack doesn't provide default devices so we'll use the first available one.
if ( _device == 0
&& info.outputChannels > 0) {
@ -260,7 +260,7 @@ bool airtaudio::api::Jack::probeDeviceOpen(uint32_t _device,
uint32_t _channels,
uint32_t _firstChannel,
uint32_t _sampleRate,
airtaudio::format _format,
audio::format _format,
uint32_t* _bufferSize,
airtaudio::StreamOptions* _options) {
JackHandle *handle = (JackHandle *) m_stream.apiHandle;
@ -277,7 +277,7 @@ bool airtaudio::api::Jack::probeDeviceOpen(uint32_t _device,
client = jack_client_open("RtApiJack", jackoptions, status);
}
if (client == 0) {
ATA_ERROR("airtaudio::api::Jack::probeDeviceOpen: Jack server not found or connection error!");
ATA_ERROR("Jack server not found or connection error!");
return false;
}
} else {
@ -308,7 +308,7 @@ bool airtaudio::api::Jack::probeDeviceOpen(uint32_t _device,
free(ports);
}
if (_device >= nDevices) {
ATA_ERROR("airtaudio::api::Jack::probeDeviceOpen: device ID is invalid!");
ATA_ERROR("device ID is invalid!");
return false;
}
// Count the available ports containing the client name as device
@ -325,14 +325,14 @@ bool airtaudio::api::Jack::probeDeviceOpen(uint32_t _device,
}
// Compare the jack ports for specified client to the requested number of channels.
if (nChannels < (_channels + _firstChannel)) {
ATA_ERROR("airtaudio::api::Jack::probeDeviceOpen: requested number of channels (" << _channels << ") + offset (" << _firstChannel << ") not found for specified device (" << _device << ":" << deviceName << ").");
ATA_ERROR("requested number of channels (" << _channels << ") + offset (" << _firstChannel << ") not found for specified device (" << _device << ":" << deviceName << ").");
return false;
}
// Check the jack server sample rate.
uint32_t jackRate = jack_get_sample_rate(client);
if (_sampleRate != jackRate) {
jack_client_close(client);
ATA_ERROR("airtaudio::api::Jack::probeDeviceOpen: the requested sample rate (" << _sampleRate << ") is different than the JACK server rate (" << jackRate << ").");
ATA_ERROR("the requested sample rate (" << _sampleRate << ") is different than the JACK server rate (" << jackRate << ").");
return false;
}
m_stream.sampleRate = jackRate;
@ -381,7 +381,7 @@ bool airtaudio::api::Jack::probeDeviceOpen(uint32_t _device,
if (handle == 0) {
handle = new JackHandle;
if (handle == nullptr) {
ATA_ERROR("airtaudio::api::Jack::probeDeviceOpen: error allocating JackHandle memory.");
ATA_ERROR("error allocating JackHandle memory.");
goto error;
}
m_stream.apiHandle = (void *) handle;
@ -393,7 +393,7 @@ bool airtaudio::api::Jack::probeDeviceOpen(uint32_t _device,
bufferBytes = m_stream.nUserChannels[_mode] * *_bufferSize * formatBytes(m_stream.userFormat);
m_stream.userBuffer[_mode] = (char *) calloc(bufferBytes, 1);
if (m_stream.userBuffer[_mode] == nullptr) {
ATA_ERROR("airtaudio::api::Jack::probeDeviceOpen: error allocating user buffer memory.");
ATA_ERROR("error allocating user buffer memory.");
goto error;
}
if (m_stream.doConvertBuffer[_mode]) {
@ -414,7 +414,7 @@ bool airtaudio::api::Jack::probeDeviceOpen(uint32_t _device,
if (m_stream.deviceBuffer) free(m_stream.deviceBuffer);
m_stream.deviceBuffer = (char *) calloc(bufferBytes, 1);
if (m_stream.deviceBuffer == nullptr) {
ATA_ERROR("airtaudio::api::Jack::probeDeviceOpen: error allocating device buffer memory.");
ATA_ERROR("error allocating device buffer memory.");
goto error;
}
}
@ -422,7 +422,7 @@ bool airtaudio::api::Jack::probeDeviceOpen(uint32_t _device,
// Allocate memory for the Jack ports (channels) identifiers.
handle->ports[_mode] = (jack_port_t **) malloc (sizeof (jack_port_t *) * _channels);
if (handle->ports[_mode] == nullptr) {
ATA_ERROR("airtaudio::api::Jack::probeDeviceOpen: error allocating port memory.");
ATA_ERROR("error allocating port memory.");
goto error;
}
m_stream.device[_mode] = _device;
@ -494,7 +494,7 @@ error:
enum airtaudio::errorType airtaudio::api::Jack::closeStream() {
if (m_stream.state == STREAM_CLOSED) {
ATA_ERROR("airtaudio::api::Jack::closeStream(): no open stream to close!");
ATA_ERROR("no open stream to close!");
return airtaudio::errorWarning;
}
JackHandle *handle = (JackHandle *) m_stream.apiHandle;
@ -534,13 +534,13 @@ enum airtaudio::errorType airtaudio::api::Jack::startStream() {
return airtaudio::errorFail;
}
if (m_stream.state == STREAM_RUNNING) {
ATA_ERROR("airtaudio::api::Jack::startStream(): the stream is already running!");
ATA_ERROR("the stream is already running!");
return airtaudio::errorWarning;
}
JackHandle *handle = (JackHandle *) m_stream.apiHandle;
int32_t result = jack_activate(handle->client);
if (result) {
ATA_ERROR("airtaudio::api::Jack::startStream(): unable to activate JACK client!");
ATA_ERROR("unable to activate JACK client!");
goto unlock;
}
const char **ports;
@ -550,7 +550,7 @@ enum airtaudio::errorType airtaudio::api::Jack::startStream() {
result = 1;
ports = jack_get_ports(handle->client, handle->deviceName[0].c_str(), nullptr, JackPortIsInput);
if (ports == nullptr) {
ATA_ERROR("airtaudio::api::Jack::startStream(): error determining available JACK input ports!");
ATA_ERROR("error determining available JACK input ports!");
goto unlock;
}
// Now make the port connections. Since RtAudio wasn't designed to
@ -562,7 +562,7 @@ enum airtaudio::errorType airtaudio::api::Jack::startStream() {
result = jack_connect(handle->client, jack_port_name(handle->ports[0][i]), ports[ m_stream.channelOffset[0] + i ]);
if (result) {
free(ports);
ATA_ERROR("airtaudio::api::Jack::startStream(): error connecting output ports!");
ATA_ERROR("error connecting output ports!");
goto unlock;
}
}
@ -573,7 +573,7 @@ enum airtaudio::errorType airtaudio::api::Jack::startStream() {
result = 1;
ports = jack_get_ports(handle->client, handle->deviceName[1].c_str(), nullptr, JackPortIsOutput);
if (ports == nullptr) {
ATA_ERROR("airtaudio::api::Jack::startStream(): error determining available JACK output ports!");
ATA_ERROR("error determining available JACK output ports!");
goto unlock;
}
// Now make the port connections. See note above.
@ -584,7 +584,7 @@ enum airtaudio::errorType airtaudio::api::Jack::startStream() {
}
if (result) {
free(ports);
ATA_ERROR("airtaudio::api::Jack::startStream(): error connecting input ports!");
ATA_ERROR("error connecting input ports!");
goto unlock;
}
}
@ -605,7 +605,7 @@ enum airtaudio::errorType airtaudio::api::Jack::stopStream() {
return airtaudio::errorFail;
}
if (m_stream.state == STREAM_STOPPED) {
ATA_ERROR("airtaudio::api::Jack::stopStream(): the stream is already stopped!");
ATA_ERROR("the stream is already stopped!");
return airtaudio::errorWarning;
}
JackHandle *handle = (JackHandle *) m_stream.apiHandle;
@ -627,7 +627,7 @@ enum airtaudio::errorType airtaudio::api::Jack::abortStream() {
return airtaudio::errorFail;
}
if (m_stream.state == STREAM_STOPPED) {
ATA_ERROR("airtaudio::api::Jack::abortStream(): the stream is already stopped!");
ATA_ERROR("the stream is already stopped!");
return airtaudio::errorWarning;
}
JackHandle *handle = (JackHandle *) m_stream.apiHandle;

2
airtaudio/api/Jack.h
View File

@ -38,7 +38,7 @@ namespace airtaudio {
uint32_t _channels,
uint32_t _firstChannel,
uint32_t _sampleRate,
airtaudio::format _format,
audio::format _format,
uint32_t *_bufferSize,
airtaudio::StreamOptions *_options);
};

104
airtaudio/api/Oss.cpp
View File

@ -57,13 +57,13 @@ airtaudio::api::Oss::~Oss() {
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'.");
ATA_ERROR("error opening '/dev/mixer'.");
return 0;
}
oss_sysinfo sysinfo;
if (ioctl(mixerfd, SNDCTL_SYSINFO, &sysinfo) == -1) {
close(mixerfd);
ATA_ERROR("airtaudio::api::Oss::getDeviceCount: error getting sysinfo, OSS version >= 4.0 is required.");
ATA_ERROR("error getting sysinfo, OSS version >= 4.0 is required.");
return 0;
}
close(mixerfd);
@ -75,25 +75,25 @@ airtaudio::DeviceInfo airtaudio::api::Oss::getDeviceInfo(uint32_t _device) {
info.probed = false;
int32_t mixerfd = open("/dev/mixer", O_RDWR, 0);
if (mixerfd == -1) {
ATA_ERROR("airtaudio::api::Oss::getDeviceInfo: error opening '/dev/mixer'.");
ATA_ERROR("error opening '/dev/mixer'.");
return info;
}
oss_sysinfo sysinfo;
int32_t result = ioctl(mixerfd, SNDCTL_SYSINFO, &sysinfo);
if (result == -1) {
close(mixerfd);
ATA_ERROR("airtaudio::api::Oss::getDeviceInfo: error getting sysinfo, OSS version >= 4.0 is required.");
ATA_ERROR("error getting sysinfo, OSS version >= 4.0 is required.");
return info;
}
unsigned nDevices = sysinfo.numaudios;
if (nDevices == 0) {
close(mixerfd);
ATA_ERROR("airtaudio::api::Oss::getDeviceInfo: no devices found!");
ATA_ERROR("no devices found!");
return info;
}
if (_device >= nDevices) {
close(mixerfd);
ATA_ERROR("airtaudio::api::Oss::getDeviceInfo: device ID is invalid!");
ATA_ERROR("device ID is invalid!");
return info;
}
oss_audioinfo ainfo;
@ -101,7 +101,7 @@ airtaudio::DeviceInfo airtaudio::api::Oss::getDeviceInfo(uint32_t _device) {
result = ioctl(mixerfd, SNDCTL_AUDIOINFO, &ainfo);
close(mixerfd);
if (result == -1) {
ATA_ERROR("airtaudio::api::Oss::getDeviceInfo: error getting device (" << ainfo.name << ") info.");
ATA_ERROR("error getting device (" << ainfo.name << ") info.");
error(airtaudio::errorWarning);
return info;
}
@ -123,25 +123,25 @@ airtaudio::DeviceInfo airtaudio::api::Oss::getDeviceInfo(uint32_t _device) {
uint64_t mask = ainfo.iformats;
if ( mask & AFMT_S16_LE
|| mask & AFMT_S16_BE) {
info.nativeFormats |= RTAUDIO_SINT16;
info.nativeFormats.push_back(audio::format_int16);
}
if (mask & AFMT_S8) {
info.nativeFormats |= RTAUDIO_SINT8;
info.nativeFormats.push_back(audio::format_int8);
}
if ( mask & AFMT_S32_LE
|| mask & AFMT_S32_BE) {
info.nativeFormats |= RTAUDIO_SINT32;
info.nativeFormats.push_back(audio::format_int32);
}
if (mask & AFMT_FLOAT) {
info.nativeFormats |= RTAUDIO_FLOAT32;
info.nativeFormats.push_back(audio::format_float);
}
if ( mask & AFMT_S24_LE
|| mask & AFMT_S24_BE) {
info.nativeFormats |= RTAUDIO_SINT24;
info.nativeFormats.push_back(audio::format_int24);
}
// Check that we have at least one supported format
if (info.nativeFormats == 0) {
ATA_ERROR("airtaudio::api::Oss::getDeviceInfo: device (" << ainfo.name << ") data format not supported by RtAudio.");
ATA_ERROR("device (" << ainfo.name << ") data format not supported by RtAudio.");
return info;
}
// Probe the supported sample rates.
@ -165,7 +165,7 @@ airtaudio::DeviceInfo airtaudio::api::Oss::getDeviceInfo(uint32_t _device) {
}
}
if (info.sampleRates.size() == 0) {
ATA_ERROR("airtaudio::api::Oss::getDeviceInfo: no supported sample rates found for device (" << ainfo.name << ").");
ATA_ERROR("no supported sample rates found for device (" << ainfo.name << ").");
} else {
info.probed = true;
info.name = ainfo.name;
@ -183,27 +183,27 @@ bool airtaudio::api::Oss::probeDeviceOpen(uint32_t _device,
rtaudio::StreamOptions* _options) {
int32_t mixerfd = open("/dev/mixer", O_RDWR, 0);
if (mixerfd == -1) {
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: error opening '/dev/mixer'.");
ATA_ERROR("error opening '/dev/mixer'.");
return false;
}
oss_sysinfo sysinfo;
int32_t result = ioctl(mixerfd, SNDCTL_SYSINFO, &sysinfo);
if (result == -1) {
close(mixerfd);
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: error getting sysinfo, OSS version >= 4.0 is required.");
ATA_ERROR("error getting sysinfo, OSS version >= 4.0 is required.");
return false;
}
unsigned nDevices = sysinfo.numaudios;
if (nDevices == 0) {
// This should not happen because a check is made before this function is called.
close(mixerfd);
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: no devices found!");
ATA_ERROR("no devices found!");
return false;
}
if (_device >= nDevices) {
// This should not happen because a check is made before this function is called.
close(mixerfd);
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: device ID is invalid!");
ATA_ERROR("device ID is invalid!");
return false;
}
oss_audioinfo ainfo;
@ -211,7 +211,7 @@ bool airtaudio::api::Oss::probeDeviceOpen(uint32_t _device,
result = ioctl(mixerfd, SNDCTL_AUDIOINFO, &ainfo);
close(mixerfd);
if (result == -1) {
ATA_ERROR("airtaudio::api::Oss::getDeviceInfo: error getting device (" << ainfo.name << ") info.");
ATA_ERROR("error getting device (" << ainfo.name << ") info.");
return false;
}
// Check if device supports input or output
@ -220,9 +220,9 @@ bool airtaudio::api::Oss::probeDeviceOpen(uint32_t _device,
|| ( _mode == INPUT
&& !(ainfo.caps & PCM_CAP_INPUT))) {
if (_mode == OUTPUT) {
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: device (" << ainfo.name << ") does not support output.");
ATA_ERROR("device (" << ainfo.name << ") does not support output.");
} else {
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: device (" << ainfo.name << ") does not support input.");
ATA_ERROR("device (" << ainfo.name << ") does not support input.");
}
return false;
}
@ -237,12 +237,12 @@ bool airtaudio::api::Oss::probeDeviceOpen(uint32_t _device,
close(handle->id[0]);
handle->id[0] = 0;
if (!(ainfo.caps & PCM_CAP_DUPLEX)) {
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: device (" << ainfo.name << ") does not support duplex mode.");
ATA_ERROR("device (" << ainfo.name << ") does not support duplex mode.");
return false;
}
// Check that the number previously set channels is the same.
if (m_stream.nUserChannels[0] != _channels) {
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: input/output channels must be equal for OSS duplex device (" << ainfo.name << ").");
ATA_ERROR("input/output channels must be equal for OSS duplex device (" << ainfo.name << ").");
return false;
}
flags |= O_RDWR;
@ -260,9 +260,9 @@ bool airtaudio::api::Oss::probeDeviceOpen(uint32_t _device,
fd = open(ainfo.devnode, flags, 0);
if (fd == -1) {
if (errno == EBUSY) {
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: device (" << ainfo.name << ") is busy.");
ATA_ERROR("device (" << ainfo.name << ") is busy.");
} else {
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: error opening device (" << ainfo.name << ").");
ATA_ERROR("error opening device (" << ainfo.name << ").");
}
return false;
}
@ -271,7 +271,7 @@ bool airtaudio::api::Oss::probeDeviceOpen(uint32_t _device,
if (flags | O_RDWR) {
result = ioctl(fd, SNDCTL_DSP_SETDUPLEX, nullptr);
if (result == -1) {
m_errorStream << "airtaudio::api::Oss::probeDeviceOpen: error setting duplex mode for device (" << ainfo.name << ").";
m_errorStream << "error setting duplex mode for device (" << ainfo.name << ").";
m_errorText = m_errorStream.str();
return false;
}
@ -281,7 +281,7 @@ bool airtaudio::api::Oss::probeDeviceOpen(uint32_t _device,
m_stream.nUserChannels[_mode] = _channels;
if (ainfo.max_channels < (int)(_channels + _firstChannel)) {
close(fd);
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: the device (" << ainfo.name << ") does not support requested channel parameters.");
ATA_ERROR("the device (" << ainfo.name << ") does not support requested channel parameters.");
return false;
}
// Set the number of channels.
@ -290,7 +290,7 @@ bool airtaudio::api::Oss::probeDeviceOpen(uint32_t _device,
if ( result == -1
|| deviceChannels < (int)(_channels + _firstChannel)) {
close(fd);
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: error setting channel parameters on device (" << ainfo.name << ").");
ATA_ERROR("error setting channel parameters on device (" << ainfo.name << ").");
return false;
}
m_stream.nDeviceChannels[_mode] = deviceChannels;
@ -299,7 +299,7 @@ bool airtaudio::api::Oss::probeDeviceOpen(uint32_t _device,
result = ioctl(fd, SNDCTL_DSP_GETFMTS, &mask);
if (result == -1) {
close(fd);
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: error getting device (" << ainfo.name << ") data formats.");
ATA_ERROR("error getting device (" << ainfo.name << ") data formats.");
return false;
}
// Determine how to set the device format.
@ -370,7 +370,7 @@ bool airtaudio::api::Oss::probeDeviceOpen(uint32_t _device,
if (m_stream.deviceFormat[_mode] == 0) {
// This really shouldn't happen ...
close(fd);
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: device (" << ainfo.name << ") data format not supported by RtAudio.");
ATA_ERROR("device (" << ainfo.name << ") data format not supported by RtAudio.");
return false;
}
// Set the data format.
@ -379,7 +379,7 @@ bool airtaudio::api::Oss::probeDeviceOpen(uint32_t _device,
if ( result == -1
|| deviceFormat != temp) {
close(fd);
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: error setting data format on device (" << ainfo.name << ").");
ATA_ERROR("error setting data format on device (" << ainfo.name << ").");
return false;
}
// Attempt to set the buffer size. According to OSS, the minimum
@ -408,7 +408,7 @@ bool airtaudio::api::Oss::probeDeviceOpen(uint32_t _device,
result = ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &temp);
if (result == -1) {
close(fd);
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: error setting buffer size on device (" << ainfo.name << ").");
ATA_ERROR("error setting buffer size on device (" << ainfo.name << ").");
return false;
}
m_stream.nBuffers = buffers;
@ -420,13 +420,13 @@ bool airtaudio::api::Oss::probeDeviceOpen(uint32_t _device,
result = ioctl(fd, SNDCTL_DSP_SPEED, &srate);
if (result == -1) {
close(fd);
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: error setting sample rate (" << _sampleRate << ") on device (" << ainfo.name << ").");
ATA_ERROR("error setting sample rate (" << _sampleRate << ") on device (" << ainfo.name << ").");
return false;
}
// Verify the sample rate setup worked.
if (abs(srate - _sampleRate) > 100) {
close(fd);
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: device (" << ainfo.name << ") does not support sample rate (" << _sampleRate << ").");
ATA_ERROR("device (" << ainfo.name << ") does not support sample rate (" << _sampleRate << ").");
return false;
}
m_stream.sampleRate = _sampleRate;
@ -459,7 +459,7 @@ bool airtaudio::api::Oss::probeDeviceOpen(uint32_t _device,
if (m_stream.apiHandle == 0) {
handle = new OssHandle;
if handle == nullptr) {
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: error allocating OssHandle memory.");
ATA_ERROR("error allocating OssHandle memory.");
goto error;
}
m_stream.apiHandle = (void *) handle;
@ -472,7 +472,7 @@ bool airtaudio::api::Oss::probeDeviceOpen(uint32_t _device,
bufferBytes = m_stream.nUserChannels[_mode] * *_bufferSize * formatBytes(m_stream.userFormat);
m_stream.userBuffer[_mode] = (char *) calloc(bufferBytes, 1);
if (m_stream.userBuffer[_mode] == nullptr) {
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: error allocating user buffer memory.");
ATA_ERROR("error allocating user buffer memory.");
goto error;
}
if (m_stream.doConvertBuffer[_mode]) {
@ -494,7 +494,7 @@ bool airtaudio::api::Oss::probeDeviceOpen(uint32_t _device,
}
m_stream.deviceBuffer = (char *) calloc(bufferBytes, 1);
if (m_stream.deviceBuffer == nullptr) {
ATA_ERROR("airtaudio::api::Oss::probeDeviceOpen: error allocating device buffer memory.");
ATA_ERROR("error allocating device buffer memory.");
goto error;
}
}
@ -520,7 +520,7 @@ bool airtaudio::api::Oss::probeDeviceOpen(uint32_t _device,
m_stream.callbackInfo.thread = new std::thread(ossCallbackHandler, &m_stream.callbackInfo);
if (m_stream.callbackInfo.thread == nullptr) {
m_stream.callbackInfo.isRunning = false;
ATA_ERROR("airtaudio::api::Oss::error creating callback thread!");
ATA_ERROR("creating callback thread!");
goto error;
}
}
@ -551,7 +551,7 @@ error:
enum airtaudio::errorType airtaudio::api::Oss::closeStream() {
if (m_stream.state == STREAM_CLOSED) {
ATA_ERROR("airtaudio::api::Oss::closeStream(): no open stream to close!");
ATA_ERROR("no open stream to close!");
return airtaudio::errorWarning;
}
OssHandle *handle = (OssHandle *) m_stream.apiHandle;
@ -600,7 +600,7 @@ enum airtaudio::errorType airtaudio::api::Oss::startStream() {
return airtaudio::errorFail;
}
if (m_stream.state == STREAM_RUNNING) {
ATA_ERROR("airtaudio::api::Oss::startStream(): the stream is already running!");
ATA_ERROR("the stream is already running!");
return airtaudio::errorWarning;
}
m_stream.mutex.lock();
@ -617,7 +617,7 @@ enum airtaudio::errorType airtaudio::api::Oss::stopStream() {
return airtaudio::errorFail;
}
if (m_stream.state == STREAM_STOPPED) {
ATA_ERROR("airtaudio::api::Oss::stopStream(): the stream is already stopped!");
ATA_ERROR("the stream is already stopped!");
return;
}
m_stream.mutex.lock();
@ -633,7 +633,7 @@ enum airtaudio::errorType airtaudio::api::Oss::stopStream() {
// Flush the output with zeros a few times.
char *buffer;
int32_t samples;
airtaudio::format format;
audio::format format;
if (m_stream.doConvertBuffer[0]) {
buffer = m_stream.deviceBuffer;
samples = m_stream.bufferSize * m_stream.nDeviceChannels[0];
@ -647,13 +647,13 @@ enum airtaudio::errorType airtaudio::api::Oss::stopStream() {
for (uint32_t i=0; i<m_stream.nBuffers+1; i++) {
result = write(handle->id[0], buffer, samples * formatBytes(format));
if (result == -1) {
ATA_ERROR("airtaudio::api::Oss::stopStream: audio write error.");
ATA_ERROR("audio write error.");
return airtaudio::errorWarning;
}
}
result = ioctl(handle->id[0], SNDCTL_DSP_HALT, 0);
if (result == -1) {
ATA_ERROR("airtaudio::api::Oss::stopStream: system error stopping callback procedure on device (" << m_stream.device[0] << ").");
ATA_ERROR("system error stopping callback procedure on device (" << m_stream.device[0] << ").");
goto unlock;
}
handle->triggered = false;
@ -663,7 +663,7 @@ enum airtaudio::errorType airtaudio::api::Oss::stopStream() {
&& handle->id[0] != handle->id[1])) {
result = ioctl(handle->id[1], SNDCTL_DSP_HALT, 0);
if (result == -1) {
ATA_ERROR("airtaudio::api::Oss::stopStream: system error stopping input callback procedure on device (" << m_stream.device[0] << ").");
ATA_ERROR("system error stopping input callback procedure on device (" << m_stream.device[0] << ").");
goto unlock;
}
}
@ -681,7 +681,7 @@ enum airtaudio::errorType airtaudio::api::Oss::abortStream() {
return airtaudio::errorFail;
}
if (m_stream.state == STREAM_STOPPED) {
ATA_ERROR("airtaudio::api::Oss::abortStream(): the stream is already stopped!");
ATA_ERROR("the stream is already stopped!");
return airtaudio::errorWarning;
}
m_stream.mutex.lock();
@ -695,7 +695,7 @@ enum airtaudio::errorType airtaudio::api::Oss::abortStream() {
if (m_stream.mode == OUTPUT || m_stream.mode == DUPLEX) {
result = ioctl(handle->id[0], SNDCTL_DSP_HALT, 0);
if (result == -1) {
ATA_ERROR("airtaudio::api::Oss::abortStream: system error stopping callback procedure on device (" << m_stream.device[0] << ").");
ATA_ERROR("system error stopping callback procedure on device (" << m_stream.device[0] << ").");
goto unlock;
}
handle->triggered = false;
@ -703,7 +703,7 @@ enum airtaudio::errorType airtaudio::api::Oss::abortStream() {
if (m_stream.mode == INPUT || (m_stream.mode == DUPLEX && handle->id[0] != handle->id[1])) {
result = ioctl(handle->id[1], SNDCTL_DSP_HALT, 0);
if (result == -1) {
ATA_ERROR("airtaudio::api::Oss::abortStream: system error stopping input callback procedure on device (" << m_stream.device[0] << ").");
ATA_ERROR("system error stopping input callback procedure on device (" << m_stream.device[0] << ").");
goto unlock;
}
}
@ -726,7 +726,7 @@ void airtaudio::api::Oss::callbackEvent() {
}
}
if (m_stream.state == STREAM_CLOSED) {
ATA_ERROR("airtaudio::api::Oss::callbackEvent(): the stream is closed ... this shouldn't happen!");
ATA_ERROR("the stream is closed ... this shouldn't happen!");
return airtaudio::errorWarning;
}
// Invoke user callback to get fresh output data.
@ -760,7 +760,7 @@ void airtaudio::api::Oss::callbackEvent() {
int32_t result;
char *buffer;
int32_t samples;
airtaudio::format format;
audio::format format;
if ( m_stream.mode == OUTPUT
|| m_stream.mode == DUPLEX) {
// Setup parameters and do buffer conversion if necessary.
@ -794,7 +794,7 @@ void airtaudio::api::Oss::callbackEvent() {
// We'll assume this is an underrun, though there isn't a
// specific means for determining that.
handle->xrun[0] = true;
ATA_ERROR("airtaudio::api::Oss::callbackEvent: audio write error.");
ATA_ERROR("audio write error.");
//error(airtaudio::errorWarning);
// Continue on to input section.
}
@ -817,7 +817,7 @@ void airtaudio::api::Oss::callbackEvent() {
// We'll assume this is an overrun, though there isn't a
// specific means for determining that.
handle->xrun[1] = true;
ATA_ERROR("airtaudio::api::Oss::callbackEvent: audio read error.");
ATA_ERROR("audio read error.");
goto unlock;
}
// Do byte swapping if necessary.

2
airtaudio/api/Oss.h
View File

@ -37,7 +37,7 @@ namespace airtaudio {
uint32_t _channels,
uint32_t _firstChannel,
uint32_t _sampleRate,
airtaudio::format _format,
audio::format _format,
uint32_t *_bufferSize,
airtaudio::StreamOptions *_options);
};

54
airtaudio/api/Pulse.cpp
View File

@ -40,14 +40,14 @@ static const uint32_t SUPPORTED_SAMPLERATES[] = {
};
struct rtaudio_pa_format_mapping_t {
airtaudio::format airtaudio_format;
audio::format airtaudio_format;
pa_sample_format_t pa_format;
};
static const rtaudio_pa_format_mapping_t supported_sampleformats[] = {
{airtaudio::SINT16, PA_SAMPLE_S16LE},
{airtaudio::SINT32, PA_SAMPLE_S32LE},
{airtaudio::FLOAT32, PA_SAMPLE_FLOAT32LE},
{audio::format_int16, PA_SAMPLE_S16LE},
{audio::format_int32, PA_SAMPLE_S32LE},
{audio::format_float, PA_SAMPLE_FLOAT32LE},
{0, PA_SAMPLE_INVALID}};
struct PulseAudioHandle {
@ -86,7 +86,9 @@ airtaudio::DeviceInfo airtaudio::api::Pulse::getDeviceInfo(uint32_t _device) {
for (const uint32_t *sr = SUPPORTED_SAMPLERATES; *sr; ++sr) {
info.sampleRates.push_back(*sr);
}
info.nativeFormats = SINT16 | SINT32 | FLOAT32;
info.nativeFormats.push_back(audio::format_int16);
info.nativeFormats.push_back(audio::format_int32);
info.nativeFormats.push_back(audio::format_float);
return info;
}
@ -146,7 +148,7 @@ void airtaudio::api::Pulse::callbackEvent() {
}
}
if (m_stream.state == STREAM_CLOSED) {
ATA_ERROR("airtaudio::api::Pulse::callbackEvent(): the stream is closed ... this shouldn't happen!");
ATA_ERROR("the stream is closed ... this shouldn't happen!");
return;
}
double streamTime = getStreamTime();
@ -179,7 +181,7 @@ void airtaudio::api::Pulse::callbackEvent() {
bytes = m_stream.nUserChannels[OUTPUT] * m_stream.bufferSize * formatBytes(m_stream.userFormat);
}
if (pa_simple_write(pah->s_play, pulse_out, bytes, &pa_error) < 0) {
ATA_ERROR("airtaudio::api::Pulse::callbackEvent: audio write error, " << pa_strerror(pa_error) << ".");
ATA_ERROR("audio write error, " << pa_strerror(pa_error) << ".");
return;
}
}
@ -190,7 +192,7 @@ void airtaudio::api::Pulse::callbackEvent() {
bytes = m_stream.nUserChannels[INPUT] * m_stream.bufferSize * formatBytes(m_stream.userFormat);
}
if (pa_simple_read(pah->s_rec, pulse_in, bytes, &pa_error) < 0) {
ATA_ERROR("airtaudio::api::Pulse::callbackEvent: audio read error, " << pa_strerror(pa_error) << ".");
ATA_ERROR("audio read error, " << pa_strerror(pa_error) << ".");
return;
}
if (m_stream.doConvertBuffer[INPUT]) {
@ -212,11 +214,11 @@ unlock:
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!");
ATA_ERROR("the stream is not open!");
return airtaudio::errorInvalidUse;
}
if (m_stream.state == STREAM_RUNNING) {
ATA_ERROR("airtaudio::api::Pulse::startStream(): the stream is already running!");
ATA_ERROR("the stream is already running!");
return airtaudio::errorWarning;
}
m_stream.mutex.lock();
@ -230,11 +232,11 @@ enum airtaudio::errorType airtaudio::api::Pulse::startStream() {
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!");
ATA_ERROR("the stream is not open!");
return airtaudio::errorInvalidUse;
}
if (m_stream.state == STREAM_STOPPED) {
ATA_ERROR("airtaudio::api::Pulse::stopStream(): the stream is already stopped!");
ATA_ERROR("the stream is already stopped!");
return airtaudio::errorWarning;
}
m_stream.state = STREAM_STOPPED;
@ -242,7 +244,7 @@ enum airtaudio::errorType airtaudio::api::Pulse::stopStream() {
if (pah && pah->s_play) {
int32_t pa_error;
if (pa_simple_drain(pah->s_play, &pa_error) < 0) {
ATA_ERROR("airtaudio::api::Pulse::stopStream: error draining output device, " << pa_strerror(pa_error) << ".");
ATA_ERROR("error draining output device, " << pa_strerror(pa_error) << ".");
m_stream.mutex.unlock();
return airtaudio::errorSystemError;
}
@ -255,11 +257,11 @@ enum airtaudio::errorType airtaudio::api::Pulse::stopStream() {
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!");
ATA_ERROR("the stream is not open!");
return airtaudio::errorInvalidUse;
}
if (m_stream.state == STREAM_STOPPED) {
ATA_ERROR("airtaudio::api::Pulse::abortStream(): the stream is already stopped!");
ATA_ERROR("the stream is already stopped!");
return airtaudio::errorWarning;
}
m_stream.state = STREAM_STOPPED;
@ -267,7 +269,7 @@ enum airtaudio::errorType airtaudio::api::Pulse::abortStream() {
if (pah && pah->s_play) {
int32_t pa_error;
if (pa_simple_flush(pah->s_play, &pa_error) < 0) {
ATA_ERROR("airtaudio::api::Pulse::abortStream: error flushing output device, " << pa_strerror(pa_error) << ".");
ATA_ERROR("error flushing output device, " << pa_strerror(pa_error) << ".");
m_stream.mutex.unlock();
return airtaudio::errorSystemError;
}
@ -282,7 +284,7 @@ bool airtaudio::api::Pulse::probeDeviceOpen(uint32_t _device,
uint32_t _channels,
uint32_t _firstChannel,
uint32_t _sampleRate,
airtaudio::format _format,
audio::format _format,
uint32_t *_bufferSize,
airtaudio::StreamOptions *_options) {
PulseAudioHandle *pah = 0;
@ -295,7 +297,7 @@ bool airtaudio::api::Pulse::probeDeviceOpen(uint32_t _device,
return false;
}
if (_channels != 1 && _channels != 2) {
ATA_ERROR("airtaudio::api::Pulse::probeDeviceOpen: unsupported number of channels.");
ATA_ERROR("unsupported number of channels.");
return false;
}
ss.channels = _channels;
@ -312,7 +314,7 @@ bool airtaudio::api::Pulse::probeDeviceOpen(uint32_t _device,
}
}
if (!sr_found) {
ATA_ERROR("airtaudio::api::Pulse::probeDeviceOpen: unsupported sample rate.");
ATA_ERROR("unsupported sample rate.");
return false;
}
bool sf_found = 0;
@ -327,7 +329,7 @@ bool airtaudio::api::Pulse::probeDeviceOpen(uint32_t _device,
}
}
if (!sf_found) {
ATA_ERROR("airtaudio::api::Pulse::probeDeviceOpen: unsupported sample format.");
ATA_ERROR("unsupported sample format.");
return false;
}
// Set interleaving parameters.
@ -348,7 +350,7 @@ bool airtaudio::api::Pulse::probeDeviceOpen(uint32_t _device,
bufferBytes = m_stream.nUserChannels[_mode] * *_bufferSize * formatBytes(m_stream.userFormat);
m_stream.userBuffer[_mode] = (char *) calloc(bufferBytes, 1);
if (m_stream.userBuffer[_mode] == nullptr) {
ATA_ERROR("airtaudio::api::Pulse::probeDeviceOpen: error allocating user buffer memory.");
ATA_ERROR("error allocating user buffer memory.");
goto error;
}
m_stream.bufferSize = *_bufferSize;
@ -366,7 +368,7 @@ bool airtaudio::api::Pulse::probeDeviceOpen(uint32_t _device,
if (m_stream.deviceBuffer) free(m_stream.deviceBuffer);
m_stream.deviceBuffer = (char *) calloc(bufferBytes, 1);
if (m_stream.deviceBuffer == nullptr) {
ATA_ERROR("airtaudio::api::Pulse::probeDeviceOpen: error allocating device buffer memory.");
ATA_ERROR("error allocating device buffer memory.");
goto error;
}
}
@ -379,7 +381,7 @@ bool airtaudio::api::Pulse::probeDeviceOpen(uint32_t _device,
if (!m_stream.apiHandle) {
PulseAudioHandle *pah = new PulseAudioHandle;
if (!pah) {
ATA_ERROR("airtaudio::api::Pulse::probeDeviceOpen: error allocating memory for handle.");
ATA_ERROR("error allocating memory for handle.");
goto error;
}
m_stream.apiHandle = pah;
@ -390,14 +392,14 @@ bool airtaudio::api::Pulse::probeDeviceOpen(uint32_t _device,
case INPUT:
pah->s_rec = pa_simple_new(nullptr, "airtAudio", PA_STREAM_RECORD, nullptr, "Record", &ss, nullptr, nullptr, &error);
if (!pah->s_rec) {
ATA_ERROR("airtaudio::api::Pulse::probeDeviceOpen: error connecting input to PulseAudio server.");
ATA_ERROR("error connecting input to PulseAudio server.");
goto error;
}
break;
case OUTPUT:
pah->s_play = pa_simple_new(nullptr, "airtAudio", PA_STREAM_PLAYBACK, nullptr, "Playback", &ss, nullptr, nullptr, &error);
if (!pah->s_play) {
ATA_ERROR("airtaudio::api::Pulse::probeDeviceOpen: error connecting output to PulseAudio server.");
ATA_ERROR("error connecting output to PulseAudio server.");
goto error;
}
break;
@ -416,7 +418,7 @@ bool airtaudio::api::Pulse::probeDeviceOpen(uint32_t _device,
m_stream.callbackInfo.isRunning = true;
pah->thread = new std::thread(pulseaudio_callback, (void *)&m_stream.callbackInfo);
if (pah->thread == nullptr) {
ATA_ERROR("airtaudio::api::Pulse::probeDeviceOpen: error creating thread.");
ATA_ERROR("error creating thread.");
goto error;
}
}

2
airtaudio/api/Pulse.h
View File

@ -38,7 +38,7 @@ namespace airtaudio {
uint32_t _channels,
uint32_t _firstChannel,
uint32_t _sampleRate,
airtaudio::format _format,
audio::format _format,
uint32_t *_bufferSize,
airtaudio::StreamOptions *_options);
};

2
airtaudio/base.cpp
View File

@ -35,7 +35,7 @@ std::ostream& airtaudio::operator <<(std::ostream& _os, enum errorType _obj) {
return _os;
}
std::ostream& airtaudio::operator <<(std::ostream& _os, const airtaudio::format& _obj) {
std::ostream& airtaudio::operator <<(std::ostream& _os, const audio::format& _obj) {
switch(_obj) {
case SINT8:
_os << "SINT8";

31
airtaudio/base.h
View File

@ -13,6 +13,8 @@
#include <condition_variable>
#include <mutex>
#include <functional>
#include <audio/channel.h>
#include <audio/format.h>
// defien type : uintXX_t and intXX_t
#define __STDC_LIMIT_MACROS
@ -37,35 +39,6 @@ namespace airtaudio {
// airtaudio version
static const std::string VERSION("4.0.12");
/**
* @brief Debug operator To display the curent element in a Human redeable information
*/
//std::ostream& operator <<(std::ostream& _os, enum errorType _obj);
/**
* @typedef typedef uint64_t format;
* @brief airtaudio data format type.
*
* Support for signed integers and floats. Audio data fed to/from an
* airtaudio stream is assumed to ALWAYS be in host byte order. The
* internal routines will automatically take care of any necessary
* byte-swapping between the host format and the soundcard. Thus,
* endian-ness is not a concern in the following format definitions.
*
* - \e SINT8: 8-bit signed integer.
* - \e SINT16: 16-bit signed integer.
* - \e SINT24: 24-bit signed integer.
* - \e SINT32: 32-bit signed integer.
* - \e FLOAT32: Normalized between plus/minus 1.0.
* - \e FLOAT64: Normalized between plus/minus 1.0.
*/
typedef uint64_t format;
static const format SINT8 = 0x1; // 8-bit signed integer.
static const format SINT16 = 0x2; // 16-bit signed integer.
static const format SINT24 = 0x4; // 24-bit signed integer.
static const format SINT32 = 0x8; // 32-bit signed integer.
static const format FLOAT32 = 0x10; // Normalized between plus/minus 1.0.
static const format FLOAT64 = 0x20; // Normalized between plus/minus 1.0.
/**
* @typedef typedef uint64_t streamFlags;
* @brief RtAudio stream option flags.

1
lutin_airtaudio.py
View File

@ -17,6 +17,7 @@ def create(target):
'airtaudio/Api.cpp',
'airtaudio/api/Dummy.cpp',
])
myModule.add_module_depend(['audio'])
myModule.add_export_flag_CC(['-D__AIRTAUDIO_API_DUMMY_H__'])
if target.name=="Windows":