class CAudioError {
public:
/* Enums Definition */
- enum EError {
+ enum class EError : unsigned int {
ERROR_NONE,
ERROR_INVALID_ARGUMENT,
*/
class CAudioInfo {
public:
- enum EChannel {
+ enum class EChannel : unsigned int {
CHANNEL_MONO = 1, /**< 1 channel, mono */
CHANNEL_STEREO, /**< 2 channel, stereo */
CHANNEL_MAX
};
- enum ESampleType {
+ enum class ESampleType : unsigned int {
SAMPLE_TYPE_U8 = 1, /**< Unsigned 8-bit audio samples */
SAMPLE_TYPE_S16_LE, /**< Signed 16-bit audio samples */
SAMPLE_TYPE_MAX
};
- enum EAudioType {
+ enum class EAudioType : unsigned int {
/* Input Type */
AUDIO_IN_TYPE_MEDIA = 0,
//AUDIO_IN_TYPE_SYSTEM,
AUDIO_TYPE_MAX
};
- enum EAudioIOState {
+ enum class EAudioIOState : unsigned int {
AUDIO_IO_STATE_NONE, /**< Audio-io handle is not created */
AUDIO_IO_STATE_IDLE, /**< Audio-io handle is created, but not prepared */
AUDIO_IO_STATE_RUNNING, /**< Audio-io handle is ready and the stream is running */
AUDIO_IO_STATE_PAUSED, /**< Audio-io handle is ready and the stream is paused */
+ AUDIO_IO_STATE_MAX
};
const static unsigned int MIN_SYSTEM_SAMPLERATE = 8000;
void convertOutputStreamType2AudioType (char *streamType, CAudioInfo::EAudioType *audioType);
private:
- const char *__STREAM_TYPE_TABLE[AUDIO_TYPE_MAX] = {
+ const char *__STREAM_TYPE_TABLE[(unsigned int)EAudioType::AUDIO_TYPE_MAX] = {
/* Input Type */
"media", /**< AUDIO_IN_TYPE_MEDIA */
//"system", /**< AUDIO_IN_TYPE_SYSTEM */
*/
class CAudioSessionHandler {
public:
- enum EAudioSessionType {
+ enum class EAudioSessionType : unsigned int {
AUDIO_SESSION_TYPE_CAPTURE,
AUDIO_SESSION_TYPE_PLAYBACK
};
class CPulseStreamSpec;
class CPulseAudioClient {
public:
- enum EStreamDirection {
+ enum class EStreamDirection : unsigned int {
STREAM_DIRECTION_RECORD, /**< Record stream */
STREAM_DIRECTION_PLAYBACK /**< Playback stream */
};
class CPulseAudioPolicy {
public:
/* Enums */
- enum EPolicy {
+ enum class EPolicy : unsigned int {
POLICY_DEFAULT,
POLICY_OUT_AUTO,
POLICY_OUT_PHONE,
class CPulseAudioVolume {
public:
/* Enums */
- enum EVolume {
+ enum class EVolume : unsigned int {
VOLUME_SYSTEM, /**< System volume type */
VOLUME_NOTIFICATION, /**< Notification volume type */
VOLUME_ALARM, /**< Alarm volume type */
VOLUME_MAX /**< Volume type count */
};
- enum EVolumeGain {
+ enum class EVolumeGain : unsigned int {
VOLUME_GAIN_DEFAULT,
VOLUME_GAIN_DIALER,
VOLUME_GAIN_TOUCH,
class CPulseStreamSpec {
public:
/* Enums */
- enum EStreamLatency {
+ enum class EStreamLatency : unsigned int {
STREAM_LATENCY_INPUT_LOW,
STREAM_LATENCY_INPUT_MID,
STREAM_LATENCY_INPUT_HIGH,
class CAudioSessionHandler;
class IAudioSessionEventListener {
public:
- enum EInterruptCode {
+ enum class EInterruptCode : unsigned int {
INTERRUPT_COMPLETED = 0, /**< Interrupt completed */
INTERRUPT_BY_MEDIA, /**< Interrupted by a media application */
INTERRUPT_BY_CALL, /**< Interrupted by an incoming call */
Name: capi-media-audio-io
Summary: An Audio Input & Audio Output library in Tizen Native API
-Version: 0.3.14
+Version: 0.3.15
Release: 0
Group: Multimedia/API
License: Apache-2.0
/**
* class CAudioError
*/
-CAudioError::EError CAudioError::__mLastError = CAudioError::ERROR_NONE;
+CAudioError::EError CAudioError::__mLastError = CAudioError::EError::ERROR_NONE;
char CAudioError::__mLastErrorMsg[CAudioError::MSG_LENGTH];
CAudioError::CAudioError(EError err) :
const char* CAudioError::__convertErrorToString(EError err) {
switch (err) {
default:
- case ERROR_NONE: return COLOR_GREEN "ERROR_NONE" COLOR_END;
- case ERROR_INVALID_ARGUMENT: return COLOR_RED "ERROR_INVALID_ARGUMENT" COLOR_END;
- case ERROR_INVALID_HANDLE: return COLOR_RED "ERROR_INVALID_HANDLE" COLOR_END;
- case ERROR_INVALID_SAMPLERATE: return COLOR_RED "ERROR_INVALID_SAMPLERATE" COLOR_END;
- case ERROR_INVALID_CHANNEL: return COLOR_RED "ERROR_INVALID_CHANNEL" COLOR_END;
- case ERROR_INVALID_FORMAT: return COLOR_RED "ERROR_INVALID_FORMAT" COLOR_END;
- case ERROR_INVALID_POINTER: return COLOR_RED "ERROR_INVALID_POINTER" COLOR_END;
- case ERROR_INVALID_OPERATION: return COLOR_RED "ERROR_INVALID_OPERATION" COLOR_END;
- case ERROR_NOT_INITIALIZED: return COLOR_RED "ERROR_NOT_INITIALIZED" COLOR_END;
- case ERROR_NOT_SUPPORTED: return COLOR_RED "ERROR_NOT_SUPPORTED" COLOR_END;
- case ERROR_NOT_SUPPORTED_TYPE: return COLOR_RED "ERROR_NOT_SUPPORTED_TYPE" COLOR_END;
- case ERROR_PERMISSION_DENIED: return COLOR_RED "ERROR_PERMISSION_DENIED" COLOR_END;
- case ERROR_DEVICE_NOT_OPENED: return COLOR_RED "ERROR_DEVICE_NOT_OPENED" COLOR_END;
- case ERROR_DEVICE_NOT_CLOSED: return COLOR_RED "ERROR_DEVICE_NOT_CLOSED" COLOR_END;
- case ERROR_OUT_OF_MEMORY: return COLOR_RED "ERROR_OUT_OF_MEMORY" COLOR_END;
- case ERROR_INTERNAL_OPERATION: return COLOR_RED "ERROR_INTERNAL_OPERATION" COLOR_END;
- case ERROR_FAILED_OPERATION: return COLOR_RED "ERROR_FAILED_OPERATION" COLOR_END;
- case ERROR_POLICY_BLOCKED: return COLOR_RED "ERROR_POLICY_BLOCKED" COLOR_END;
- case ERROR_POLICY_INTERRUPTED: return COLOR_RED "ERROR_POLICY_INTERRUPTED" COLOR_END;
- case ERROR_POLICY_DUPLICATED: return COLOR_RED "ERROR_POLICY_DUPLICATED" COLOR_END;
+ case EError::ERROR_NONE: return COLOR_GREEN "ERROR_NONE" COLOR_END;
+ case EError::ERROR_INVALID_ARGUMENT: return COLOR_RED "ERROR_INVALID_ARGUMENT" COLOR_END;
+ case EError::ERROR_INVALID_HANDLE: return COLOR_RED "ERROR_INVALID_HANDLE" COLOR_END;
+ case EError::ERROR_INVALID_SAMPLERATE: return COLOR_RED "ERROR_INVALID_SAMPLERATE" COLOR_END;
+ case EError::ERROR_INVALID_CHANNEL: return COLOR_RED "ERROR_INVALID_CHANNEL" COLOR_END;
+ case EError::ERROR_INVALID_FORMAT: return COLOR_RED "ERROR_INVALID_FORMAT" COLOR_END;
+ case EError::ERROR_INVALID_POINTER: return COLOR_RED "ERROR_INVALID_POINTER" COLOR_END;
+ case EError::ERROR_INVALID_OPERATION: return COLOR_RED "ERROR_INVALID_OPERATION" COLOR_END;
+ case EError::ERROR_NOT_INITIALIZED: return COLOR_RED "ERROR_NOT_INITIALIZED" COLOR_END;
+ case EError::ERROR_NOT_SUPPORTED: return COLOR_RED "ERROR_NOT_SUPPORTED" COLOR_END;
+ case EError::ERROR_NOT_SUPPORTED_TYPE: return COLOR_RED "ERROR_NOT_SUPPORTED_TYPE" COLOR_END;
+ case EError::ERROR_PERMISSION_DENIED: return COLOR_RED "ERROR_PERMISSION_DENIED" COLOR_END;
+ case EError::ERROR_DEVICE_NOT_OPENED: return COLOR_RED "ERROR_DEVICE_NOT_OPENED" COLOR_END;
+ case EError::ERROR_DEVICE_NOT_CLOSED: return COLOR_RED "ERROR_DEVICE_NOT_CLOSED" COLOR_END;
+ case EError::ERROR_OUT_OF_MEMORY: return COLOR_RED "ERROR_OUT_OF_MEMORY" COLOR_END;
+ case EError::ERROR_INTERNAL_OPERATION: return COLOR_RED "ERROR_INTERNAL_OPERATION" COLOR_END;
+ case EError::ERROR_FAILED_OPERATION: return COLOR_RED "ERROR_FAILED_OPERATION" COLOR_END;
+ case EError::ERROR_POLICY_BLOCKED: return COLOR_RED "ERROR_POLICY_BLOCKED" COLOR_END;
+ case EError::ERROR_POLICY_INTERRUPTED: return COLOR_RED "ERROR_POLICY_INTERRUPTED" COLOR_END;
+ case EError::ERROR_POLICY_DUPLICATED: return COLOR_RED "ERROR_POLICY_DUPLICATED" COLOR_END;
}
}
mpPulseAudioClient(NULL),
__mIsInit(false),
__mForceIgnore(false) {
- mState = CAudioInfo::AUDIO_IO_STATE_NONE;
- mStatePrev = CAudioInfo::AUDIO_IO_STATE_NONE;
+ mState = CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE;
+ mStatePrev = CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE;
mByPolicy = false;
}
CAudioIO::CAudioIO(CAudioInfo& audioInfo) : mpAudioSessionHandler(NULL), mpPulseAudioClient(NULL), __mIsInit(false), __mForceIgnore(false) {
mAudioInfo = audioInfo;
- mState = CAudioInfo::AUDIO_IO_STATE_NONE;
- mStatePrev = CAudioInfo::AUDIO_IO_STATE_NONE;
+ mState = CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE;
+ mStatePrev = CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE;
mByPolicy = false;
}
}
bool CAudioIO::IsReady() {
- return ((mState == CAudioInfo::AUDIO_IO_STATE_RUNNING || mState == CAudioInfo::AUDIO_IO_STATE_PAUSED)? true : false);
+ return ((mState == CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING || mState == CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED)? true : false);
}
void CAudioIO::internalLock() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
if (pthread_mutex_lock(&__mMutex) != 0) {
- THROW_ERROR_MSG(CAudioError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_lock()");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_lock()");
}
#ifdef _AUDIO_IO_DEBUG_TIMING_
AUDIO_IO_LOGD(COLOR_RED "LOCK" COLOR_END);
void CAudioIO::internalUnlock() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
if (pthread_mutex_unlock(&__mMutex) != 0) {
- THROW_ERROR_MSG(CAudioError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_lock()");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_lock()");
}
#ifdef _AUDIO_IO_DEBUG_TIMING_
AUDIO_IO_LOGD(COLOR_GREEN "UNLOCK" COLOR_END);
void CAudioIO::internalWait() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
#ifdef _AUDIO_IO_DEBUG_TIMING_
void CAudioIO::internalSignal() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
#ifdef _AUDIO_IO_DEBUG_TIMING_
int ret = pthread_mutex_init(&__mMutex, NULL);
if (ret != 0) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed pthread_mutex_init()");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pthread_mutex_init()");
}
ret = pthread_cond_init(&__mCond, NULL);
if (ret != 0) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed pthread_cond_init()");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pthread_cond_init()");
}
__mIsInit = true;
int ret = pthread_mutex_destroy(&__mMutex);
if (ret != 0) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_OUT_OF_MEMORY, "Failed pthread_mutex_destroy() ret:%d", ret);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pthread_mutex_destroy() ret:%d", ret);
}
ret = pthread_cond_destroy(&__mCond);
if (ret != 0) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_OUT_OF_MEMORY, "Failed pthread_cond_destroy() ret:%d", ret);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pthread_cond_destroy() ret:%d", ret);
}
__mIsInit = false;
void CAudioIO::onStateChanged(CAudioInfo::EAudioIOState state, bool byPolicy) {
assert(__mIsInit == true);
- assert(state > 0);
+ assert(state >= CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE && state < CAudioInfo::EAudioIOState::AUDIO_IO_STATE_MAX);
mStatePrev = mState;
mState = state;
internalLock();
mpPulseAudioClient->cork(false);
- onStateChanged(CAudioInfo::AUDIO_IO_STATE_RUNNING);
+ onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING);
internalUnlock();
// Focus handle(id) of the other application was acquired, do pause if possible
internalLock();
- if (mpPulseAudioClient->getStreamDirection() == CPulseAudioClient::STREAM_DIRECTION_PLAYBACK) {
+ if (mpPulseAudioClient->getStreamDirection() == CPulseAudioClient::EStreamDirection::STREAM_DIRECTION_PLAYBACK) {
if (mpPulseAudioClient->drain() == false) {
AUDIO_IO_LOGE("Failed CPulseAudioClient::drain()");
}
}
mpPulseAudioClient->cork(true);
- onStateChanged(CAudioInfo::AUDIO_IO_STATE_PAUSED);
+ onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED);
internalUnlock();
// Focus handle(id) was released, do pause here
internalLock();
- if (mpPulseAudioClient->getStreamDirection() == CPulseAudioClient::STREAM_DIRECTION_PLAYBACK) {
+ if (mpPulseAudioClient->getStreamDirection() == CPulseAudioClient::EStreamDirection::STREAM_DIRECTION_PLAYBACK) {
if (mpPulseAudioClient->drain() == false) {
AUDIO_IO_LOGE("Failed CPulseAudioClient::drain()");
}
}
mpPulseAudioClient->cork(true);
- onStateChanged(CAudioInfo::AUDIO_IO_STATE_PAUSED);
+ onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED);
internalUnlock();
} else if (state == FOCUS_IS_ACQUIRED) {
internalLock();
mpPulseAudioClient->cork(false);
- onStateChanged(CAudioInfo::AUDIO_IO_STATE_RUNNING);
+ onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING);
internalUnlock();
}
}
if (mInterruptCallback.onInterrupt != NULL) {
- IAudioSessionEventListener::EInterruptCode e = IAudioSessionEventListener::INTERRUPT_COMPLETED;
+ IAudioSessionEventListener::EInterruptCode e = IAudioSessionEventListener::EInterruptCode::INTERRUPT_COMPLETED;
e = IAudioSessionEventListener::convertInterruptedCode(state, reason_for_change);
mInterruptCallback.onInterrupt(e, mInterruptCallback.mUserData);
}
void CAudioIO::prepare() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
try {
void CAudioIO::unprepare() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
try {
void CAudioIO::pause() throw (CAudioError) {
if (__mIsInit == false || IsReady() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO");
}
try {
void CAudioIO::resume() throw (CAudioError) {
if (__mIsInit == false || IsReady() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO");
}
try {
void CAudioIO::drain() throw (CAudioError) {
if (__mIsInit == false || IsReady() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO");
}
try {
void CAudioIO::flush() throw (CAudioError) {
if (__mIsInit == false || IsReady() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO");
}
try {
CAudioInfo CAudioIO::getAudioInfo() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
return mAudioInfo;
void CAudioIO::setStreamCallback(SStreamCallback callback) throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
mStreamCallback = callback;
CAudioIO::SStreamCallback CAudioIO::getStreamCallback() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
return mStreamCallback;
void CAudioIO::setStateChangedCallback(SStateChangedCallback callback) throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
mStateChangedCallback = callback;
CAudioIO::SStateChangedCallback CAudioIO::getStateChangedCallback() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
return mStateChangedCallback;
void CAudioIO::setInterruptCallback(SInterruptCallback callback) throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
mInterruptCallback = callback;
CAudioIO::SInterruptCallback CAudioIO::getInterruptCallback() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
return mInterruptCallback;
void CAudioIO::ignoreSession() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
try {
internalLock();
if (mpPulseAudioClient != NULL && mpPulseAudioClient->isCorked() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_INVALID_OPERATION, "An Operation is not permitted while started");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION, "An Operation is not permitted while started");
}
bool isSkip = mpAudioSessionHandler->isSkipSessionEvent();
*/
CAudioInfo::CAudioInfo() :
__mSampleRate(MAX_SYSTEM_SAMPLERATE),
- __mChannel(CHANNEL_MONO),
- __mSampleType(SAMPLE_TYPE_U8),
- __mAudioType(AUDIO_IN_TYPE_MEDIA),
+ __mChannel(EChannel::CHANNEL_MONO),
+ __mSampleType(ESampleType::SAMPLE_TYPE_U8),
+ __mAudioType(EAudioType::AUDIO_IN_TYPE_MEDIA),
__mAudioIndex(-1) {
}
__mAudioIndex(audioIndex) {
// Check to invalid AudioInfo
if (sampleRate < CAudioInfo::MIN_SYSTEM_SAMPLERATE || sampleRate > CAudioInfo::MAX_SYSTEM_SAMPLERATE) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "The sampleRate is invalid [sampleRate:%d]", sampleRate);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "The sampleRate is invalid [sampleRate:%d]", sampleRate);
}
- if (channel < CAudioInfo::CHANNEL_MONO || channel >= CAudioInfo::CHANNEL_MAX) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "The channel is invalid [channel:%d]", channel);
+ if (channel < CAudioInfo::EChannel::CHANNEL_MONO || channel >= CAudioInfo::EChannel::CHANNEL_MAX) {
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "The channel is invalid [channel:%d]", channel);
}
- if (sampleType < CAudioInfo::SAMPLE_TYPE_U8 || sampleType >= CAudioInfo::SAMPLE_TYPE_MAX) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "The sampleType is invalid [sampleType:%d]", sampleType);
+ if (sampleType < CAudioInfo::ESampleType::SAMPLE_TYPE_U8 || sampleType >= CAudioInfo::ESampleType::SAMPLE_TYPE_MAX) {
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "The sampleType is invalid [sampleType:%d]", sampleType);
}
- if (audioType < CAudioInfo::AUDIO_IN_TYPE_MEDIA || audioType >= CAudioInfo::AUDIO_TYPE_MAX) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "The audioType is invalid [audioType:%d]", audioType);
+ if (audioType < CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA || audioType >= CAudioInfo::EAudioType::AUDIO_TYPE_MAX) {
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "The audioType is invalid [audioType:%d]", audioType);
}
}
void CAudioInfo::convertAudioType2StreamType (CAudioInfo::EAudioType audioType, char **streamType)
{
- if (audioType < CAudioInfo::AUDIO_IN_TYPE_MEDIA || audioType >= CAudioInfo::AUDIO_TYPE_MAX) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_NOT_SUPPORTED_TYPE, "The audioType is not supported [audioType:%d]", audioType);
+ if (audioType < CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA || audioType >= CAudioInfo::EAudioType::AUDIO_TYPE_MAX) {
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE, "The audioType is not supported [audioType:%d]", audioType);
}
- *streamType = (char *)__STREAM_TYPE_TABLE[audioType];
+ *streamType = (char *)__STREAM_TYPE_TABLE[(unsigned int)audioType];
return;
}
void CAudioInfo::convertInputStreamType2AudioType (char *streamType, CAudioInfo::EAudioType *audioType)
{
unsigned int i;
- for (i = CAudioInfo::AUDIO_IN_TYPE_MEDIA ; i < CAudioInfo::AUDIO_OUT_TYPE_MEDIA ; i++) {
+ for (i = (unsigned int)CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA ; i < (unsigned int)CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA ; i++) {
if (!strcmp((char *)__STREAM_TYPE_TABLE[i], streamType)) {
break;
}
}
- if (i >= CAudioInfo::AUDIO_OUT_TYPE_MEDIA) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_NOT_SUPPORTED_TYPE, "The streamType is not supported [streamType:%s]", streamType);
+ if (i >= (unsigned int)CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA) {
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE, "The streamType is not supported [streamType:%s]", streamType);
}
*audioType = (CAudioInfo::EAudioType)i;
return;
void CAudioInfo::convertOutputStreamType2AudioType (char *streamType, CAudioInfo::EAudioType *audioType)
{
unsigned int i;
- for (i = CAudioInfo::AUDIO_OUT_TYPE_MEDIA ; i < CAudioInfo::AUDIO_TYPE_MAX ; i++) {
+ for (i = (unsigned int)CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA ; i < (unsigned int)CAudioInfo::EAudioType::AUDIO_TYPE_MAX ; i++) {
if (!strcmp((char *)__STREAM_TYPE_TABLE[i], streamType)) {
break;
}
}
- if (i >= CAudioInfo::AUDIO_TYPE_MAX) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_NOT_SUPPORTED_TYPE, "The streamType is not supported [streamType:%s]", streamType);
+ if (i >= (unsigned int)CAudioInfo::EAudioType::AUDIO_TYPE_MAX) {
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE, "The streamType is not supported [streamType:%s]", streamType);
}
*audioType = (CAudioInfo::EAudioType)i;
return;
CAudioIO::initialize();
// Create ASM Handler
- mpAudioSessionHandler = new CAudioSessionHandler(CAudioSessionHandler::AUDIO_SESSION_TYPE_CAPTURE, mAudioInfo, this);
+ mpAudioSessionHandler = new CAudioSessionHandler(CAudioSessionHandler::EAudioSessionType::AUDIO_SESSION_TYPE_CAPTURE, mAudioInfo, this);
if (mpAudioSessionHandler == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed to allocate CAudioSessionHandler object");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to allocate CAudioSessionHandler object");
}
// Initialize ASM Handler
mpAudioSessionHandler->initialize();
__setInit(true);
- CAudioIO::onStateChanged(CAudioInfo::AUDIO_IO_STATE_IDLE);
+ CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE);
} catch (CAudioError err) {
finalize();
throw err;
void CAudioInput::prepare() throw (CAudioError) {
if (__IsInit() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput");
}
if (__IsReady() == true) {
// Check to invalid AudioType
CAudioInfo::EAudioType audioType = mAudioInfo.getAudioType();
- if (audioType < CAudioInfo::AUDIO_IN_TYPE_MEDIA || audioType > CAudioInfo::AUDIO_IN_TYPE_LOOPBACK) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "The audioType is invalid [type:%d]", static_cast<int>(audioType));
+ if (audioType < CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA || audioType > CAudioInfo::EAudioType::AUDIO_IN_TYPE_LOOPBACK) {
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "The audioType is invalid [type:%d]", static_cast<int>(audioType));
}
if (mpAudioSessionHandler->getId() < 0) { //Did not registerSound()
// Init StreamSpec
AUDIO_IO_LOGD("Set Strem Spec : CPulseStreamSpec::STREAM_LATENCY_INPUT_MID");
- CPulseStreamSpec::EStreamLatency streamSpec = CPulseStreamSpec::STREAM_LATENCY_INPUT_MID;
+ CPulseStreamSpec::EStreamLatency streamSpec = CPulseStreamSpec::EStreamLatency::STREAM_LATENCY_INPUT_MID;
CPulseStreamSpec spec(streamSpec, mAudioInfo);
// Create PulseAudio Handler
- mpPulseAudioClient = new CPulseAudioClient(CPulseAudioClient::STREAM_DIRECTION_RECORD, spec, this);
+ mpPulseAudioClient = new CPulseAudioClient(CPulseAudioClient::EStreamDirection::STREAM_DIRECTION_RECORD, spec, this);
if (mpPulseAudioClient == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed to allocate CPulseAudioClient object");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to allocate CPulseAudioClient object");
}
// Initialize PulseAudio Handler
void CAudioInput::unprepare() throw (CAudioError) {
if (__IsInit() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput");
}
if (__IsReady() == false) {
internalUnlock();
- CAudioIO::onStateChanged(CAudioInfo::AUDIO_IO_STATE_IDLE);
+ CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE);
} catch (CAudioError e) {
internalUnlock();
throw e;
void CAudioInput::pause() throw (CAudioError) {
if (__IsInit() == false || __IsReady() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput");
}
try{
internalUnlock();
- CAudioIO::onStateChanged(CAudioInfo::AUDIO_IO_STATE_PAUSED);
+ CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED);
} catch (CAudioError e) {
internalUnlock();
throw e;
void CAudioInput::resume() throw (CAudioError) {
if (__IsInit() == false || __IsReady() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput");
}
try {
CAudioIO::resume();
- CAudioIO::onStateChanged(CAudioInfo::AUDIO_IO_STATE_RUNNING);
+ CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING);
} catch (CAudioError e) {
internalUnlock();
throw e;
}
void CAudioInput::drain() throw (CAudioError) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_SUPPORTED, "Did not support drain of CAudioInput");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "Did not support drain of CAudioInput");
}
void CAudioInput::flush() throw (CAudioError) {
if (__IsInit() == false || __IsReady() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput");
}
try {
int CAudioInput::getBufferSize() throw (CAudioError) {
if (__IsInit() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput");
}
if (__IsReady() == false) {
void CAudioInput::setStreamCallback(SStreamCallback callback) throw (CAudioError) {
if (__IsInit() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput");
}
if (callback.onStream == NULL) {
size_t CAudioInput::read(void* buffer, size_t length) throw (CAudioError) {
if (__IsInit() == false || __IsReady() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput");
}
if (buffer == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are invalid - buffer:%p, length:%zu", buffer, length);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are invalid - buffer:%p, length:%zu", buffer, length);
}
/* Checks synchronous flag */
if (__mIsUsedSyncRead == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_INVALID_OPERATION, "Invalid operation of read() if receive stream callback");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION, "Invalid operation of read() if receive stream callback");
}
size_t lengthIter = length;
while (__mpSyncReadDataPtr == NULL) {
ret = mpPulseAudioClient->peek(&__mpSyncReadDataPtr, &__mSyncReadLength);
if (ret != 0) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INTERNAL_OPERATION, "Failed CPulseAudioClient::peek() ret:[%d]", ret);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed CPulseAudioClient::peek() ret:[%d]", ret);
}
if (__mSyncReadLength <= 0) {
*/
ret = mpPulseAudioClient->drop();
if (ret != 0) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INTERNAL_OPERATION, "Failed CPulseAudioClient::drop() ret:[%d]", ret);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed CPulseAudioClient::drop() ret:[%d]", ret);
}
} else {
__mSyncReadIndex = 0;
#endif
ret = mpPulseAudioClient->drop();
if (ret != 0) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INTERNAL_OPERATION, "Failed CPulseAudioClient::drop() ret:[%d]", ret);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed CPulseAudioClient::drop() ret:[%d]", ret);
}
// Reset the internal pointer
int CAudioInput::peek(const void** buffer, size_t* length) throw (CAudioError) {
if (__IsInit() == false || __IsReady() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput");
}
if (buffer == NULL || length == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL buffer:%p, length:%p", buffer, length);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL buffer:%p, length:%p", buffer, length);
}
/* Checks synchronous flag */
if (__mIsUsedSyncRead == true) {
- THROW_ERROR_MSG(CAudioError::ERROR_INVALID_OPERATION, "Invalid operation of peek() if does not receive a stream callback");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION, "Invalid operation of peek() if does not receive a stream callback");
}
int ret = 0;
int CAudioInput::drop() throw (CAudioError) {
if (__IsInit() == false || __IsReady() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput");
}
/* Checks synchronous flag */
if (__mIsUsedSyncRead == true) {
- THROW_ERROR_MSG(CAudioError::ERROR_INVALID_OPERATION, "Invalid operation of drop() if does not receive a stream callback");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION, "Invalid operation of drop() if does not receive a stream callback");
}
int ret = 0;
CAudioIO::initialize();
// Create ASM Handler
- mpAudioSessionHandler = new CAudioSessionHandler(CAudioSessionHandler::AUDIO_SESSION_TYPE_PLAYBACK, mAudioInfo, this);
+ mpAudioSessionHandler = new CAudioSessionHandler(CAudioSessionHandler::EAudioSessionType::AUDIO_SESSION_TYPE_PLAYBACK, mAudioInfo, this);
if (mpAudioSessionHandler == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed to allocate CAudioSessionHandler object");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to allocate CAudioSessionHandler object");
}
// Initialize ASM Handler
mpAudioSessionHandler->initialize();
__setInit(true);
- CAudioIO::onStateChanged(CAudioInfo::AUDIO_IO_STATE_IDLE);
+ CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE);
} catch (CAudioError err) {
finalize();
throw err;
void CAudioOutput::prepare() throw (CAudioError) {
if (__IsInit() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioOutput");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioOutput");
}
- if (IsReady() == true) {
+ if (__IsReady() == true) {
AUDIO_IO_LOGD("Already prepared CAudioOutput");
return;
}
// Check to invalid AudioType
CAudioInfo::EAudioType audioType = mAudioInfo.getAudioType();
- if (audioType < CAudioInfo::AUDIO_OUT_TYPE_MEDIA || audioType >= CAudioInfo::AUDIO_TYPE_MAX) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "The audioType is invalid [type:%d]", static_cast<int>(audioType));
+ if (audioType < CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA || audioType >= CAudioInfo::EAudioType::AUDIO_TYPE_MAX) {
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "The audioType is invalid [type:%d]", static_cast<int>(audioType));
}
if (mpAudioSessionHandler->getId() < 0) { //Did not registerSound()
// Init StreamSpec
AUDIO_IO_LOGD("Set Stream Spec : CPulseStreamSpec::STREAM_LATENCY_OUTPUT_MID");
- CPulseStreamSpec::EStreamLatency streamSpec = CPulseStreamSpec::STREAM_LATENCY_OUTPUT_MID;
+ CPulseStreamSpec::EStreamLatency streamSpec = CPulseStreamSpec::EStreamLatency::STREAM_LATENCY_OUTPUT_MID;
CPulseStreamSpec spec(streamSpec, mAudioInfo);
// Create PulseAudio Handler
- mpPulseAudioClient = new CPulseAudioClient(CPulseAudioClient::STREAM_DIRECTION_PLAYBACK, spec, this);
+ mpPulseAudioClient = new CPulseAudioClient(CPulseAudioClient::EStreamDirection::STREAM_DIRECTION_PLAYBACK, spec, this);
if (mpPulseAudioClient == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed to allocate CPulseAudioClient object");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to allocate CPulseAudioClient object");
}
// Initialize PulseAudio Handler
void CAudioOutput::unprepare() throw (CAudioError) {
if (__IsInit() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioOutput");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioOutput");
}
- if (IsReady() == false) {
+ if (__IsReady() == false) {
AUDIO_IO_LOGD("Already unprepared");
return;
}
internalUnlock();
- CAudioIO::onStateChanged(CAudioInfo::AUDIO_IO_STATE_IDLE);
+ CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE);
} catch (CAudioError e) {
internalUnlock();
throw e;
}
void CAudioOutput::pause() throw (CAudioError) {
- if (__IsInit() == false || IsReady() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput");
+ if (__IsInit() == false || __IsReady() == false) {
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput");
}
try {
internalUnlock();
- CAudioIO::onStateChanged(CAudioInfo::AUDIO_IO_STATE_PAUSED);
+ CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED);
} catch (CAudioError e) {
internalUnlock();
throw e;
}
void CAudioOutput::resume() throw (CAudioError) {
- if (__IsInit() == false || IsReady() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput");
+ if (__IsInit() == false || __IsReady() == false) {
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput");
}
try {
CAudioIO::resume();
- CAudioIO::onStateChanged(CAudioInfo::AUDIO_IO_STATE_RUNNING);
+ CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING);
} catch (CAudioError e) {
internalUnlock();
throw e;
}
void CAudioOutput::drain() throw (CAudioError) {
- if (__IsInit() == false || IsReady() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput");
+ if (__IsInit() == false || __IsReady() == false) {
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput");
}
try {
}
void CAudioOutput::flush() throw (CAudioError) {
- if (__IsInit() == false || IsReady() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput");
+ if (__IsInit() == false || __IsReady() == false) {
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput");
}
try {
int CAudioOutput::getBufferSize() throw (CAudioError) {
if (__IsInit() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioOutput");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioOutput");
}
- if (IsReady() == false) {
+ if (__IsReady() == false) {
AUDIO_IO_LOGD("Warning: Did not prepare CAudioOutput, then return zero");
return 0;
}
}
size_t CAudioOutput::write(const void* buffer, size_t length) throw (CAudioError) {
- if (__IsInit() == false || IsReady() == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput");
+ if (__IsInit() == false || __IsReady() == false) {
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput");
}
if (buffer == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are invalid - buffer:%p, length:%zu", buffer, length);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are invalid - buffer:%p, length:%zu", buffer, length);
}
/* When write() is called in PulseAudio callback, bypass a pcm data to PulseAudioClient (For Asynchronous) */
int r = mpPulseAudioClient->write(buffer, l);
if (r < 0) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INTERNAL_OPERATION, "The written result is invalid ret:%d", r);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, "The written result is invalid ret:%d", r);
}
buffer = static_cast<const uint8_t*>(buffer) + l;
assert(index != NULL);
- if (type1 == AUDIO_SESSION_TYPE_CAPTURE) {
+ if (type1 == EAudioSessionType::AUDIO_SESSION_TYPE_CAPTURE) {
for (i = 0 ; i < sizeof(__STREAM_TYPE_TABLE_IN) / sizeof(__STREAM_TYPE_TABLE_IN[0]) ; i++) {
if (__STREAM_TYPE_TABLE_IN[i].type == type2) {
idx = i;
}
if (idx < 0) {
- RET_ERROR_MSG(CAudioError::ERROR_NOT_SUPPORTED, "Does not support session type.");
+ RET_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "Does not support session type.");
}
*index = idx;
- RET_ERROR(CAudioError::ERROR_NONE);
+ RET_ERROR(CAudioError::EError::ERROR_NONE);
}
CAudioError CAudioSessionHandler::__getAsmInformation(MMSessionType *type, int *options) {
int ret = 0;
if ((ret = _mm_session_util_read_information(-1, (int*)¤tSession, &sessionOptions)) < 0) {
if (ret == (int) MM_ERROR_INVALID_HANDLE) {
- RET_ERROR_MSG(CAudioError::ERROR_INVALID_HANDLE, "Failed _mm_session_util_read_information(). Invalid handle");
+ RET_ERROR_MSG(CAudioError::EError::ERROR_INVALID_HANDLE, "Failed _mm_session_util_read_information(). Invalid handle");
} else {
- RET_ERROR_MSG(CAudioError::ERROR_FAILED_OPERATION, "Failed _mm_session_util_read_information(). Not exist");
+ RET_ERROR_MSG(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed _mm_session_util_read_information(). Not exist");
}
}
*type = currentSession;
*options = sessionOptions;
- RET_ERROR(CAudioError::ERROR_NONE);
+ RET_ERROR(CAudioError::EError::ERROR_NONE);
}
bool CAudioSessionHandler::__isFocusRequired(MMSessionType type, int options) {
int sessionOptions = 0; // Mix with others by default
CAudioError err = __getAsmInformation(¤tSession, &sessionOptions);
- if (err == CAudioError::ERROR_NONE) {
+ if (err == CAudioError::EError::ERROR_NONE) {
// Session was configured before, use focus callback
__mUseFocus = true;
AUDIO_IO_LOGD("Use audio focus concept internally!");
} else {
- if (err == CAudioError::ERROR_INVALID_HANDLE) {
+ if (err == CAudioError::EError::ERROR_INVALID_HANDLE) {
int value = 0;
unsigned int subscribe_id;
int errorCode = mm_sound_get_signal_value(MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS, &value);
if (errorCode != MM_ERROR_NONE) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_POLICY_BLOCKED, "Failed mm_sound_get_signal_value() err:0x%x", errorCode);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_POLICY_BLOCKED, "Failed mm_sound_get_signal_value() err:0x%x", errorCode);
}
if (value == 1) {
// Use focus watch callback with signal subscribe
errorCode = mm_sound_subscribe_signal(MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS, &subscribe_id, __sound_pcm_signal_cb, static_cast<void*>(this));
if (errorCode != MM_ERROR_NONE) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_POLICY_BLOCKED, "Failed mm_sound_get_signal_value() err:0x%x", errorCode);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_POLICY_BLOCKED, "Failed mm_sound_get_signal_value() err:0x%x", errorCode);
}
__mSubscribeId = (int)subscribe_id;
AUDIO_IO_LOGD("Skip audio focus concept!");
}
- if (__mAudioSession == AUDIO_SESSION_TYPE_CAPTURE) {
+ if (__mAudioSession == EAudioSessionType::AUDIO_SESSION_TYPE_CAPTURE) {
AUDIO_IO_LOGD("Set default \"Media_Record\" type");
currentSession = MM_SESSION_TYPE_MEDIA_RECORD;
} else {
__mMultimediaSession = currentSession;
__mOptions = sessionOptions;
- if (this->__mAudioSession == AUDIO_SESSION_TYPE_CAPTURE) {
+ if (this->__mAudioSession == EAudioSessionType::AUDIO_SESSION_TYPE_CAPTURE) {
__pcmCaptureCountInc();
}
return;
}
- if (__mAudioSession == AUDIO_SESSION_TYPE_CAPTURE) {
+ if (__mAudioSession == EAudioSessionType::AUDIO_SESSION_TYPE_CAPTURE) {
__pcmCaptureCountDec();
}
void CAudioSessionHandler::registerSound() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioSessionHandler");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioSessionHandler");
}
if (__mUseFocus == true) {
if (__mId >= 0) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_POLICY_BLOCKED, "Already registered [id:%d]", __mId);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_POLICY_BLOCKED, "Already registered [id:%d]", __mId);
}
int errorCode = 0;
if (__isFocusRequired(__mMultimediaSession, __mOptions)) {
int index = 0;
CAudioError err = __convertStreamType(__mAudioSession, __mMultimediaSession, &index);
- if (err != CAudioError::ERROR_NONE) {
+ if (err != CAudioError::EError::ERROR_NONE) {
throw err;
}
errorCode = mm_sound_focus_get_id(&__mId);
if (errorCode != MM_ERROR_NONE) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_POLICY_BLOCKED, "Failed mm_sound_focus_get_id() err:0x%x", errorCode);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_POLICY_BLOCKED, "Failed mm_sound_focus_get_id() err:0x%x", errorCode);
}
// Register focus callback
errorCode = mm_sound_register_focus(__mId,
- __mAudioSession == AUDIO_SESSION_TYPE_CAPTURE ? __STREAM_TYPE_TABLE_IN[index].name : __STREAM_TYPE_TABLE_OUT[index].name,
+ __mAudioSession == EAudioSessionType::AUDIO_SESSION_TYPE_CAPTURE ? __STREAM_TYPE_TABLE_IN[index].name : __STREAM_TYPE_TABLE_OUT[index].name,
__sound_pcm_focus_cb,
static_cast<void*>(this));
if (errorCode != MM_ERROR_NONE) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_POLICY_BLOCKED, "Failed mm_sound_register_focus() err:0x%x", errorCode);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_POLICY_BLOCKED, "Failed mm_sound_register_focus() err:0x%x", errorCode);
}
__focusIdCountInc();
// Register focus watch callback
errorCode = mm_sound_set_focus_watch_callback(FOCUS_FOR_BOTH, __sound_pcm_focus_watch_cb, static_cast<void*>(this), &__mId);
if (errorCode < 0) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_POLICY_BLOCKED, "Failed mm_sound_set_focus_watch_callback() err:0x%x", errorCode);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_POLICY_BLOCKED, "Failed mm_sound_set_focus_watch_callback() err:0x%x", errorCode);
}
__focusIdCountInc();
void CAudioSessionHandler::unregisterSound() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioSessionHandler");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioSessionHandler");
}
if (__mUseFocus == true) {
if (__mId < 0) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_POLICY_BLOCKED, "Did not register [id:%d]", __mId);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_POLICY_BLOCKED, "Did not register [id:%d]", __mId);
}
int errorCode = 0;
// Unregister focus callback
errorCode = mm_sound_unregister_focus(__mId);
if (errorCode != MM_ERROR_NONE) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_POLICY_BLOCKED, "Failed mm_sound_unregister_focus() err:0x%x", errorCode);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_POLICY_BLOCKED, "Failed mm_sound_unregister_focus() err:0x%x", errorCode);
}
__focusIdCountDec();
// Unregister focus watch callback.
errorCode = mm_sound_unset_focus_watch_callback(__mId);
if (errorCode < 0) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_POLICY_BLOCKED, "Failed mm_sound_unset_focus_watch_callback() err:0x%x", errorCode);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_POLICY_BLOCKED, "Failed mm_sound_unset_focus_watch_callback() err:0x%x", errorCode);
}
__focusIdCountDec();
void CAudioSessionHandler::updatePlaying() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioSessionHandler");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioSessionHandler");
}
if (__mUseFocus && __isFocusRequired(__mMultimediaSession, __mOptions)) {
if (__mId >= 0) {
int ret = mm_sound_acquire_focus(__mId, FOCUS_FOR_BOTH, "audio-io acquire focus");
if (ret != MM_ERROR_NONE) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_POLICY_BLOCKED, "Failed mm_sound_acquire_focus() err:0x%x", ret);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_POLICY_BLOCKED, "Failed mm_sound_acquire_focus() err:0x%x", ret);
}
AUDIO_IO_LOGD("Focus acquired successfully [id:%d]", __mId);
}
void CAudioSessionHandler::updateStop() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioSessionHandler");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioSessionHandler");
}
if (__mUseFocus && __isFocusRequired(__mMultimediaSession, __mOptions)) {
if (__mId >= 0) {
int ret = mm_sound_release_focus(__mId, FOCUS_FOR_BOTH, "audio-io release focus");
if (ret != MM_ERROR_NONE) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_POLICY_BLOCKED, "Failed mm_sound_release_focus() err:0x%x", ret);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_POLICY_BLOCKED, "Failed mm_sound_release_focus() err:0x%x", ret);
}
AUDIO_IO_LOGD("Focus released successfully [id:%d]", __mId);
}
* class IAudioSessionEventListener
*/
IAudioSessionEventListener::EInterruptCode IAudioSessionEventListener::convertInterruptedCode(int code, const char *reason_for_change) {
- EInterruptCode e = INTERRUPT_COMPLETED;
+ EInterruptCode e = EInterruptCode::INTERRUPT_COMPLETED;
switch (code)
{
case FOCUS_IS_ACQUIRED:
- e = INTERRUPT_COMPLETED;
+ e = EInterruptCode::INTERRUPT_COMPLETED;
break;
case FOCUS_IS_RELEASED:
- if (!strcmp(reason_for_change, "media")) e = INTERRUPT_BY_MEDIA;
- if (!strcmp(reason_for_change, "radio")) e = INTERRUPT_BY_MEDIA;
- if (!strcmp(reason_for_change, "loopback")) e = INTERRUPT_BY_MEDIA;
- if (!strcmp(reason_for_change, "system")) e = INTERRUPT_BY_MEDIA;
- if (!strcmp(reason_for_change, "alarm")) e = INTERRUPT_BY_ALARM;
- if (!strcmp(reason_for_change, "notification")) e = INTERRUPT_BY_NOTIFICATION;
- if (!strcmp(reason_for_change, "emergency")) e = INTERRUPT_BY_EMERGENCY;
- if (!strcmp(reason_for_change, "voice-information")) e = INTERRUPT_BY_MEDIA; //for what?
- if (!strcmp(reason_for_change, "voice-recognition")) e = INTERRUPT_BY_MEDIA; //for what?
- if (!strcmp(reason_for_change, "ringtone-voip")) e = INTERRUPT_BY_MEDIA; //for what?
- if (!strcmp(reason_for_change, "ringtone-call")) e = INTERRUPT_BY_MEDIA; //for what?
- if (!strcmp(reason_for_change, "voip")) e = INTERRUPT_BY_MEDIA; //for what?
- if (!strcmp(reason_for_change, "call-voice")) e = INTERRUPT_BY_MEDIA; //for what?
- if (!strcmp(reason_for_change, "call-video")) e = INTERRUPT_BY_MEDIA; //for what?
+ if (!strcmp(reason_for_change, "media")) e = EInterruptCode::INTERRUPT_BY_MEDIA;
+ if (!strcmp(reason_for_change, "radio")) e = EInterruptCode::INTERRUPT_BY_MEDIA;
+ if (!strcmp(reason_for_change, "loopback")) e = EInterruptCode::INTERRUPT_BY_MEDIA;
+ if (!strcmp(reason_for_change, "system")) e = EInterruptCode::INTERRUPT_BY_MEDIA;
+ if (!strcmp(reason_for_change, "alarm")) e = EInterruptCode::INTERRUPT_BY_ALARM;
+ if (!strcmp(reason_for_change, "notification")) e = EInterruptCode::INTERRUPT_BY_NOTIFICATION;
+ if (!strcmp(reason_for_change, "emergency")) e = EInterruptCode::INTERRUPT_BY_EMERGENCY;
+ if (!strcmp(reason_for_change, "voice-information")) e = EInterruptCode::INTERRUPT_BY_MEDIA; //for what?
+ if (!strcmp(reason_for_change, "voice-recognition")) e = EInterruptCode::INTERRUPT_BY_MEDIA; //for what?
+ if (!strcmp(reason_for_change, "ringtone-voip")) e = EInterruptCode::INTERRUPT_BY_MEDIA; //for what?
+ if (!strcmp(reason_for_change, "ringtone-call")) e = EInterruptCode::INTERRUPT_BY_MEDIA; //for what?
+ if (!strcmp(reason_for_change, "voip")) e = EInterruptCode::INTERRUPT_BY_MEDIA; //for what?
+ if (!strcmp(reason_for_change, "call-voice")) e = EInterruptCode::INTERRUPT_BY_MEDIA; //for what?
+ if (!strcmp(reason_for_change, "call-video")) e = EInterruptCode::INTERRUPT_BY_MEDIA; //for what?
break;
}
switch (pa_stream_get_state(s)) {
case PA_STREAM_READY:
AUDIO_IO_LOGD("The stream is ready!");
- pClient->__mpListener->onStateChanged(CAudioInfo::AUDIO_IO_STATE_RUNNING);
+ pClient->__mpListener->onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING);
case PA_STREAM_FAILED:
case PA_STREAM_TERMINATED:
pa_threaded_mainloop_signal(pClient->__mpMainloop, 0);
// Allocates PA proplist
__mpPropList = pa_proplist_new();
if (__mpPropList == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed pa_proplist_new()");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pa_proplist_new()");
}
// Adds values on proplist for delivery to PULSEAUDIO
// Allocates PA mainloop
__mpMainloop = pa_threaded_mainloop_new();
if (__mpMainloop == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed pa_threaded_mainloop_new()");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pa_threaded_mainloop_new()");
}
// Allocates PA context
__mpContext = pa_context_new(pa_threaded_mainloop_get_api(__mpMainloop), CLIENT_NAME);
if (__mpContext == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed pa_context_new()");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pa_context_new()");
}
// Sets context state changed callback
// Connects this client with PA server
if (pa_context_connect(__mpContext, NULL, PA_CONTEXT_NOFLAGS, NULL) < 0) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed pa_context_connect()");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pa_context_connect()");
}
// LOCK for synchronous connection
// Start mainloop
if (pa_threaded_mainloop_start(__mpMainloop) < 0) {
pa_threaded_mainloop_unlock(__mpMainloop);
- THROW_ERROR_MSG(CAudioError::ERROR_FAILED_OPERATION, "Failed pa_threaded_mainloop_start()");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_threaded_mainloop_start()");
}
// Connection process is asynchronously
if (!PA_CONTEXT_IS_GOOD(state)) {
err = pa_context_errno(__mpContext);
pa_threaded_mainloop_unlock(__mpMainloop);
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INTERNAL_OPERATION, "pa_context's state is not good err:[%d]", err);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, "pa_context's state is not good err:[%d]", err);
}
/* Wait until the context is ready */
__mpStream = pa_stream_new_with_proplist(__mpContext, __mSpec.getStreamName(), &ss, &map, __mpPropList);
if (__mpStream == NULL) {
pa_threaded_mainloop_unlock(__mpMainloop);
- THROW_ERROR_MSG(CAudioError::ERROR_FAILED_OPERATION, "Failed pa_stream_new_with_proplist()()");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_stream_new_with_proplist()()");
}
// Sets stream callbacks
// Connect stream with PA Server
- if (__mDirection == STREAM_DIRECTION_PLAYBACK) {
+ if (__mDirection == EStreamDirection::STREAM_DIRECTION_PLAYBACK) {
pa_stream_flags_t flags = static_cast<pa_stream_flags_t>(
PA_STREAM_INTERPOLATE_TIMING |
PA_STREAM_ADJUST_LATENCY |
if (ret != 0) {
err = pa_context_errno(__mpContext);
pa_threaded_mainloop_unlock(__mpMainloop);
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_FAILED_OPERATION, "Failed pa_stream_connect() err:[%d]", err);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_stream_connect() err:[%d]", err);
}
while (true) {
if (!PA_STREAM_IS_GOOD(state)) {
err = pa_context_errno(__mpContext);
pa_threaded_mainloop_unlock(__mpMainloop);
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INTERNAL_OPERATION, "pa_stream's state is not good err:[%d]", err);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, "pa_stream's state is not good err:[%d]", err);
}
/* Wait until the stream is ready */
int CPulseAudioClient::peek(const void** data, size_t* length) throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
}
#ifdef _AUDIO_IO_DEBUG_TIMING_
checkRunningState();
if (data == NULL || length == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "The parameter is invalid - data:%p, length:%p", data, length);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "The parameter is invalid - data:%p, length:%p", data, length);
}
- if (__mDirection == STREAM_DIRECTION_PLAYBACK) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_SUPPORTED, "The Playback client couldn't use this function");
+ if (__mDirection == EStreamDirection::STREAM_DIRECTION_PLAYBACK) {
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "The Playback client couldn't use this function");
}
int ret = 0;
}
if (ret < 0) {
- THROW_ERROR_MSG(CAudioError::ERROR_FAILED_OPERATION, "Failed pa_stream_peek()");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_stream_peek()");
}
return ret;
int CPulseAudioClient::drop() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
}
#ifdef _AUDIO_IO_DEBUG_TIMING_
checkRunningState();
- if (__mDirection == STREAM_DIRECTION_PLAYBACK) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_SUPPORTED, "The Playback client couldn't use this function");
+ if (__mDirection == EStreamDirection::STREAM_DIRECTION_PLAYBACK) {
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "The Playback client couldn't use this function");
}
int ret = 0;
}
if (ret < 0) {
- THROW_ERROR_MSG(CAudioError::ERROR_FAILED_OPERATION, "Failed pa_stream_drop()");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_stream_drop()");
}
return ret;
int CPulseAudioClient::write(const void* data, size_t length) throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
}
#ifdef _AUDIO_IO_DEBUG_TIMING_
checkRunningState();
if (data == NULL || length < 0) {
- THROW_ERROR_MSG(CAudioError::ERROR_INVALID_ARGUMENT, "The parameter is invalid");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_ARGUMENT, "The parameter is invalid");
}
- if (__mDirection == STREAM_DIRECTION_RECORD) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_SUPPORTED, "The Playback client couldn't use this function");
+ if (__mDirection == EStreamDirection::STREAM_DIRECTION_RECORD) {
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "The Playback client couldn't use this function");
}
int ret = 0;
}
if (ret < 0) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_FAILED_OPERATION, "Failed pa_stream_write() err:%d", ret);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_stream_write() err:%d", ret);
}
return ret;
AUDIO_IO_LOGD("bool cork:%d", cork);
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
}
if (isInThread() == true) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_SUPPORTED, "This operation is not supported in callback");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "This operation is not supported in callback");
}
checkRunningState();
bool CPulseAudioClient::isCorked() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
}
checkRunningState();
AUDIO_IO_LOGD("drain");
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
}
checkRunningState();
AUDIO_IO_LOGD("flush");
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
}
checkRunningState();
size_t CPulseAudioClient::getWritableSize() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
}
checkRunningState();
- if (__mDirection != STREAM_DIRECTION_PLAYBACK) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_SUPPORTED, "This client is used for Playback");
+ if (__mDirection != EStreamDirection::STREAM_DIRECTION_PLAYBACK) {
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "This client is used for Playback");
}
size_t ret = 0;
void CPulseAudioClient::checkRunningState() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
}
if (__mpContext == NULL || PA_CONTEXT_IS_GOOD(pa_context_get_state(__mpContext)) == 0) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_NOT_INITIALIZED, "The context[%p] is not created or not good state", __mpContext);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_INITIALIZED, "The context[%p] is not created or not good state", __mpContext);
}
if (__mpStream == NULL || PA_STREAM_IS_GOOD(pa_stream_get_state(__mpStream)) == 0) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_NOT_INITIALIZED, "The stream[%p] is not created or not good state", __mpStream);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_INITIALIZED, "The stream[%p] is not created or not good state", __mpStream);
}
if (pa_context_get_state(__mpContext) != PA_CONTEXT_READY || pa_stream_get_state(__mpStream) != PA_STREAM_READY) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_NOT_INITIALIZED, "The context[%p] or stream[%p] state is not ready", __mpContext, __mpStream);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_INITIALIZED, "The context[%p] or stream[%p] state is not ready", __mpContext, __mpStream);
}
#ifdef _AUDIO_IO_DEBUG_TIMING_
bool CPulseAudioClient::isInThread() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
}
int ret = pa_threaded_mainloop_in_thread(__mpMainloop);
size_t CPulseAudioClient::getReadableSize() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
}
checkRunningState();
- if (__mDirection != STREAM_DIRECTION_RECORD) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_SUPPORTED, "This client is used for Capture");
+ if (__mDirection != EStreamDirection::STREAM_DIRECTION_RECORD) {
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "This client is used for Capture");
}
size_t ret = 0;
size_t CPulseAudioClient::getBufferSize() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
}
checkRunningState();
const pa_buffer_attr* attr = pa_stream_get_buffer_attr(__mpStream);
if (attr == NULL) {
int _err = pa_context_errno(__mpContext);
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_FAILED_OPERATION, "Failed pa_stream_get_buffer_attr() err:%d", _err);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_stream_get_buffer_attr() err:%d", _err);
}
- if (__mDirection == STREAM_DIRECTION_PLAYBACK) {
+ if (__mDirection == EStreamDirection::STREAM_DIRECTION_PLAYBACK) {
ret = attr->tlength;
AUDIO_IO_LOGD("PLAYBACK buffer size : %d", ret);
} else {
pa_usec_t CPulseAudioClient::getLatency() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
}
checkRunningState();
if (pa_stream_get_latency(__mpStream, &ret, &negative) < 0) {
int _err = pa_context_errno(__mpContext);
if (_err != PA_ERR_NODATA) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_FAILED_OPERATION, "Failed pa_stream_get_latency() err:%d", _err);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_stream_get_latency() err:%d", _err);
}
}
return negative ? 0 : ret;
int _err = pa_context_errno(__mpContext);
if (_err != PA_ERR_NODATA) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_FAILED_OPERATION, "Failed pa_stream_get_latency() err:%d", _err);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_stream_get_latency() err:%d", _err);
}
/* Wait until latency data is available again */
pa_usec_t CPulseAudioClient::getFinalLatency() throw (CAudioError) {
if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
}
checkRunningState();
const pa_timing_info* timing_info = pa_stream_get_timing_info(__mpStream);
if (buffer_attr == NULL || sample_spec == NULL || timing_info == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_OUT_OF_MEMORY, "Failed to get buffer_attr[%p] or sample_spec[%p] or timing_info[%p] from a pa_stream",
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to get buffer_attr[%p] or sample_spec[%p] or timing_info[%p] from a pa_stream",
buffer_attr, sample_spec, timing_info);
}
- if (__mDirection == STREAM_DIRECTION_PLAYBACK) {
+ if (__mDirection == EStreamDirection::STREAM_DIRECTION_PLAYBACK) {
ret = (pa_bytes_to_usec(buffer_attr->tlength, sample_spec) + timing_info->configured_sink_usec);
AUDIO_IO_LOGD("FINAL PLAYBACK LATENCY : %d", ret);
} else {
AUDIO_IO_LOGD("FINAL RECORD LATENCY : %d", ret);
}
} else {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_NOT_SUPPORTED, "This version(ver.%d) is not supported", ver);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_SUPPORTED, "This version(ver.%d) is not supported", ver);
}
if (isInThread() == false) {
* class CPulseAudioPolicy
*/
CPulseAudioPolicy::CPulseAudioPolicy() :
- __mPolicy(POLICY_DEFAULT) {
+ __mPolicy(EPolicy::POLICY_DEFAULT) {
}
CPulseAudioPolicy::CPulseAudioPolicy(EPolicy policy) :
}
void CPulseAudioPolicy::setPolicy(EPolicy policy) throw (CAudioError) {
- if (policy < POLICY_DEFAULT || policy >= POLICY_MAX) {
- THROW_ERROR_MSG(CAudioError::ERROR_INVALID_ARGUMENT, "The argument is out of range");
+ if (policy < EPolicy::POLICY_DEFAULT || policy >= EPolicy::POLICY_MAX) {
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_ARGUMENT, "The argument is out of range");
}
__mPolicy = policy;
/**
* class CPulseAudioVolume
*/
-CPulseAudioVolume::CPulseAudioVolume() : __mVolume(VOLUME_MEDIA), __mVolumeGain(VOLUME_GAIN_DEFAULT) {
+CPulseAudioVolume::CPulseAudioVolume() : __mVolume(EVolume::VOLUME_MEDIA), __mVolumeGain(EVolumeGain::VOLUME_GAIN_DEFAULT) {
}
CPulseAudioVolume::CPulseAudioVolume(EVolume volume, EVolumeGain gain) :
CPulseStreamSpec::CPulseStreamSpec() throw (CAudioError) :
- __mLatency(STREAM_LATENCY_INPUT_MID),
+ __mLatency(EStreamLatency::STREAM_LATENCY_INPUT_MID),
__mStreamName(NULL) {
__adjustSpec();
}
// Convert channels for PA
switch (__mAudioInfo.getChannel()) {
- case CAudioInfo::CHANNEL_MONO:
+ case CAudioInfo::EChannel::CHANNEL_MONO:
__mSampleSpec.channels = 1;
break;
- case CAudioInfo::CHANNEL_STEREO:
+ case CAudioInfo::EChannel::CHANNEL_STEREO:
default:
__mSampleSpec.channels = 2;
break;
// Convert format for PA
switch (__mAudioInfo.getSampleType()) {
- case CAudioInfo::SAMPLE_TYPE_U8:
+ case CAudioInfo::ESampleType::SAMPLE_TYPE_U8:
__mSampleSpec.format = PA_SAMPLE_U8;
break;
- case CAudioInfo::SAMPLE_TYPE_S16_LE:
+ case CAudioInfo::ESampleType::SAMPLE_TYPE_S16_LE:
default:
__mSampleSpec.format = PA_SAMPLE_S16LE;
break;
// Sets stream name
switch (__mLatency) {
- case STREAM_LATENCY_OUTPUT_MID:
+ case EStreamLatency::STREAM_LATENCY_OUTPUT_MID:
__mStreamName = STREAM_NAME_OUTPUT;
break;
- case STREAM_LATENCY_OUTPUT_HIGH:
+ case EStreamLatency::STREAM_LATENCY_OUTPUT_HIGH:
__mStreamName = STREAM_NAME_OUTPUT_HIGH_LATENCY;
break;
- case STREAM_LATENCY_OUTPUT_LOW:
+ case EStreamLatency::STREAM_LATENCY_OUTPUT_LOW:
__mStreamName = STREAM_NAME_OUTPUT_LOW_LATENCY;
break;
- case STREAM_LATENCY_OUTPUT_VOIP:
+ case EStreamLatency::STREAM_LATENCY_OUTPUT_VOIP:
__mStreamName = STREAM_NAME_OUTPUT_VOIP;
break;
- case STREAM_LATENCY_INPUT_HIGH:
+ case EStreamLatency::STREAM_LATENCY_INPUT_HIGH:
__mStreamName = STREAM_NAME_INPUT_HIGH_LATENCY;
break;
- case STREAM_LATENCY_INPUT_LOW:
+ case EStreamLatency::STREAM_LATENCY_INPUT_LOW:
__mStreamName = STREAM_NAME_INPUT_LOW_LATENCY;
break;
- case STREAM_LATENCY_INPUT_VOIP:
+ case EStreamLatency::STREAM_LATENCY_INPUT_VOIP:
__mStreamName = STREAM_NAME_INPUT_VOIP;
break;
- case STREAM_LATENCY_INPUT_MID:
+ case EStreamLatency::STREAM_LATENCY_INPUT_MID:
default:
__mStreamName = STREAM_NAME_INPUT;
break;
const char* latency;
switch (__mLatency) {
- case STREAM_LATENCY_INPUT_LOW:
- case STREAM_LATENCY_OUTPUT_LOW:
+ case EStreamLatency::STREAM_LATENCY_INPUT_LOW:
+ case EStreamLatency::STREAM_LATENCY_OUTPUT_LOW:
latency = STREAM_LATENCY_LOW;
break;
- case STREAM_LATENCY_INPUT_MID:
- case STREAM_LATENCY_OUTPUT_MID:
+ case EStreamLatency::STREAM_LATENCY_INPUT_MID:
+ case EStreamLatency::STREAM_LATENCY_OUTPUT_MID:
latency = STREAM_LATENCY_MID;
break;
- case STREAM_LATENCY_INPUT_HIGH:
- case STREAM_LATENCY_OUTPUT_HIGH:
+ case EStreamLatency::STREAM_LATENCY_INPUT_HIGH:
+ case EStreamLatency::STREAM_LATENCY_OUTPUT_HIGH:
latency = STREAM_LATENCY_HIGH;
break;
- case STREAM_LATENCY_INPUT_VOIP:
- case STREAM_LATENCY_OUTPUT_VOIP:
+ case EStreamLatency::STREAM_LATENCY_INPUT_VOIP:
+ case EStreamLatency::STREAM_LATENCY_OUTPUT_VOIP:
latency = STREAM_LATENCY_VOIP;
break;
default:
switch (err)
{
- case CAudioError::ERROR_NONE:
+ case CAudioError::EError::ERROR_NONE:
ret = AUDIO_IO_ERROR_NONE;
break;
- case CAudioError::ERROR_INVALID_ARGUMENT:
- case CAudioError::ERROR_INVALID_HANDLE:
- case CAudioError::ERROR_INVALID_SAMPLERATE:
- case CAudioError::ERROR_INVALID_CHANNEL:
- case CAudioError::ERROR_INVALID_FORMAT:
+ case CAudioError::EError::ERROR_INVALID_ARGUMENT:
+ case CAudioError::EError::ERROR_INVALID_HANDLE:
+ case CAudioError::EError::ERROR_INVALID_SAMPLERATE:
+ case CAudioError::EError::ERROR_INVALID_CHANNEL:
+ case CAudioError::EError::ERROR_INVALID_FORMAT:
ret = AUDIO_IO_ERROR_INVALID_PARAMETER;
break;
- case CAudioError::ERROR_DEVICE_NOT_OPENED:
+ case CAudioError::EError::ERROR_DEVICE_NOT_OPENED:
ret = AUDIO_IO_ERROR_DEVICE_NOT_OPENED;
break;
- case CAudioError::ERROR_DEVICE_NOT_CLOSED:
+ case CAudioError::EError::ERROR_DEVICE_NOT_CLOSED:
ret = AUDIO_IO_ERROR_DEVICE_NOT_CLOSED;
break;
- case CAudioError::ERROR_PERMISSION_DENIED:
+ case CAudioError::EError::ERROR_PERMISSION_DENIED:
ret = AUDIO_IO_ERROR_PERMISSION_DENIED;
break;
- case CAudioError::ERROR_NOT_SUPPORTED:
+ case CAudioError::EError::ERROR_NOT_SUPPORTED:
ret = AUDIO_IO_ERROR_NOT_SUPPORTED;
break;
- case CAudioError::ERROR_NOT_SUPPORTED_TYPE:
+ case CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE:
ret = AUDIO_IO_ERROR_NOT_SUPPORTED_TYPE;
break;
- case CAudioError::ERROR_MAX:
- case CAudioError::ERROR_INTERNAL_OPERATION:
- case CAudioError::ERROR_NOT_INITIALIZED:
- case CAudioError::ERROR_FAILED_OPERATION:
- case CAudioError::ERROR_INVALID_OPERATION:
+ case CAudioError::EError::ERROR_MAX:
+ case CAudioError::EError::ERROR_INTERNAL_OPERATION:
+ case CAudioError::EError::ERROR_NOT_INITIALIZED:
+ case CAudioError::EError::ERROR_FAILED_OPERATION:
+ case CAudioError::EError::ERROR_INVALID_OPERATION:
ret = AUDIO_IO_ERROR_INVALID_OPERATION;
break;
- case CAudioError::ERROR_OUT_OF_MEMORY:
- case CAudioError::ERROR_INVALID_POINTER:
+ case CAudioError::EError::ERROR_OUT_OF_MEMORY:
+ case CAudioError::EError::ERROR_INVALID_POINTER:
ret = AUDIO_IO_ERROR_INVALID_BUFFER;
break;
- case CAudioError::ERROR_POLICY_BLOCKED:
- case CAudioError::ERROR_POLICY_INTERRUPTED:
- case CAudioError::ERROR_POLICY_DUPLICATED:
+ case CAudioError::EError::ERROR_POLICY_BLOCKED:
+ case CAudioError::EError::ERROR_POLICY_INTERRUPTED:
+ case CAudioError::EError::ERROR_POLICY_DUPLICATED:
ret = AUDIO_IO_ERROR_SOUND_POLICY;
break;
}
static void __convert_channel_2_audio_info_channel(const audio_channel_e& src_channel, CAudioInfo::EChannel& dst_channel) {
switch (src_channel) {
case AUDIO_CHANNEL_MONO:
- dst_channel = CAudioInfo::CHANNEL_MONO;
+ dst_channel = CAudioInfo::EChannel::CHANNEL_MONO;
break;
case AUDIO_CHANNEL_STEREO:
- dst_channel = CAudioInfo::CHANNEL_STEREO;
+ dst_channel = CAudioInfo::EChannel::CHANNEL_STEREO;
break;
default:
- dst_channel = CAudioInfo::CHANNEL_MONO;
+ dst_channel = CAudioInfo::EChannel::CHANNEL_MONO;
}
}
static void __convert_audio_info_channel_2_channel(const CAudioInfo::EChannel& src_channel, audio_channel_e& dst_channel) {
switch (src_channel) {
- case CAudioInfo::CHANNEL_MONO:
+ case CAudioInfo::EChannel::CHANNEL_MONO:
dst_channel = AUDIO_CHANNEL_MONO;
break;
- case CAudioInfo::CHANNEL_STEREO:
+ case CAudioInfo::EChannel::CHANNEL_STEREO:
dst_channel = AUDIO_CHANNEL_STEREO;
break;
default:
static void __convert_sample_type_2_audio_info_sample_type(const audio_sample_type_e& src_type, CAudioInfo::ESampleType& dst_type) {
switch (src_type) {
case AUDIO_SAMPLE_TYPE_U8:
- dst_type = CAudioInfo::SAMPLE_TYPE_U8;
+ dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_U8;
break;
case AUDIO_SAMPLE_TYPE_S16_LE:
- dst_type = CAudioInfo::SAMPLE_TYPE_S16_LE;
+ dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_S16_LE;
break;
default:
- dst_type = CAudioInfo::SAMPLE_TYPE_U8;
+ dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_U8;
}
}
static void __convert_audio_info_sample_type_2_sample_type(const CAudioInfo::ESampleType& src_type, audio_sample_type_e& dst_type) {
switch (src_type) {
- case CAudioInfo::SAMPLE_TYPE_U8:
+ case CAudioInfo::ESampleType::SAMPLE_TYPE_U8:
dst_type = AUDIO_SAMPLE_TYPE_U8;
break;
- case CAudioInfo::SAMPLE_TYPE_S16_LE:
+ case CAudioInfo::ESampleType::SAMPLE_TYPE_S16_LE:
dst_type = AUDIO_SAMPLE_TYPE_S16_LE;
break;
default:
static void __convert_sound_type_2_audio_info_audio_type(const sound_type_e& src_type, CAudioInfo::EAudioType& dst_type) {
switch (src_type) {
case SOUND_TYPE_SYSTEM:
- dst_type = CAudioInfo::AUDIO_OUT_TYPE_SYSTEM;
+ dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM;
break;
case SOUND_TYPE_NOTIFICATION:
- dst_type = CAudioInfo::AUDIO_OUT_TYPE_NOTIFICATION;
+ dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_NOTIFICATION;
break;
case SOUND_TYPE_ALARM:
- dst_type = CAudioInfo::AUDIO_OUT_TYPE_ALARM;
+ dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_ALARM;
break;
case SOUND_TYPE_RINGTONE:
- dst_type = CAudioInfo::AUDIO_OUT_TYPE_RINGTONE_VOIP;
+ dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_RINGTONE_VOIP;
break;
case SOUND_TYPE_MEDIA:
- dst_type = CAudioInfo::AUDIO_OUT_TYPE_MEDIA;
+ dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
break;
case SOUND_TYPE_CALL:
- dst_type = CAudioInfo::AUDIO_OUT_TYPE_SYSTEM;
+ dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM;
break;
case SOUND_TYPE_VOIP:
- dst_type = CAudioInfo::AUDIO_OUT_TYPE_VOIP;
+ dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOIP;
break;
case SOUND_TYPE_VOICE:
- dst_type = CAudioInfo::AUDIO_OUT_TYPE_VOICE_INFORMATION;
+ dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOICE_INFORMATION;
break;
default:
- dst_type = CAudioInfo::AUDIO_OUT_TYPE_MEDIA;
+ dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
break;
}
}
static void __convert_audio_info_audio_type_2_sound_type(const CAudioInfo::EAudioType& src_type, sound_type_e& dst_type) {
switch (src_type) {
- case CAudioInfo::AUDIO_OUT_TYPE_MEDIA:
+ case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA:
dst_type = SOUND_TYPE_MEDIA;
break;
- case CAudioInfo::AUDIO_OUT_TYPE_SYSTEM:
+ case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM:
dst_type = SOUND_TYPE_SYSTEM;
break;
- case CAudioInfo::AUDIO_OUT_TYPE_ALARM:
+ case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_ALARM:
dst_type = SOUND_TYPE_ALARM;
break;
- case CAudioInfo::AUDIO_OUT_TYPE_NOTIFICATION:
- case CAudioInfo::AUDIO_OUT_TYPE_EMERGENCY:
+ case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_NOTIFICATION:
+ case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_EMERGENCY:
dst_type = SOUND_TYPE_NOTIFICATION;
break;
- case CAudioInfo::AUDIO_OUT_TYPE_VOICE_INFORMATION:
+ case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOICE_INFORMATION:
dst_type = SOUND_TYPE_VOICE;
break;
- case CAudioInfo::AUDIO_OUT_TYPE_RINGTONE_VOIP:
+ case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_RINGTONE_VOIP:
dst_type = SOUND_TYPE_RINGTONE;
break;
- case CAudioInfo::AUDIO_OUT_TYPE_VOIP:
+ case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOIP:
dst_type = SOUND_TYPE_VOIP;
break;
default:
static audio_io_state_e __convert_state_type(const CAudioInfo::EAudioIOState src_state) {
audio_io_state_e dst_state;
switch (src_state) {
- case CAudioInfo::AUDIO_IO_STATE_NONE:
+ case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE:
dst_state = AUDIO_IO_STATE_IDLE;
break;
- case CAudioInfo::AUDIO_IO_STATE_IDLE:
+ case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE:
dst_state = AUDIO_IO_STATE_IDLE;
break;
- case CAudioInfo::AUDIO_IO_STATE_RUNNING:
+ case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING:
dst_state = AUDIO_IO_STATE_RUNNING;
break;
- case CAudioInfo::AUDIO_IO_STATE_PAUSED:
+ case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED:
dst_state = AUDIO_IO_STATE_PAUSED;
break;
default:
static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type) throw (CAudioError) {
if (sample_rate < 0) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Invalid sample rate :%d", sample_rate);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid sample rate :%d", sample_rate);
}
if (channel != AUDIO_CHANNEL_MONO && channel != AUDIO_CHANNEL_STEREO) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Invalid channel :%d", channel);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid channel :%d", channel);
}
if (type != AUDIO_SAMPLE_TYPE_U8 && type != AUDIO_SAMPLE_TYPE_S16_LE) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Invalid sample type :%d", type);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid sample type :%d", type);
}
}
__check_audio_param(sample_rate, channel, type);
if (sound_type < SOUND_TYPE_SYSTEM || sound_type > SOUND_TYPE_VOICE) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Invalid sound type : %d", sound_type);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid sound type : %d", sound_type);
}
}
static CAudioInfo __generate_audio_input_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw (CAudioError) {
CAudioInfo::EChannel dstChannel;
CAudioInfo::ESampleType dstSampleType;
- CAudioInfo::EAudioType dstAudioType = CAudioInfo::AUDIO_IN_TYPE_MEDIA;
+ CAudioInfo::EAudioType dstAudioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA;
__convert_channel_2_audio_info_channel(channel, dstChannel);
__convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
static CAudioInfo __generate_audio_input_loopback_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw (CAudioError) {
CAudioInfo::EChannel dstChannel;
CAudioInfo::ESampleType dstSampleType;
- CAudioInfo::EAudioType dstAudioType = CAudioInfo::AUDIO_IN_TYPE_LOOPBACK;
+ CAudioInfo::EAudioType dstAudioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_LOOPBACK;
__convert_channel_2_audio_info_channel(channel, dstChannel);
__convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
static audio_io_interrupted_code_e __convert_interrupted_code(IAudioSessionEventListener::EInterruptCode code) {
switch (code) {
- case IAudioSessionEventListener::INTERRUPT_COMPLETED:
+ case IAudioSessionEventListener::EInterruptCode::INTERRUPT_COMPLETED:
return AUDIO_IO_INTERRUPTED_COMPLETED;
- case IAudioSessionEventListener::INTERRUPT_BY_CALL:
+ case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_CALL:
return AUDIO_IO_INTERRUPTED_BY_CALL;
- case IAudioSessionEventListener::INTERRUPT_BY_EARJACK_UNPLUG:
+ case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_EARJACK_UNPLUG:
return AUDIO_IO_INTERRUPTED_BY_EARJACK_UNPLUG;
- case IAudioSessionEventListener::INTERRUPT_BY_RESOURCE_CONFLICT:
+ case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_RESOURCE_CONFLICT:
return AUDIO_IO_INTERRUPTED_BY_RESOURCE_CONFLICT;
- case IAudioSessionEventListener::INTERRUPT_BY_ALARM:
+ case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_ALARM:
return AUDIO_IO_INTERRUPTED_BY_ALARM;
- case IAudioSessionEventListener::INTERRUPT_BY_EMERGENCY:
+ case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_EMERGENCY:
return AUDIO_IO_INTERRUPTED_BY_EMERGENCY;
- case IAudioSessionEventListener::INTERRUPT_BY_NOTIFICATION:
+ case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_NOTIFICATION:
return AUDIO_IO_INTERRUPTED_BY_NOTIFICATION;
- case IAudioSessionEventListener::INTERRUPT_BY_MEDIA:
- case IAudioSessionEventListener::INTERRUPT_MAX:
+ case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_MEDIA:
+ case IAudioSessionEventListener::EInterruptCode::INTERRUPT_MAX:
default:
return AUDIO_IO_INTERRUPTED_BY_MEDIA;
}
audio_io_s* handle = NULL;
try {
if (input == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
__check_audio_param(sample_rate, channel, type);
handle = new audio_io_s;
if (handle == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
}
CAudioInfo audioInfo = __generate_audio_input_info(sample_rate, channel, type);
handle->audioIoHandle = new CAudioInput(audioInfo);
if (handle == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
}
handle->audioIoHandle->initialize();
audio_io_s* handle = NULL;
try {
if (input == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
__check_audio_param(sample_rate, channel, type);
handle = new audio_io_s;
if (handle == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
}
CAudioInfo audioInfo = __generate_audio_input_loopback_info(sample_rate, channel, type);
handle->audioIoHandle = new CAudioInput(audioInfo);
if (handle == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
}
handle->audioIoHandle->initialize();
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL || stream_info == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, stream_info:%p", input, stream_info);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, stream_info:%p", input, stream_info);
}
assert(handle->audioIoHandle);
int errorCode = SOUND_MANAGER_ERROR_NONE;
- CAudioInfo::EAudioType AudioType = CAudioInfo::AUDIO_IN_TYPE_MEDIA;
+ CAudioInfo::EAudioType AudioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA;
char *type = NULL;
int index = -1;
if ((errorCode = sound_manager_get_type_from_stream_information (stream_info, &type)) != SOUND_MANAGER_ERROR_NONE) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->stream_type is invalid [ret:%d]", errorCode);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->stream_type is invalid [ret:%d]", errorCode);
}
handle->audioIoHandle->getAudioInfo().convertInputStreamType2AudioType(type, &AudioType);
handle->audioIoHandle->getAudioInfo().setAudioType(AudioType);
if ((errorCode = sound_manager_get_index_from_stream_information (stream_info, &index)) != SOUND_MANAGER_ERROR_NONE) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->index is invalid [ret:%d]", errorCode);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->index is invalid [ret:%d]", errorCode);
}
handle->audioIoHandle->getAudioInfo().setAudioIndex(index);
} catch (CAudioError e) {
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL || buffer == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, buffer:%p", input, buffer);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, buffer:%p", input, buffer);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL || size == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, size:%p", input, size);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, size:%p", input, size);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL || sample_rate == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, sample_rate:%p", input, sample_rate);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, sample_rate:%p", input, sample_rate);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL || channel == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, channel:%p", input, channel);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, channel:%p", input, channel);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL || type == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, type:%p", input, type);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, type:%p", input, type);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL || callback == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
if (handle->stream_callback.onStream) {
- THROW_ERROR_MSG(CAudioError::ERROR_INVALID_OPERATION, "Not support ignore session in async mode");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION, "Not support ignore session in async mode");
}
assert(handle->audioIoHandle);
try {
if (handle == NULL || callback == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL || buffer == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, buffer:%p", input, buffer);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, buffer:%p", input, buffer);
}
CAudioInput* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
CAudioInput* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
try {
if (handle == NULL || callback == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", input);
}
assert(handle->audioIoHandle);
audio_io_s* handle = NULL;
try {
if (output == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
}
__check_audio_param(sample_rate, channel, type, sound_type);
handle = new audio_io_s;
if (handle == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
}
CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, sound_type);
handle->audioIoHandle = new CAudioOutput(audioInfo);
if (handle == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
}
handle->audioIoHandle->initialize();
audio_io_s* handle = NULL;
try {
if (output == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
}
__check_audio_param(sample_rate, channel, type, SOUND_TYPE_SYSTEM /*default check */);
handle = new audio_io_s;
if (handle == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
}
CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, SOUND_TYPE_MEDIA /* default sound_type */);
handle->audioIoHandle = new CAudioOutput(audioInfo);
if (handle == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
}
handle->audioIoHandle->initialize();
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL || stream_info == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, stream_info:%p", output, stream_info);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, stream_info:%p", output, stream_info);
}
assert(handle->audioIoHandle);
int errorCode = SOUND_MANAGER_ERROR_NONE;
- CAudioInfo::EAudioType AudioType = CAudioInfo::AUDIO_OUT_TYPE_MEDIA;
+ CAudioInfo::EAudioType AudioType = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
char *type = NULL;
int index = -1;
if ((errorCode = sound_manager_get_type_from_stream_information (stream_info, &type)) != SOUND_MANAGER_ERROR_NONE) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->stream_type is invalid [ret:%d]", errorCode);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->stream_type is invalid [ret:%d]", errorCode);
}
handle->audioIoHandle->getAudioInfo().convertOutputStreamType2AudioType(type, &AudioType);
handle->audioIoHandle->getAudioInfo().setAudioType(AudioType);
if ((errorCode = sound_manager_get_index_from_stream_information (stream_info, &index)) != SOUND_MANAGER_ERROR_NONE) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->index is invalid [ret:%d]", errorCode);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->index is invalid [ret:%d]", errorCode);
}
handle->audioIoHandle->getAudioInfo().setAudioIndex(index);
} catch (CAudioError e) {
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL || buffer == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p, buffer:%p", output, buffer);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p, buffer:%p", output, buffer);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL || size == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, size:%p", output, size);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, size:%p", output, size);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL || sample_rate == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, sample_rate:%p", output, sample_rate);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, sample_rate:%p", output, sample_rate);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL || channel == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, channel:%p", output, channel);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, channel:%p", output, channel);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL || type == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, type:%p", output, type);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, type:%p", output, type);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL || type == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, type:%p", output, type);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, type:%p", output, type);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL || callback == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
}
if (handle->stream_callback.onStream) {
- THROW_ERROR_MSG(CAudioError::ERROR_INVALID_OPERATION, "Not support ignore session in async mode");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION, "Not support ignore session in async mode");
}
assert(handle->audioIoHandle);
try {
if (handle == NULL || callback == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL || callback == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback);
}
assert(handle->audioIoHandle);
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
}
assert(handle->audioIoHandle);
projects / platform / core / api / audio-io.git / commitdiff