From: KimJeongYeon Date: Mon, 24 Aug 2015 02:16:26 +0000 (+0900) Subject: audio-io applied C++ coding rule X-Git-Tag: accepted/tizen/mobile/20150826.020029^0 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=c5fdaacfee62cba3cfb89e4d8bd264e21207b3b5;p=platform%2Fcore%2Fapi%2Faudio-io.git audio-io applied C++ coding rule [Version] 0.3.15 [Profile] Common [Issue Type] Typos [Dependency module] NA [Dependency commit] NA [Comment] 1) use enum class instead of enum type 2) fixed typos Signed-off-by: KimJeongYeon Change-Id: I7ed7991769599faea5d7dce281d4a6a5dc8d39be --- diff --git a/include/CAudioError.h b/include/CAudioError.h index 34f3085..61ed141 100644 --- a/include/CAudioError.h +++ b/include/CAudioError.h @@ -30,7 +30,7 @@ namespace tizen_media_audio { class CAudioError { public: /* Enums Definition */ - enum EError { + enum class EError : unsigned int { ERROR_NONE, ERROR_INVALID_ARGUMENT, diff --git a/include/CAudioInfo.h b/include/CAudioInfo.h index 2dba2a8..86ba7d8 100644 --- a/include/CAudioInfo.h +++ b/include/CAudioInfo.h @@ -29,19 +29,19 @@ namespace tizen_media_audio { */ 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, @@ -77,11 +77,12 @@ namespace tizen_media_audio { 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; @@ -104,7 +105,7 @@ namespace tizen_media_audio { 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 */ diff --git a/include/CAudioSessionHandler.h b/include/CAudioSessionHandler.h index 409e311..f4a537d 100644 --- a/include/CAudioSessionHandler.h +++ b/include/CAudioSessionHandler.h @@ -35,7 +35,7 @@ namespace tizen_media_audio { */ class CAudioSessionHandler { public: - enum EAudioSessionType { + enum class EAudioSessionType : unsigned int { AUDIO_SESSION_TYPE_CAPTURE, AUDIO_SESSION_TYPE_PLAYBACK }; diff --git a/include/CPulseAudioClient.h b/include/CPulseAudioClient.h index fe5db0a..86ae2ed 100644 --- a/include/CPulseAudioClient.h +++ b/include/CPulseAudioClient.h @@ -36,7 +36,7 @@ namespace tizen_media_audio { class CPulseStreamSpec; class CPulseAudioClient { public: - enum EStreamDirection { + enum class EStreamDirection : unsigned int { STREAM_DIRECTION_RECORD, /**< Record stream */ STREAM_DIRECTION_PLAYBACK /**< Playback stream */ }; diff --git a/include/CPulseAudioPolicy.h b/include/CPulseAudioPolicy.h index 016d677..b9ef2d8 100644 --- a/include/CPulseAudioPolicy.h +++ b/include/CPulseAudioPolicy.h @@ -32,7 +32,7 @@ namespace tizen_media_audio { class CPulseAudioPolicy { public: /* Enums */ - enum EPolicy { + enum class EPolicy : unsigned int { POLICY_DEFAULT, POLICY_OUT_AUTO, POLICY_OUT_PHONE, diff --git a/include/CPulseAudioVolume.h b/include/CPulseAudioVolume.h index 813783b..e2839ac 100644 --- a/include/CPulseAudioVolume.h +++ b/include/CPulseAudioVolume.h @@ -32,7 +32,7 @@ namespace tizen_media_audio { 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 */ @@ -46,7 +46,7 @@ namespace tizen_media_audio { VOLUME_MAX /**< Volume type count */ }; - enum EVolumeGain { + enum class EVolumeGain : unsigned int { VOLUME_GAIN_DEFAULT, VOLUME_GAIN_DIALER, VOLUME_GAIN_TOUCH, diff --git a/include/CPulseStreamSpec.h b/include/CPulseStreamSpec.h index d09a194..784524b 100644 --- a/include/CPulseStreamSpec.h +++ b/include/CPulseStreamSpec.h @@ -33,7 +33,7 @@ namespace tizen_media_audio { class CPulseStreamSpec { public: /* Enums */ - enum EStreamLatency { + enum class EStreamLatency : unsigned int { STREAM_LATENCY_INPUT_LOW, STREAM_LATENCY_INPUT_MID, STREAM_LATENCY_INPUT_HIGH, diff --git a/include/IAudioSessionEventListener.h b/include/IAudioSessionEventListener.h index 8c425a9..6ae05f6 100644 --- a/include/IAudioSessionEventListener.h +++ b/include/IAudioSessionEventListener.h @@ -34,7 +34,7 @@ namespace tizen_media_audio { 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 */ diff --git a/packaging/capi-media-audio-io.spec b/packaging/capi-media-audio-io.spec index 40e78c1..eb903aa 100644 --- a/packaging/capi-media-audio-io.spec +++ b/packaging/capi-media-audio-io.spec @@ -1,6 +1,6 @@ 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 diff --git a/src/cpp/CAudioError.cpp b/src/cpp/CAudioError.cpp index 2a10dba..6ff56b3 100644 --- a/src/cpp/CAudioError.cpp +++ b/src/cpp/CAudioError.cpp @@ -27,7 +27,7 @@ using namespace tizen_media_audio; /** * 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) : @@ -80,26 +80,26 @@ CAudioError::~CAudioError() { 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; } } diff --git a/src/cpp/CAudioIO.cpp b/src/cpp/CAudioIO.cpp index fc3792f..ce48131 100644 --- a/src/cpp/CAudioIO.cpp +++ b/src/cpp/CAudioIO.cpp @@ -35,15 +35,15 @@ CAudioIO::CAudioIO() : 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; } @@ -59,16 +59,16 @@ bool CAudioIO::isInit() { } 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); @@ -77,11 +77,11 @@ void CAudioIO::internalLock() throw (CAudioError) { 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); @@ -90,7 +90,7 @@ void CAudioIO::internalUnlock() throw (CAudioError) { 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_ @@ -102,7 +102,7 @@ void CAudioIO::internalWait() throw (CAudioError) { 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_ @@ -125,12 +125,12 @@ void CAudioIO::initialize() throw (CAudioError) { 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; @@ -145,12 +145,12 @@ void CAudioIO::finalize() { 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; @@ -172,7 +172,7 @@ void CAudioIO::onStream(CPulseAudioClient* pClient, size_t length) { 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; @@ -209,7 +209,7 @@ void CAudioIO::onInterrupt(CAudioSessionHandler* pHandler, int id, mm_sound_focu internalLock(); mpPulseAudioClient->cork(false); - onStateChanged(CAudioInfo::AUDIO_IO_STATE_RUNNING); + onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING); internalUnlock(); @@ -219,14 +219,14 @@ void CAudioIO::onInterrupt(CAudioSessionHandler* pHandler, int id, mm_sound_focu // 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(); @@ -251,14 +251,14 @@ void CAudioIO::onInterrupt(CAudioSessionHandler* pHandler, int id, mm_sound_focu // 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) { @@ -268,14 +268,14 @@ void CAudioIO::onInterrupt(CAudioSessionHandler* pHandler, int id, mm_sound_focu 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); } @@ -297,7 +297,7 @@ void CAudioIO::onSignal(CAudioSessionHandler* pHandler, mm_sound_signal_name_t s 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 { @@ -310,7 +310,7 @@ void CAudioIO::prepare() throw (CAudioError) { 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 { @@ -323,7 +323,7 @@ void CAudioIO::unprepare() throw (CAudioError) { 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 { @@ -339,7 +339,7 @@ void CAudioIO::pause() throw (CAudioError) { 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 { @@ -355,7 +355,7 @@ void CAudioIO::resume() throw (CAudioError) { 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 { @@ -371,7 +371,7 @@ void CAudioIO::drain() throw (CAudioError) { 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 { @@ -387,7 +387,7 @@ void CAudioIO::flush() throw (CAudioError) { 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; @@ -395,7 +395,7 @@ CAudioInfo CAudioIO::getAudioInfo() throw (CAudioError) { 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; @@ -403,7 +403,7 @@ void CAudioIO::setStreamCallback(SStreamCallback callback) throw (CAudioError) { 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; @@ -411,7 +411,7 @@ CAudioIO::SStreamCallback CAudioIO::getStreamCallback() throw (CAudioError) { 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; @@ -419,7 +419,7 @@ void CAudioIO::setStateChangedCallback(SStateChangedCallback callback) throw (CA 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; @@ -427,7 +427,7 @@ CAudioIO::SStateChangedCallback CAudioIO::getStateChangedCallback() throw (CAudi 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; @@ -435,7 +435,7 @@ void CAudioIO::setInterruptCallback(SInterruptCallback callback) throw (CAudioEr 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; @@ -444,14 +444,14 @@ CAudioIO::SInterruptCallback CAudioIO::getInterruptCallback() throw (CAudioError 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(); diff --git a/src/cpp/CAudioInfo.cpp b/src/cpp/CAudioInfo.cpp index 2857836..e847f68 100644 --- a/src/cpp/CAudioInfo.cpp +++ b/src/cpp/CAudioInfo.cpp @@ -28,9 +28,9 @@ using namespace tizen_media_audio; */ 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) { } @@ -42,19 +42,19 @@ CAudioInfo::CAudioInfo(unsigned int sampleRate, EChannel channel, ESampleType sa __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); } } @@ -90,23 +90,23 @@ void CAudioInfo::setAudioIndex(int AudioIndex) { 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; @@ -115,13 +115,13 @@ void CAudioInfo::convertInputStreamType2AudioType (char *streamType, CAudioInfo: 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; diff --git a/src/cpp/CAudioInput.cpp b/src/cpp/CAudioInput.cpp index 8d2dc42..1bec4a1 100644 --- a/src/cpp/CAudioInput.cpp +++ b/src/cpp/CAudioInput.cpp @@ -105,16 +105,16 @@ void CAudioInput::initialize() throw (CAudioError) { 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; @@ -137,7 +137,7 @@ void CAudioInput::finalize() { 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) { @@ -150,8 +150,8 @@ void CAudioInput::prepare() throw (CAudioError) { // 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(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(audioType)); } if (mpAudioSessionHandler->getId() < 0) { //Did not registerSound() @@ -165,13 +165,13 @@ void CAudioInput::prepare() throw (CAudioError) { // 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 @@ -194,7 +194,7 @@ void CAudioInput::prepare() throw (CAudioError) { 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) { @@ -225,7 +225,7 @@ void CAudioInput::unprepare() throw (CAudioError) { internalUnlock(); - CAudioIO::onStateChanged(CAudioInfo::AUDIO_IO_STATE_IDLE); + CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE); } catch (CAudioError e) { internalUnlock(); throw e; @@ -234,7 +234,7 @@ void CAudioInput::unprepare() throw (CAudioError) { 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{ @@ -249,7 +249,7 @@ void CAudioInput::pause() throw (CAudioError) { internalUnlock(); - CAudioIO::onStateChanged(CAudioInfo::AUDIO_IO_STATE_PAUSED); + CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED); } catch (CAudioError e) { internalUnlock(); throw e; @@ -258,7 +258,7 @@ void CAudioInput::pause() throw (CAudioError) { 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 { @@ -274,7 +274,7 @@ void CAudioInput::resume() throw (CAudioError) { CAudioIO::resume(); - CAudioIO::onStateChanged(CAudioInfo::AUDIO_IO_STATE_RUNNING); + CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING); } catch (CAudioError e) { internalUnlock(); throw e; @@ -282,12 +282,12 @@ void CAudioInput::resume() throw (CAudioError) { } 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 { @@ -299,7 +299,7 @@ void CAudioInput::flush() throw (CAudioError) { 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) { @@ -320,7 +320,7 @@ int CAudioInput::getBufferSize() throw (CAudioError) { 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) { @@ -336,16 +336,16 @@ void CAudioInput::setStreamCallback(SStreamCallback callback) throw (CAudioError 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; @@ -360,7 +360,7 @@ size_t CAudioInput::read(void* buffer, size_t length) throw (CAudioError) { 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) { @@ -374,7 +374,7 @@ size_t CAudioInput::read(void* buffer, size_t length) throw (CAudioError) { */ 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; @@ -407,7 +407,7 @@ size_t CAudioInput::read(void* buffer, size_t length) throw (CAudioError) { #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 @@ -428,16 +428,16 @@ size_t CAudioInput::read(void* buffer, size_t length) throw (CAudioError) { 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; @@ -453,12 +453,12 @@ int CAudioInput::peek(const void** buffer, size_t* length) throw (CAudioError) { 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; diff --git a/src/cpp/CAudioOutput.cpp b/src/cpp/CAudioOutput.cpp index 1a34c6a..15ccc07 100644 --- a/src/cpp/CAudioOutput.cpp +++ b/src/cpp/CAudioOutput.cpp @@ -100,16 +100,16 @@ void CAudioOutput::initialize() throw (CAudioError) { 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; @@ -132,10 +132,10 @@ void CAudioOutput::finalize() { 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; } @@ -145,8 +145,8 @@ void CAudioOutput::prepare() throw (CAudioError) { // 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(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(audioType)); } if (mpAudioSessionHandler->getId() < 0) { //Did not registerSound() @@ -159,13 +159,13 @@ void CAudioOutput::prepare() throw (CAudioError) { // 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 @@ -187,10 +187,10 @@ void CAudioOutput::prepare() throw (CAudioError) { 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; } @@ -217,7 +217,7 @@ void CAudioOutput::unprepare() throw (CAudioError) { internalUnlock(); - CAudioIO::onStateChanged(CAudioInfo::AUDIO_IO_STATE_IDLE); + CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE); } catch (CAudioError e) { internalUnlock(); throw e; @@ -225,8 +225,8 @@ void CAudioOutput::unprepare() throw (CAudioError) { } 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 { @@ -241,7 +241,7 @@ void CAudioOutput::pause() throw (CAudioError) { internalUnlock(); - CAudioIO::onStateChanged(CAudioInfo::AUDIO_IO_STATE_PAUSED); + CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED); } catch (CAudioError e) { internalUnlock(); throw e; @@ -249,8 +249,8 @@ void CAudioOutput::pause() throw (CAudioError) { } 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 { @@ -266,7 +266,7 @@ void CAudioOutput::resume() throw (CAudioError) { CAudioIO::resume(); - CAudioIO::onStateChanged(CAudioInfo::AUDIO_IO_STATE_RUNNING); + CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING); } catch (CAudioError e) { internalUnlock(); throw e; @@ -274,8 +274,8 @@ void CAudioOutput::resume() throw (CAudioError) { } 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 { @@ -286,8 +286,8 @@ void CAudioOutput::drain() throw (CAudioError) { } 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 { @@ -299,10 +299,10 @@ void CAudioOutput::flush() throw (CAudioError) { 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; } @@ -319,12 +319,12 @@ int CAudioOutput::getBufferSize() throw (CAudioError) { } 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) */ @@ -364,7 +364,7 @@ size_t CAudioOutput::write(const void* buffer, size_t length) throw (CAudioError 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(buffer) + l; diff --git a/src/cpp/CAudioSessionHandler.cpp b/src/cpp/CAudioSessionHandler.cpp index aa00520..87bff45 100644 --- a/src/cpp/CAudioSessionHandler.cpp +++ b/src/cpp/CAudioSessionHandler.cpp @@ -101,7 +101,7 @@ CAudioError CAudioSessionHandler::__convertStreamType(EAudioSessionType type1, M 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; @@ -118,10 +118,10 @@ CAudioError CAudioSessionHandler::__convertStreamType(EAudioSessionType type1, M } 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) { @@ -135,16 +135,16 @@ CAudioError CAudioSessionHandler::__getAsmInformation(MMSessionType *type, int * 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) { @@ -200,18 +200,18 @@ void CAudioSessionHandler::initialize() throw (CAudioError) { 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) { @@ -223,7 +223,7 @@ void CAudioSessionHandler::initialize() throw (CAudioError) { // 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(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; @@ -238,7 +238,7 @@ void CAudioSessionHandler::initialize() throw (CAudioError) { 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 { @@ -251,7 +251,7 @@ void CAudioSessionHandler::initialize() throw (CAudioError) { __mMultimediaSession = currentSession; __mOptions = sessionOptions; - if (this->__mAudioSession == AUDIO_SESSION_TYPE_CAPTURE) { + if (this->__mAudioSession == EAudioSessionType::AUDIO_SESSION_TYPE_CAPTURE) { __pcmCaptureCountInc(); } @@ -264,7 +264,7 @@ void CAudioSessionHandler::finalize() { return; } - if (__mAudioSession == AUDIO_SESSION_TYPE_CAPTURE) { + if (__mAudioSession == EAudioSessionType::AUDIO_SESSION_TYPE_CAPTURE) { __pcmCaptureCountDec(); } @@ -345,12 +345,12 @@ void CAudioSessionHandler::__sound_pcm_focus_watch_cb(int id, mm_sound_focus_typ 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; @@ -358,22 +358,22 @@ void CAudioSessionHandler::registerSound() throw (CAudioError) { 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(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(); @@ -383,7 +383,7 @@ void CAudioSessionHandler::registerSound() throw (CAudioError) { // Register focus watch callback errorCode = mm_sound_set_focus_watch_callback(FOCUS_FOR_BOTH, __sound_pcm_focus_watch_cb, static_cast(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(); @@ -395,12 +395,12 @@ void CAudioSessionHandler::registerSound() throw (CAudioError) { 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; @@ -409,7 +409,7 @@ void CAudioSessionHandler::unregisterSound() throw (CAudioError) { // 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(); @@ -420,7 +420,7 @@ void CAudioSessionHandler::unregisterSound() throw (CAudioError) { // 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(); @@ -433,14 +433,14 @@ void CAudioSessionHandler::unregisterSound() throw (CAudioError) { 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); } @@ -449,14 +449,14 @@ void CAudioSessionHandler::updatePlaying() throw (CAudioError) { 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); } @@ -474,29 +474,29 @@ void CAudioSessionHandler::disableSessionHandler() throw (CAudioError) { * 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; } diff --git a/src/cpp/CPulseAudioClient.cpp b/src/cpp/CPulseAudioClient.cpp index 733fe05..64d680e 100644 --- a/src/cpp/CPulseAudioClient.cpp +++ b/src/cpp/CPulseAudioClient.cpp @@ -87,7 +87,7 @@ void CPulseAudioClient::__streamStateChangeCb(pa_stream* s, void* user_data) { 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); @@ -165,7 +165,7 @@ void CPulseAudioClient::initialize() throw (CAudioError) { // 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 @@ -186,13 +186,13 @@ void CPulseAudioClient::initialize() throw (CAudioError) { // 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 @@ -200,7 +200,7 @@ void CPulseAudioClient::initialize() throw (CAudioError) { // 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 @@ -209,7 +209,7 @@ void CPulseAudioClient::initialize() throw (CAudioError) { // 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 @@ -226,7 +226,7 @@ void CPulseAudioClient::initialize() throw (CAudioError) { 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 */ @@ -240,7 +240,7 @@ void CPulseAudioClient::initialize() throw (CAudioError) { __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 @@ -251,7 +251,7 @@ void CPulseAudioClient::initialize() throw (CAudioError) { // 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_INTERPOLATE_TIMING | PA_STREAM_ADJUST_LATENCY | @@ -270,7 +270,7 @@ void CPulseAudioClient::initialize() throw (CAudioError) { 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) { @@ -285,7 +285,7 @@ void CPulseAudioClient::initialize() throw (CAudioError) { 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 */ @@ -337,7 +337,7 @@ void CPulseAudioClient::finalize() { 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_ @@ -347,11 +347,11 @@ int CPulseAudioClient::peek(const void** data, size_t* length) throw (CAudioErro 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; @@ -365,7 +365,7 @@ int CPulseAudioClient::peek(const void** data, size_t* length) throw (CAudioErro } 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; @@ -373,7 +373,7 @@ int CPulseAudioClient::peek(const void** data, size_t* length) throw (CAudioErro 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_ @@ -382,8 +382,8 @@ int CPulseAudioClient::drop() throw (CAudioError) { 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; @@ -397,7 +397,7 @@ int CPulseAudioClient::drop() throw (CAudioError) { } 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; @@ -405,7 +405,7 @@ int CPulseAudioClient::drop() throw (CAudioError) { 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_ @@ -415,11 +415,11 @@ int CPulseAudioClient::write(const void* data, size_t length) throw (CAudioError 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; @@ -433,7 +433,7 @@ int CPulseAudioClient::write(const void* data, size_t length) throw (CAudioError } 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; @@ -443,11 +443,11 @@ void CPulseAudioClient::cork(bool cork) throw (CAudioError) { 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(); @@ -465,7 +465,7 @@ void CPulseAudioClient::cork(bool cork) throw (CAudioError) { 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(); @@ -488,7 +488,7 @@ bool CPulseAudioClient::drain() throw (CAudioError) { 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(); @@ -508,7 +508,7 @@ bool CPulseAudioClient::flush() throw (CAudioError) { 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(); @@ -526,13 +526,13 @@ bool CPulseAudioClient::flush() throw (CAudioError) { 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; @@ -550,17 +550,17 @@ size_t CPulseAudioClient::getWritableSize() throw (CAudioError) { 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_ @@ -570,7 +570,7 @@ void CPulseAudioClient::checkRunningState() throw (CAudioError) { 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); @@ -583,13 +583,13 @@ bool CPulseAudioClient::isInThread() throw (CAudioError) { 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; @@ -607,7 +607,7 @@ size_t CPulseAudioClient::getReadableSize() throw (CAudioError) { 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(); @@ -622,10 +622,10 @@ size_t CPulseAudioClient::getBufferSize() throw (CAudioError) { 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 { @@ -648,7 +648,7 @@ size_t CPulseAudioClient::getBufferSize() throw (CAudioError) { 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(); @@ -660,7 +660,7 @@ pa_usec_t CPulseAudioClient::getLatency() throw (CAudioError) { 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; @@ -676,7 +676,7 @@ pa_usec_t CPulseAudioClient::getLatency() throw (CAudioError) { 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 */ @@ -694,7 +694,7 @@ pa_usec_t CPulseAudioClient::getLatency() throw (CAudioError) { 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(); @@ -714,11 +714,11 @@ pa_usec_t CPulseAudioClient::getFinalLatency() throw (CAudioError) { 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 { @@ -726,7 +726,7 @@ pa_usec_t CPulseAudioClient::getFinalLatency() throw (CAudioError) { 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) { diff --git a/src/cpp/CPulseAudioPolicy.cpp b/src/cpp/CPulseAudioPolicy.cpp index 429c896..12a6bb4 100644 --- a/src/cpp/CPulseAudioPolicy.cpp +++ b/src/cpp/CPulseAudioPolicy.cpp @@ -27,7 +27,7 @@ using namespace tizen_media_audio; * class CPulseAudioPolicy */ CPulseAudioPolicy::CPulseAudioPolicy() : - __mPolicy(POLICY_DEFAULT) { + __mPolicy(EPolicy::POLICY_DEFAULT) { } CPulseAudioPolicy::CPulseAudioPolicy(EPolicy policy) : @@ -38,8 +38,8 @@ CPulseAudioPolicy::~CPulseAudioPolicy() { } 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; diff --git a/src/cpp/CPulseAudioVolume.cpp b/src/cpp/CPulseAudioVolume.cpp index 5e7ceeb..66a3330 100644 --- a/src/cpp/CPulseAudioVolume.cpp +++ b/src/cpp/CPulseAudioVolume.cpp @@ -26,7 +26,7 @@ using namespace tizen_media_audio; /** * 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) : diff --git a/src/cpp/CPulseStreamSpec.cpp b/src/cpp/CPulseStreamSpec.cpp index 73025e2..bbc1b65 100644 --- a/src/cpp/CPulseStreamSpec.cpp +++ b/src/cpp/CPulseStreamSpec.cpp @@ -39,7 +39,7 @@ static const char* STREAM_LATENCY_VOIP = "voip"; CPulseStreamSpec::CPulseStreamSpec() throw (CAudioError) : - __mLatency(STREAM_LATENCY_INPUT_MID), + __mLatency(EStreamLatency::STREAM_LATENCY_INPUT_MID), __mStreamName(NULL) { __adjustSpec(); } @@ -67,11 +67,11 @@ void CPulseStreamSpec::__adjustSpec() throw (CAudioError) { // 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; @@ -79,11 +79,11 @@ void CPulseStreamSpec::__adjustSpec() throw (CAudioError) { // 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; @@ -94,35 +94,35 @@ void CPulseStreamSpec::__adjustSpec() throw (CAudioError) { // 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; @@ -137,20 +137,20 @@ const char* CPulseStreamSpec::getStreamLatencyToString() { 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: diff --git a/src/cpp/cpp_audio_io.cpp b/src/cpp/cpp_audio_io.cpp index f2a0174..59ecc1a 100644 --- a/src/cpp/cpp_audio_io.cpp +++ b/src/cpp/cpp_audio_io.cpp @@ -96,45 +96,45 @@ static audio_io_error_e __convert_CAudioError(CAudioError& error) { 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; } @@ -145,22 +145,22 @@ static audio_io_error_e __convert_CAudioError(CAudioError& error) { 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: @@ -171,22 +171,22 @@ static void __convert_audio_info_channel_2_channel(const CAudioInfo::EChannel& s 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: @@ -197,57 +197,57 @@ static void __convert_audio_info_sample_type_2_sample_type(const CAudioInfo::ESa 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: @@ -259,16 +259,16 @@ static void __convert_audio_info_audio_type_2_sound_type(const CAudioInfo::EAudi 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: @@ -279,15 +279,15 @@ static audio_io_state_e __convert_state_type(const CAudioInfo::EAudioIOState src 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); } } @@ -295,14 +295,14 @@ static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_ __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); @@ -313,7 +313,7 @@ static CAudioInfo __generate_audio_input_info(int sampleRate, audio_channel_e ch 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); @@ -335,22 +335,22 @@ static CAudioInfo __generate_audio_output_info(int sampleRate, audio_channel_e c 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; } @@ -363,21 +363,21 @@ int cpp_audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_t 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(); @@ -407,21 +407,21 @@ int cpp_audio_in_create_loopback(int sample_rate, audio_channel_e channel, audio 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(); @@ -451,7 +451,7 @@ int cpp_audio_in_destroy(audio_in_h input) { 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); @@ -472,24 +472,24 @@ int cpp_audio_in_set_stream_info(audio_in_h input, sound_stream_info_h stream_in 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) { @@ -505,7 +505,7 @@ int cpp_audio_in_prepare(audio_in_h input) { 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); @@ -524,7 +524,7 @@ int cpp_audio_in_unprepare(audio_in_h input) { 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); @@ -543,7 +543,7 @@ int cpp_audio_in_pause(audio_in_h input) { 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); @@ -562,7 +562,7 @@ int cpp_audio_in_resume(audio_in_h input) { 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); @@ -581,7 +581,7 @@ int cpp_audio_in_drain(audio_in_h input) { 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); @@ -600,7 +600,7 @@ int cpp_audio_in_flush(audio_in_h input) { 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); @@ -620,7 +620,7 @@ int cpp_audio_in_read(audio_in_h input, void *buffer, unsigned int length) { 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); @@ -644,7 +644,7 @@ int cpp_audio_in_get_buffer_size(audio_in_h input, int *size) { 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); @@ -664,7 +664,7 @@ int cpp_audio_in_get_sample_rate(audio_in_h input, int *sample_rate) { 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); @@ -682,7 +682,7 @@ int cpp_audio_in_get_channel(audio_in_h input, audio_channel_e *channel) { 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); @@ -705,7 +705,7 @@ int cpp_audio_in_get_sample_type(audio_in_h input, audio_sample_type_e *type) { 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); @@ -739,7 +739,7 @@ int cpp_audio_in_set_interrupted_cb(audio_in_h input, audio_io_interrupted_cb ca 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); @@ -765,7 +765,7 @@ int cpp_audio_in_unset_interrupted_cb(audio_in_h input) { 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); @@ -791,11 +791,11 @@ int cpp_audio_in_ignore_session(audio_in_h input) { 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); @@ -832,7 +832,7 @@ int cpp_audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, vo 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); @@ -858,7 +858,7 @@ int cpp_audio_in_unset_stream_cb(audio_in_h input) { 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); @@ -885,7 +885,7 @@ int cpp_audio_in_peek(audio_in_h input, const void **buffer, unsigned int *lengt 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(handle->audioIoHandle); @@ -907,7 +907,7 @@ int cpp_audio_in_drop(audio_in_h input) { 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(handle->audioIoHandle); @@ -927,7 +927,7 @@ int cpp_audio_in_set_state_changed_cb(audio_in_h input, audio_in_state_changed_c 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); @@ -953,7 +953,7 @@ int cpp_audio_in_unset_state_changed_cb(audio_in_h input) { 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); @@ -982,21 +982,21 @@ int cpp_audio_out_create(int sample_rate, audio_channel_e channel, audio_sample_ 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(); @@ -1025,21 +1025,21 @@ int cpp_audio_out_create_new(int sample_rate, audio_channel_e channel, audio_sam 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(); @@ -1069,7 +1069,7 @@ int cpp_audio_out_destroy(audio_out_h output) { 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); @@ -1090,24 +1090,24 @@ int cpp_audio_out_set_stream_info(audio_out_h output, sound_stream_info_h stream 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) { @@ -1123,7 +1123,7 @@ int cpp_audio_out_prepare(audio_out_h output) { 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); @@ -1142,7 +1142,7 @@ int cpp_audio_out_unprepare(audio_out_h output) { 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); @@ -1161,7 +1161,7 @@ int cpp_audio_out_pause(audio_out_h output) { 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); @@ -1180,7 +1180,7 @@ int cpp_audio_out_resume(audio_out_h output) { 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); @@ -1199,7 +1199,7 @@ int cpp_audio_out_drain(audio_out_h output) { 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); @@ -1218,7 +1218,7 @@ int cpp_audio_out_flush(audio_out_h output) { 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); @@ -1238,7 +1238,7 @@ int cpp_audio_out_write(audio_out_h output, void *buffer, unsigned int length) { 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); @@ -1262,7 +1262,7 @@ int cpp_audio_out_get_buffer_size(audio_out_h output, int *size) { 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); @@ -1282,7 +1282,7 @@ int cpp_audio_out_get_sample_rate(audio_out_h output, int *sample_rate) { 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); @@ -1300,7 +1300,7 @@ int cpp_audio_out_get_channel(audio_out_h output, audio_channel_e *channel) { 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); @@ -1323,7 +1323,7 @@ int cpp_audio_out_get_sample_type(audio_out_h output, audio_sample_type_e *type) 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); @@ -1346,7 +1346,7 @@ int cpp_audio_out_get_sound_type(audio_out_h output, sound_type_e *type) { 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); @@ -1369,7 +1369,7 @@ int cpp_audio_out_set_interrupted_cb(audio_out_h output, audio_io_interrupted_cb 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); @@ -1395,7 +1395,7 @@ int cpp_audio_out_unset_interrupted_cb(audio_out_h output) { 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); @@ -1421,11 +1421,11 @@ int cpp_audio_out_ignore_session(audio_out_h output) { 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); @@ -1444,7 +1444,7 @@ int cpp_audio_out_set_stream_cb(audio_out_h output, audio_out_stream_cb callback 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); @@ -1470,7 +1470,7 @@ int cpp_audio_out_unset_stream_cb(audio_out_h output) { 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); @@ -1496,7 +1496,7 @@ int cpp_audio_out_set_state_changed_cb(audio_out_h output, audio_in_state_change 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); @@ -1522,7 +1522,7 @@ int cpp_audio_out_unset_state_changed_cb(audio_out_h output) { 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);