From 2ef80e7e8230299522e253ab0a592a7e7a83b1ad Mon Sep 17 00:00:00 2001 From: KimJeongYeon Date: Wed, 12 Aug 2015 15:18:29 +0900 Subject: [PATCH] audio-io updated C++ coding rule [Version] 0.3.14 [Profile] Common [Issue Type] NA [Dependency module] NA [Dependency commit] NA [Comment] Signed-off-by: KimJeongYeon Change-Id: Ib411b229e1a112e07db5028b4edbfa7b991c78d5 --- include/CAudioError.h | 28 +-- include/CAudioIO.h | 70 +++--- include/CAudioInfo.h | 52 ++--- include/CAudioInput.h | 29 +-- include/CAudioOutput.h | 19 +- include/CAudioSessionHandler.h | 111 +++++---- include/CPulseAudioClient.h | 61 +++-- include/CPulseAudioPolicy.h | 11 +- include/CPulseAudioVolume.h | 13 +- include/CPulseStreamSpec.h | 25 +- packaging/capi-media-audio-io.spec | 2 +- src/cpp/CAudioError.cpp | 58 ++--- src/cpp/CAudioIO.cpp | 80 +++---- src/cpp/CAudioInfo.cpp | 40 ++-- src/cpp/CAudioInput.cpp | 110 ++++----- src/cpp/CAudioOutput.cpp | 46 ++-- src/cpp/CAudioSessionHandler.cpp | 258 ++++++++++----------- src/cpp/CPulseAudioClient.cpp | 352 ++++++++++++++--------------- src/cpp/CPulseAudioPolicy.cpp | 12 +- src/cpp/CPulseAudioVolume.cpp | 14 +- src/cpp/CPulseStreamSpec.cpp | 70 +++--- 21 files changed, 727 insertions(+), 734 deletions(-) diff --git a/include/CAudioError.h b/include/CAudioError.h index 80fe8f5..34f3085 100644 --- a/include/CAudioError.h +++ b/include/CAudioError.h @@ -29,9 +29,7 @@ namespace tizen_media_audio { */ class CAudioError { public: - /* Constants Definition */ - static const unsigned int MSG_LENGTH = 512; - + /* Enums Definition */ enum EError { ERROR_NONE, @@ -63,17 +61,9 @@ namespace tizen_media_audio { ERROR_MAX }; - private: - /* Members */ - static EError mLastError; - static char mLastErrorMsg[MSG_LENGTH]; - - EError mError; - char mErrorMsg[MSG_LENGTH]; - - const char* __convertErrorToString(EError err); + /* Constants Definition */ + static const unsigned int MSG_LENGTH = 512; - public: /* Constructor & Destructor */ CAudioError(EError err); CAudioError(EError err, const char* fileName, const char* parentFunc, int lineNum); @@ -94,9 +84,19 @@ namespace tizen_media_audio { CAudioError& operator = (const CAudioError& err); bool operator != (const EError err); bool operator == (const EError err); -// friend bool operator == (const CAudioError& src, const EError& err); + //friend bool operator == (const CAudioError& src, const EError& err); + + private: + const char* __convertErrorToString(EError err); + + /* Members */ + static EError __mLastError; + static char __mLastErrorMsg[MSG_LENGTH]; + EError __mError; + char __mErrorMsg[MSG_LENGTH]; }; + } /* namespace tizen_media_audio */ #endif diff --git a/include/CAudioIO.h b/include/CAudioIO.h index b920752..dc648a2 100644 --- a/include/CAudioIO.h +++ b/include/CAudioIO.h @@ -37,7 +37,7 @@ namespace tizen_media_audio { void (*onStream)(size_t nbytes, void* user_data); SStreamCallback() : mUserData(NULL), onStream(NULL) - {/* Empty Body */} + { /* Empty Body */ } }; struct SStateChangedCallback { @@ -45,7 +45,7 @@ namespace tizen_media_audio { void (*onStateChanged)(CAudioInfo::EAudioIOState state, CAudioInfo::EAudioIOState statePrev, bool byPolicy, void* user_data); SStateChangedCallback() : mUserData(NULL), onStateChanged(NULL) - {/* Empty Body */} + { /* Empty Body */ } }; struct SInterruptCallback { @@ -53,41 +53,9 @@ namespace tizen_media_audio { void (*onInterrupt)(IAudioSessionEventListener::EInterruptCode code, void* user_data); SInterruptCallback() : mUserData(NULL), onInterrupt(NULL) - {/* Empty Body */} + { /* Empty Body */ } }; - private: - pthread_mutex_t mMutex; - pthread_cond_t mCond; - bool mIsInit; - bool mForceIgnore; - - protected: - CAudioSessionHandler* mpAudioSessionHandler; - CPulseAudioClient* mpPulseAudioClient; - CAudioInfo mAudioInfo; - - SStreamCallback mStreamCallback; - SStateChangedCallback mStateChangedCallback; - SInterruptCallback mInterruptCallback; - - CAudioInfo::EAudioIOState mState; - CAudioInfo::EAudioIOState mStatePrev; - bool mByPolicy; - - /* Protected Methods */ - virtual void setInit(bool flag); - virtual bool isInit(); - virtual bool IsReady(); - - void internalLock() throw (CAudioError); - void internalUnlock() throw (CAudioError); - void internalWait() throw (CAudioError); - void internalSignal() throw (CAudioError); - - bool isForceIgnore(); - - public: /* Constructor & Destructor */ CAudioIO(); CAudioIO(CAudioInfo& audioInfo); @@ -128,8 +96,40 @@ namespace tizen_media_audio { SInterruptCallback getInterruptCallback() throw (CAudioError); void ignoreSession() throw (CAudioError); + + protected: + /* Protected Methods */ + virtual void setInit(bool flag); + virtual bool isInit(); + virtual bool IsReady(); + + void internalLock() throw (CAudioError); + void internalUnlock() throw (CAudioError); + void internalWait() throw (CAudioError); + void internalSignal() throw (CAudioError); + + bool isForceIgnore(); + + CAudioSessionHandler* mpAudioSessionHandler; + CPulseAudioClient* mpPulseAudioClient; + CAudioInfo mAudioInfo; + + SStreamCallback mStreamCallback; + SStateChangedCallback mStateChangedCallback; + SInterruptCallback mInterruptCallback; + + CAudioInfo::EAudioIOState mState; + CAudioInfo::EAudioIOState mStatePrev; + bool mByPolicy; + + private: + pthread_mutex_t __mMutex; + pthread_cond_t __mCond; + bool __mIsInit; + bool __mForceIgnore; }; + } /* namespace tizen_media_audio */ #endif diff --git a/include/CAudioInfo.h b/include/CAudioInfo.h index 8feab06..2dba2a8 100644 --- a/include/CAudioInfo.h +++ b/include/CAudioInfo.h @@ -29,9 +29,6 @@ namespace tizen_media_audio { */ class CAudioInfo { public: - const static unsigned int MIN_SYSTEM_SAMPLERATE = 8000; - const static unsigned int MAX_SYSTEM_SAMPLERATE = 48000; - enum EChannel { CHANNEL_MONO = 1, /**< 1 channel, mono */ CHANNEL_STEREO, /**< 2 channel, stereo */ @@ -87,14 +84,27 @@ namespace tizen_media_audio { AUDIO_IO_STATE_PAUSED, /**< Audio-io handle is ready and the stream is paused */ }; - private: - unsigned int mSampleRate; - EChannel mChannel; - ESampleType mSampleType; - EAudioType mAudioType; - int mAudioIndex; + const static unsigned int MIN_SYSTEM_SAMPLERATE = 8000; + const static unsigned int MAX_SYSTEM_SAMPLERATE = 48000; + + /* Constructors */ + CAudioInfo(); + CAudioInfo(unsigned int sampleRate, EChannel channel, ESampleType sampleType, EAudioType audioType, int audioIndex) throw (CAudioError); + + /* Setter & Getter */ + unsigned int getSampleRate(); + EChannel getChannel(); + ESampleType getSampleType(); + EAudioType getAudioType(); + void setAudioType(EAudioType AudioType); + int getAudioIndex(); + void setAudioIndex(int AudioIndex); + void convertAudioType2StreamType (CAudioInfo::EAudioType audioType, char **streamType); + void convertInputStreamType2AudioType (char *streamType, CAudioInfo::EAudioType *audioType); + void convertOutputStreamType2AudioType (char *streamType, CAudioInfo::EAudioType *audioType); - const char *StreamTypeTable[AUDIO_TYPE_MAX] = { + private: + const char *__STREAM_TYPE_TABLE[AUDIO_TYPE_MAX] = { /* Input Type */ "media", /**< AUDIO_IN_TYPE_MEDIA */ //"system", /**< AUDIO_IN_TYPE_SYSTEM */ @@ -128,24 +138,14 @@ namespace tizen_media_audio { //"loopback", /**< AUDIO_OUT_TYPE_LOOPBACK */ }; - public: - /* Constructors */ - CAudioInfo(); - CAudioInfo(unsigned int sampleRate, EChannel channel, ESampleType sampleType, EAudioType audioType, int audioIndex) throw (CAudioError); - - /* Setter & Getter */ - unsigned int getSampleRate(); - EChannel getChannel(); - ESampleType getSampleType(); - EAudioType getAudioType(); - void setAudioType(EAudioType AudioType); - int getAudioIndex(); - void setAudioIndex(int AudioIndex); - void convertAudioType2StreamType (CAudioInfo::EAudioType audioType, char **streamType); - void convertInputStreamType2AudioType (char *streamType, CAudioInfo::EAudioType *audioType); - void convertOutputStreamType2AudioType (char *streamType, CAudioInfo::EAudioType *audioType); + unsigned int __mSampleRate; + EChannel __mChannel; + ESampleType __mSampleType; + EAudioType __mAudioType; + int __mAudioIndex; }; + } /* namespace tizen_media_audio */ #endif diff --git a/include/CAudioInput.h b/include/CAudioInput.h index f8c0284..dde06c8 100644 --- a/include/CAudioInput.h +++ b/include/CAudioInput.h @@ -28,20 +28,6 @@ namespace tizen_media_audio { * A class CAudioInput that inherited from CAudioIO */ class CAudioInput : public CAudioIO { - private: - - const void* mpSyncReadDataPtr; - size_t mSyncReadIndex; - size_t mSyncReadLength; - - bool mIsUsedSyncRead; - bool mIsInit; - - /* Private Methods */ - void setInit(bool flag); - bool IsInit(); - bool IsReady(); - public: /* Constructor & Destructor */ CAudioInput(CAudioInfo& info); @@ -79,7 +65,22 @@ namespace tizen_media_audio { size_t read(void* buffer, size_t length) throw (CAudioError); int peek(const void** buffer, size_t* length) throw (CAudioError); int drop() throw (CAudioError); + + private: + /* Private Methods */ + void __setInit(bool flag); + bool __IsInit(); + bool __IsReady(); + + const void* __mpSyncReadDataPtr; + size_t __mSyncReadIndex; + size_t __mSyncReadLength; + + bool __mIsUsedSyncRead; + bool __mIsInit; }; + + } /* namespace tizen_media_audio */ #endif diff --git a/include/CAudioOutput.h b/include/CAudioOutput.h index 984bf0d..6adb991 100644 --- a/include/CAudioOutput.h +++ b/include/CAudioOutput.h @@ -30,15 +30,6 @@ namespace tizen_media_audio { * A class CAudioOutput that inherited from CAudioIO */ class CAudioOutput : public CAudioIO { - private: - bool mIsUsedSyncWrite; - bool mIsInit; - - /* Private Methods */ - void setInit(bool flag); - bool IsInit(); - bool IsReady(); - public: /* Constructor & Destructor */ CAudioOutput(CAudioInfo& info); @@ -71,8 +62,18 @@ namespace tizen_media_audio { /* Methods */ size_t write(const void* buffer, size_t length) throw (CAudioError); + + private: + /* Private Methods */ + void __setInit(bool flag); + bool __IsInit(); + bool __IsReady(); + + bool __mIsUsedSyncWrite; + bool __mIsInit; }; + } /* namespace tizen_media_audio */ #endif diff --git a/include/CAudioSessionHandler.h b/include/CAudioSessionHandler.h index 7c4ab9a..409e311 100644 --- a/include/CAudioSessionHandler.h +++ b/include/CAudioSessionHandler.h @@ -40,37 +40,37 @@ namespace tizen_media_audio { AUDIO_SESSION_TYPE_PLAYBACK }; - private: - /* Static Member */ - static int sCaptureRef; - static int sFocusRef; - - /* Members */ - int mId; - int mOptions; - - EAudioSessionType mAudioSession; - MMSessionType mMultimediaSession; + /* Constructor & Destructor */ + CAudioSessionHandler(EAudioSessionType sessionType, CAudioInfo& audioInfo, IAudioSessionEventListener* listener); + virtual ~CAudioSessionHandler(); - mm_sound_focus_type_e mFocusType; /* For audio focus */ - mm_sound_focus_state_e mState; /* For audio focus */ - char* mReasonForChange; /* For audio focus */ - char* mAdditionalInfo; /* For audio focus */ + /* Methods */ + virtual void initialize() throw (CAudioError); + virtual void finalize(); - CAudioInfo mAudioInfo; /* Referenced from CAudioIO */ + bool isSkipSessionEvent() throw (CAudioError); - IAudioSessionEventListener* mpEventListener; + void registerSound() throw (CAudioError); + void unregisterSound() throw (CAudioError); - bool mIsInit; + void updatePlaying() throw (CAudioError); + void updateStop() throw (CAudioError); + void disableSessionHandler() throw (CAudioError); - bool mUseFocus; - int mSubscribeId; + /* Setter & Getter */ + int getId(); + int getOptions(); + EAudioSessionType getAudioSession(); + MMSessionType getMultimediaSession(); + int getSubscribeId(); + CAudioInfo getAudioInfo(); - struct stream_type_table_s { + private: + struct __streamTypeTable { const char* name; MMSessionType type; }; - const struct stream_type_table_s stream_type_table_in[MM_SESSION_TYPE_NUM] = { + const struct __streamTypeTable __STREAM_TYPE_TABLE_IN[MM_SESSION_TYPE_NUM] = { {"media", MM_SESSION_TYPE_MEDIA}, {"media", MM_SESSION_TYPE_MEDIA_RECORD}, {"media", MM_SESSION_TYPE_ALARM}, @@ -83,7 +83,7 @@ namespace tizen_media_audio { {"media", MM_SESSION_TYPE_RECORD_AUDIO}, {"media", MM_SESSION_TYPE_RECORD_VIDEO} }; - const struct stream_type_table_s stream_type_table_out[MM_SESSION_TYPE_NUM] = { + const struct __streamTypeTable __STREAM_TYPE_TABLE_OUT[MM_SESSION_TYPE_NUM] = { {"media", MM_SESSION_TYPE_MEDIA}, {"media", MM_SESSION_TYPE_MEDIA_RECORD}, {"alarm", MM_SESSION_TYPE_ALARM}, @@ -98,51 +98,46 @@ namespace tizen_media_audio { }; /* Private Static Methods */ - static int PCM_CAPTURE_COUNT_INC(); - static int PCM_CAPTURE_COUNT_DEC(); - static int PCM_CAPTURE_COUNT_GET(); - static int FOCUS_ID_COUNT_INC(); - static int FOCUS_ID_COUNT_DEC(); - static int FOCUS_ID_COUNT_GET(); - - static void _sound_pcm_signal_cb(mm_sound_signal_name_t signal, int value, void *user_data); - static ASM_cb_result_t _sound_pcm_asm_cb(int handle, ASM_event_sources_t eventSrc, ASM_sound_commands_t command, unsigned int soundState, void *cbData); - static void _sound_pcm_focus_cb(int id, mm_sound_focus_type_e focus_type, mm_sound_focus_state_e state, const char *reason_for_change, const char *additional_info, void *user_data); - static void _sound_pcm_focus_watch_cb(int id, mm_sound_focus_type_e focus_type, mm_sound_focus_state_e state, const char *reason_for_change, const char *additional_info, void *user_data); + static int __pcmCaptureCountInc(); + static int __pcmCaptureCountDec(); + static int __pcmCaptureCountGet(); + static int __focusIdCountInc(); + static int __focusIdCountDec(); + static int __focusIdCountGet(); - /* Private Method */ - CAudioError _convertStreamType(EAudioSessionType type1, MMSessionType type2, int *index); - CAudioError _getAsmInformation(MMSessionType *type, int *options); - bool _isFocusRequired(MMSessionType type, int options); + static void __sound_pcm_signal_cb(mm_sound_signal_name_t signal, int value, void *user_data); + static void __sound_pcm_focus_cb(int id, mm_sound_focus_type_e focus_type, mm_sound_focus_state_e state, const char *reason_for_change, const char *additional_info, void *user_data); + static void __sound_pcm_focus_watch_cb(int id, mm_sound_focus_type_e focus_type, mm_sound_focus_state_e state, const char *reason_for_change, const char *additional_info, void *user_data); - public: - /* Constructor & Destructor */ - CAudioSessionHandler(EAudioSessionType sessionType, CAudioInfo& audioInfo, IAudioSessionEventListener* listener); - virtual ~CAudioSessionHandler(); + /* Private Method */ + CAudioError __convertStreamType(EAudioSessionType type1, MMSessionType type2, int *index); + CAudioError __getAsmInformation(MMSessionType *type, int *options); + bool __isFocusRequired(MMSessionType type, int options); - /* Methods */ - virtual void initialize() throw (CAudioError); - virtual void finalize(); + /* Static Member */ + static int __sCaptureRef; + static int __sFocusRef; - bool isSkipSessionEvent() throw (CAudioError); + /* Members */ + int __mId; + int __mOptions; - void registerSound() throw (CAudioError); - void unregisterSound() throw (CAudioError); + EAudioSessionType __mAudioSession; + MMSessionType __mMultimediaSession; - void updatePlaying() throw (CAudioError); - void updateStop() throw (CAudioError); - void disableSessionHandler() throw (CAudioError); + mm_sound_focus_type_e __mFocusType; /* For audio focus */ + mm_sound_focus_state_e __mState; /* For audio focus */ + char* __mReasonForChange; /* For audio focus */ + char* __mAdditionalInfo; /* For audio focus */ - /* Setter & Getter */ - int getId(); - int getOptions(); + CAudioInfo __mAudioInfo; /* Referenced from CAudioIO */ - EAudioSessionType getAudioSession(); - MMSessionType getMultimediaSession(); + IAudioSessionEventListener* __mpEventListener; - int getSubscribeId(); + bool __mIsInit; - CAudioInfo getAudioInfo(); + bool __mUseFocus; + int __mSubscribeId; }; diff --git a/include/CPulseAudioClient.h b/include/CPulseAudioClient.h index 90a01fb..fe5db0a 100644 --- a/include/CPulseAudioClient.h +++ b/include/CPulseAudioClient.h @@ -36,43 +36,14 @@ namespace tizen_media_audio { class CPulseStreamSpec; class CPulseAudioClient { public: - /* Constants */ - static const char* CLIENT_NAME; - enum EStreamDirection { STREAM_DIRECTION_RECORD, /**< Record stream */ STREAM_DIRECTION_PLAYBACK /**< Playback stream */ }; - private: - /* Members */ - EStreamDirection mDirection; - CPulseStreamSpec mSpec; - IPulseStreamListener* mpListener; - - pa_threaded_mainloop* mpMainloop; - pa_context* mpContext; - pa_stream* mpStream; - pa_proplist* mpPropList; - - bool mIsInit; - bool mIsOperationSuccess; - - /* Static Methods */ - - /* Private Method */ - - /* Private Calblack Method */ - static void _contextStateChangeCb(pa_context* c, void* user_data); - static void _successContextCb(pa_context* c, int success, void* user_data); - - static void _streamStateChangeCb(pa_stream* s, void* user_data); - static void _streamCaptureCb(pa_stream* s, size_t length, void* user_data); - static void _streamPlaybackCb(pa_stream* s, size_t length, void* user_data); - static void _streamLatencyUpdateCb(pa_stream* s, void* user_data); - static void _successStreamCb(pa_stream* s, int success, void* user_data); + /* Constants */ + static const char* CLIENT_NAME; - public: /* Constructor & Destructor */ CPulseAudioClient(EStreamDirection direction, CPulseStreamSpec& spec, @@ -108,6 +79,34 @@ namespace tizen_media_audio { /* Setter & Getter */ EStreamDirection getStreamDirection(); CPulseStreamSpec getStreamSpec(); + + private: + /* Members */ + EStreamDirection __mDirection; + CPulseStreamSpec __mSpec; + IPulseStreamListener* __mpListener; + + pa_threaded_mainloop* __mpMainloop; + pa_context* __mpContext; + pa_stream* __mpStream; + pa_proplist* __mpPropList; + + bool __mIsInit; + bool __mIsOperationSuccess; + + /* Static Methods */ + + /* Private Method */ + + /* Private Calblack Method */ + static void __contextStateChangeCb(pa_context* c, void* user_data); + static void __successContextCb(pa_context* c, int success, void* user_data); + + static void __streamStateChangeCb(pa_stream* s, void* user_data); + static void __streamCaptureCb(pa_stream* s, size_t length, void* user_data); + static void __streamPlaybackCb(pa_stream* s, size_t length, void* user_data); + static void __streamLatencyUpdateCb(pa_stream* s, void* user_data); + static void __successStreamCb(pa_stream* s, int success, void* user_data); }; diff --git a/include/CPulseAudioPolicy.h b/include/CPulseAudioPolicy.h index ce941bc..016d677 100644 --- a/include/CPulseAudioPolicy.h +++ b/include/CPulseAudioPolicy.h @@ -31,7 +31,7 @@ namespace tizen_media_audio { */ class CPulseAudioPolicy { public: - /* Constants */ + /* Enums */ enum EPolicy { POLICY_DEFAULT, POLICY_OUT_AUTO, @@ -45,11 +45,6 @@ namespace tizen_media_audio { POLICY_MAX }; - private: - /* Members */ - EPolicy mPolicy; - - public: /* Constructors */ CPulseAudioPolicy(); CPulseAudioPolicy(EPolicy policy); @@ -62,6 +57,10 @@ namespace tizen_media_audio { /* Override */ bool operator != (const EPolicy policy); bool operator == (const EPolicy policy); + + private: + /* Members */ + EPolicy __mPolicy; }; diff --git a/include/CPulseAudioVolume.h b/include/CPulseAudioVolume.h index f4cbbf5..813783b 100644 --- a/include/CPulseAudioVolume.h +++ b/include/CPulseAudioVolume.h @@ -31,7 +31,7 @@ namespace tizen_media_audio { */ class CPulseAudioVolume { public: - /* Constants */ + /* Enums */ enum EVolume { VOLUME_SYSTEM, /**< System volume type */ VOLUME_NOTIFICATION, /**< Notification volume type */ @@ -61,12 +61,6 @@ namespace tizen_media_audio { VOLUME_GAIN_MAX }; - private: - /* Members */ - EVolume mVolume; - EVolumeGain mVolumeGain; - - public: /* Constructor & Destructor */ CPulseAudioVolume(); CPulseAudioVolume(EVolume volume, EVolumeGain gain); @@ -80,6 +74,11 @@ namespace tizen_media_audio { void setVolumeGain(EVolumeGain volumeGain); EVolumeGain getVolumeGain(); + + private: + /* Members */ + EVolume __mVolume; + EVolumeGain __mVolumeGain; }; diff --git a/include/CPulseStreamSpec.h b/include/CPulseStreamSpec.h index 131ecdc..d09a194 100644 --- a/include/CPulseStreamSpec.h +++ b/include/CPulseStreamSpec.h @@ -32,7 +32,7 @@ namespace tizen_media_audio { */ class CPulseStreamSpec { public: - /* Constants */ + /* Enums */ enum EStreamLatency { STREAM_LATENCY_INPUT_LOW, STREAM_LATENCY_INPUT_MID, @@ -45,18 +45,6 @@ namespace tizen_media_audio { STREAM_LATENCY_MAX }; - private: - /* Members */ - EStreamLatency mLatency; - CAudioInfo mAudioInfo; - pa_sample_spec mSampleSpec; - pa_channel_map mChannelMap; - const char* mStreamName; - - /* private meethod */ - void _adjustSpec() throw (CAudioError); - - public: /* Constructor & Destructor */ CPulseStreamSpec() throw (CAudioError); CPulseStreamSpec(EStreamLatency latency, CAudioInfo& audioInfo) throw (CAudioError); @@ -70,6 +58,17 @@ namespace tizen_media_audio { pa_sample_spec getSampleSpec(); pa_channel_map getChannelMap(); const char* getStreamName(); + + private: + /* Private Methods */ + void __adjustSpec() throw (CAudioError); + + /* Members */ + EStreamLatency __mLatency; + CAudioInfo __mAudioInfo; + pa_sample_spec __mSampleSpec; + pa_channel_map __mChannelMap; + const char* __mStreamName; }; diff --git a/packaging/capi-media-audio-io.spec b/packaging/capi-media-audio-io.spec index d8a8f66..40e78c1 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.13 +Version: 0.3.14 Release: 0 Group: Multimedia/API License: Apache-2.0 diff --git a/src/cpp/CAudioError.cpp b/src/cpp/CAudioError.cpp index 48e89e5..2a10dba 100644 --- a/src/cpp/CAudioError.cpp +++ b/src/cpp/CAudioError.cpp @@ -27,51 +27,51 @@ using namespace tizen_media_audio; /** * class CAudioError */ -CAudioError::EError CAudioError::mLastError = CAudioError::ERROR_NONE; -char CAudioError::mLastErrorMsg[CAudioError::MSG_LENGTH]; +CAudioError::EError CAudioError::__mLastError = CAudioError::ERROR_NONE; +char CAudioError::__mLastErrorMsg[CAudioError::MSG_LENGTH]; CAudioError::CAudioError(EError err) : - mError(err) { - mLastError = mError; + __mError(err) { + __mLastError = __mError; } CAudioError::CAudioError(EError err, const char* fileName, const char* parentFunc, int lineNum) : - mError(err) { - mLastError = mError; + __mError(err) { + __mLastError = __mError; const char* findFileName = strrchr(fileName, '/'); findFileName++; - const char* errStr = __convertErrorToString(mError); + const char* errStr = __convertErrorToString(__mError); - snprintf(mErrorMsg, CAudioError::MSG_LENGTH, "[" + snprintf(__mErrorMsg, CAudioError::MSG_LENGTH, "[" COLOR_RED "THROW" COLOR_END ":%s|" COLOR_YELLOW "ERR" COLOR_END ":%s|" COLOR_YELLOW "FUNC" COLOR_END ":%s(%d)]", findFileName, errStr, parentFunc, lineNum); - snprintf(mLastErrorMsg, CAudioError::MSG_LENGTH, "LastError:%s", mErrorMsg); + snprintf(__mLastErrorMsg, CAudioError::MSG_LENGTH, "LastError:%s", __mErrorMsg); } CAudioError::CAudioError(EError err, const char* msg, const char* fileName, const char* parentFunc, int lineNum) : - mError(err) { - mLastError = mError; + __mError(err) { + __mLastError = __mError; const char* findFileName = strrchr(fileName, '/'); findFileName++; - const char* errStr = __convertErrorToString(mError); + const char* errStr = __convertErrorToString(__mError); - snprintf(mErrorMsg, CAudioError::MSG_LENGTH, "[" + snprintf(__mErrorMsg, CAudioError::MSG_LENGTH, "[" COLOR_RED "THROW" COLOR_END ":%s|" COLOR_YELLOW "ERR" COLOR_END ":%s|" COLOR_YELLOW "FUNC" COLOR_END ":%s(%d)]" COLOR_YELLOW "MSG" COLOR_END ":" COLOR_CYAN "%s" COLOR_END, findFileName, errStr, parentFunc, lineNum, msg); - snprintf(mLastErrorMsg, CAudioError::MSG_LENGTH, "LastError:%s", mErrorMsg); + snprintf(__mLastErrorMsg, CAudioError::MSG_LENGTH, "LastError:%s", __mErrorMsg); } //CAudioError::CAudioError(CAudioError& err) { -// mError = err.mError; -// strncpy(mErrorMsg, err.mErrorMsg, MSG_LENGTH); +// __mError = err.__mError; +// strncpy(__mErrorMsg, err.__mErrorMsg, MSG_LENGTH); //} CAudioError::~CAudioError() { @@ -104,44 +104,44 @@ const char* CAudioError::__convertErrorToString(EError err) { } CAudioError::EError CAudioError::getLastError() { - return mLastError; + return __mLastError; } const char* CAudioError::getLastErrorMsg() { - return mLastErrorMsg; + return __mLastErrorMsg; } CAudioError::EError CAudioError::getError() { - return mError; + return __mError; } const char* CAudioError::getErrorMsg() { - return mErrorMsg; + return __mErrorMsg; } CAudioError& CAudioError::operator = (const EError err) { - mError = err; - mLastError = mError; + __mError = err; + __mLastError = __mError; return *this; } CAudioError& CAudioError::operator = (const CAudioError& err) { - mError = err.mError; - mLastError = mError; - memcpy(mErrorMsg, err.mErrorMsg, MSG_LENGTH); - memcpy(mLastErrorMsg, mErrorMsg, MSG_LENGTH); + __mError = err.__mError; + __mLastError = __mError; + memcpy(__mErrorMsg, err.__mErrorMsg, MSG_LENGTH); + memcpy(__mLastErrorMsg, __mErrorMsg, MSG_LENGTH); return *this; } bool CAudioError::operator != (const EError err) { - return (mError != err); + return (__mError != err); } bool CAudioError::operator == (const EError err) { - return (mError == err); + return (__mError == err); } //bool operator == (const CAudioError& src, const CAudioError::EError& err) { -// //return (src.mLastError == err); +// //return (src.__mLastError == err); // return true; //} diff --git a/src/cpp/CAudioIO.cpp b/src/cpp/CAudioIO.cpp index e641fab..fc3792f 100644 --- a/src/cpp/CAudioIO.cpp +++ b/src/cpp/CAudioIO.cpp @@ -31,16 +31,16 @@ using namespace tizen_media_audio; * class CAudioIO */ CAudioIO::CAudioIO() : - mIsInit(false), - mForceIgnore(false), mpAudioSessionHandler(NULL), - mpPulseAudioClient(NULL) { + mpPulseAudioClient(NULL), + __mIsInit(false), + __mForceIgnore(false) { mState = CAudioInfo::AUDIO_IO_STATE_NONE; mStatePrev = CAudioInfo::AUDIO_IO_STATE_NONE; mByPolicy = false; } -CAudioIO::CAudioIO(CAudioInfo& audioInfo) : mIsInit(false), mForceIgnore(false), mpAudioSessionHandler(NULL), mpPulseAudioClient(NULL) { +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; @@ -51,11 +51,11 @@ CAudioIO::~CAudioIO() { } void CAudioIO::setInit(bool flag) { - mIsInit = flag; + __mIsInit = flag; } bool CAudioIO::isInit() { - return mIsInit; + return __mIsInit; } bool CAudioIO::IsReady() { @@ -63,11 +63,11 @@ bool CAudioIO::IsReady() { } void CAudioIO::internalLock() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } - if (pthread_mutex_lock(&mMutex) != 0) { + if (pthread_mutex_lock(&__mMutex) != 0) { THROW_ERROR_MSG(CAudioError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_lock()"); } #ifdef _AUDIO_IO_DEBUG_TIMING_ @@ -76,11 +76,11 @@ void CAudioIO::internalLock() throw (CAudioError) { } void CAudioIO::internalUnlock() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } - if (pthread_mutex_unlock(&mMutex) != 0) { + if (pthread_mutex_unlock(&__mMutex) != 0) { THROW_ERROR_MSG(CAudioError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_lock()"); } #ifdef _AUDIO_IO_DEBUG_TIMING_ @@ -89,7 +89,7 @@ void CAudioIO::internalUnlock() throw (CAudioError) { } void CAudioIO::internalWait() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } @@ -97,11 +97,11 @@ void CAudioIO::internalWait() throw (CAudioError) { AUDIO_IO_LOGD(COLOR_RED "WAIT" COLOR_END); #endif - pthread_cond_wait(&mCond, &mMutex); + pthread_cond_wait(&__mCond, &__mMutex); } void CAudioIO::internalSignal() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } @@ -109,55 +109,55 @@ void CAudioIO::internalSignal() throw (CAudioError) { AUDIO_IO_LOGD(COLOR_GREEN "SIGNAL" COLOR_END); #endif - pthread_cond_signal(&mCond); + pthread_cond_signal(&__mCond); } bool CAudioIO::isForceIgnore() { - return mForceIgnore; + return __mForceIgnore; } void CAudioIO::initialize() throw (CAudioError) { - if (mIsInit == true) { + if (__mIsInit == true) { return; } AUDIO_IO_LOGD("initialize"); - int ret = pthread_mutex_init(&mMutex, NULL); + int ret = pthread_mutex_init(&__mMutex, NULL); if (ret != 0) { THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed pthread_mutex_init()"); } - ret = pthread_cond_init(&mCond, NULL); + ret = pthread_cond_init(&__mCond, NULL); if (ret != 0) { THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed pthread_cond_init()"); } - mIsInit = true; + __mIsInit = true; } void CAudioIO::finalize() { - if (mIsInit == false) { + if (__mIsInit == false) { return; } AUDIO_IO_LOGD("finalize"); - int ret = pthread_mutex_destroy(&mMutex); + 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); } - ret = pthread_cond_destroy(&mCond); + ret = pthread_cond_destroy(&__mCond); if (ret != 0) { THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_OUT_OF_MEMORY, "Failed pthread_cond_destroy() ret:%d", ret); } - mIsInit = false; + __mIsInit = false; } void CAudioIO::onStream(CPulseAudioClient* pClient, size_t length) { - assert(mIsInit == true); + assert(__mIsInit == true); assert(pClient != NULL); assert(length > 0); @@ -171,7 +171,7 @@ void CAudioIO::onStream(CPulseAudioClient* pClient, size_t length) { } void CAudioIO::onStateChanged(CAudioInfo::EAudioIOState state, bool byPolicy) { - assert(mIsInit == true); + assert(__mIsInit == true); assert(state > 0); mStatePrev = mState; @@ -296,7 +296,7 @@ void CAudioIO::onSignal(CAudioSessionHandler* pHandler, mm_sound_signal_name_t s } void CAudioIO::prepare() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } @@ -309,7 +309,7 @@ void CAudioIO::prepare() throw (CAudioError) { } void CAudioIO::unprepare() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } @@ -322,7 +322,7 @@ void CAudioIO::unprepare() throw (CAudioError) { } void CAudioIO::pause() throw (CAudioError) { - if (mIsInit == false || IsReady() == false) { + if (__mIsInit == false || IsReady() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO"); } @@ -338,7 +338,7 @@ void CAudioIO::pause() throw (CAudioError) { } void CAudioIO::resume() throw (CAudioError) { - if (mIsInit == false || IsReady() == false) { + if (__mIsInit == false || IsReady() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO"); } @@ -354,7 +354,7 @@ void CAudioIO::resume() throw (CAudioError) { } void CAudioIO::drain() throw (CAudioError) { - if (mIsInit == false || IsReady() == false) { + if (__mIsInit == false || IsReady() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO"); } @@ -370,7 +370,7 @@ void CAudioIO::drain() throw (CAudioError) { } void CAudioIO::flush() throw (CAudioError) { - if (mIsInit == false || IsReady() == false) { + if (__mIsInit == false || IsReady() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO"); } @@ -386,7 +386,7 @@ void CAudioIO::flush() throw (CAudioError) { } CAudioInfo CAudioIO::getAudioInfo() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } @@ -394,7 +394,7 @@ CAudioInfo CAudioIO::getAudioInfo() throw (CAudioError) { } void CAudioIO::setStreamCallback(SStreamCallback callback) throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } @@ -402,7 +402,7 @@ void CAudioIO::setStreamCallback(SStreamCallback callback) throw (CAudioError) { } CAudioIO::SStreamCallback CAudioIO::getStreamCallback() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } @@ -410,7 +410,7 @@ CAudioIO::SStreamCallback CAudioIO::getStreamCallback() throw (CAudioError) { } void CAudioIO::setStateChangedCallback(SStateChangedCallback callback) throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } @@ -418,7 +418,7 @@ void CAudioIO::setStateChangedCallback(SStateChangedCallback callback) throw (CA } CAudioIO::SStateChangedCallback CAudioIO::getStateChangedCallback() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } @@ -426,7 +426,7 @@ CAudioIO::SStateChangedCallback CAudioIO::getStateChangedCallback() throw (CAudi } void CAudioIO::setInterruptCallback(SInterruptCallback callback) throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } @@ -434,7 +434,7 @@ void CAudioIO::setInterruptCallback(SInterruptCallback callback) throw (CAudioEr } CAudioIO::SInterruptCallback CAudioIO::getInterruptCallback() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } @@ -443,7 +443,7 @@ CAudioIO::SInterruptCallback CAudioIO::getInterruptCallback() throw (CAudioError void CAudioIO::ignoreSession() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO"); } @@ -457,7 +457,7 @@ void CAudioIO::ignoreSession() throw (CAudioError) { bool isSkip = mpAudioSessionHandler->isSkipSessionEvent(); if (isSkip == false && mpAudioSessionHandler->getId() >= 0) { mpAudioSessionHandler->unregisterSound(); - mForceIgnore = true; + __mForceIgnore = true; } internalUnlock(); diff --git a/src/cpp/CAudioInfo.cpp b/src/cpp/CAudioInfo.cpp index 302d348..2857836 100644 --- a/src/cpp/CAudioInfo.cpp +++ b/src/cpp/CAudioInfo.cpp @@ -27,19 +27,19 @@ using namespace tizen_media_audio; * class CAudioInfo */ CAudioInfo::CAudioInfo() : - mSampleRate(MAX_SYSTEM_SAMPLERATE), - mChannel(CHANNEL_MONO), - mSampleType(SAMPLE_TYPE_U8), - mAudioType(AUDIO_IN_TYPE_MEDIA), - mAudioIndex(-1) { + __mSampleRate(MAX_SYSTEM_SAMPLERATE), + __mChannel(CHANNEL_MONO), + __mSampleType(SAMPLE_TYPE_U8), + __mAudioType(AUDIO_IN_TYPE_MEDIA), + __mAudioIndex(-1) { } CAudioInfo::CAudioInfo(unsigned int sampleRate, EChannel channel, ESampleType sampleType, EAudioType audioType, int audioIndex) throw (CAudioError) : - mSampleRate(sampleRate), - mChannel(channel), - mSampleType(sampleType), - mAudioType(audioType), - mAudioIndex(audioIndex) { + __mSampleRate(sampleRate), + __mChannel(channel), + __mSampleType(sampleType), + __mAudioType(audioType), + __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); @@ -59,32 +59,32 @@ CAudioInfo::CAudioInfo(unsigned int sampleRate, EChannel channel, ESampleType sa } unsigned int CAudioInfo::getSampleRate() { - return mSampleRate; + return __mSampleRate; } CAudioInfo::EChannel CAudioInfo::getChannel() { - return mChannel; + return __mChannel; } CAudioInfo::ESampleType CAudioInfo::getSampleType() { - return mSampleType; + return __mSampleType; } CAudioInfo::EAudioType CAudioInfo::getAudioType() { - return mAudioType; + return __mAudioType; } void CAudioInfo::setAudioType(CAudioInfo::EAudioType AudioType) { - mAudioType = AudioType; + __mAudioType = AudioType; return; } int CAudioInfo::getAudioIndex() { - return mAudioIndex; + return __mAudioIndex; } void CAudioInfo::setAudioIndex(int AudioIndex) { - mAudioIndex = AudioIndex; + __mAudioIndex = AudioIndex; return; } @@ -93,7 +93,7 @@ void CAudioInfo::convertAudioType2StreamType (CAudioInfo::EAudioType audioType, 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); } - *streamType = (char *)StreamTypeTable[audioType]; + *streamType = (char *)__STREAM_TYPE_TABLE[audioType]; return; } @@ -101,7 +101,7 @@ void CAudioInfo::convertInputStreamType2AudioType (char *streamType, CAudioInfo: { unsigned int i; for (i = CAudioInfo::AUDIO_IN_TYPE_MEDIA ; i < CAudioInfo::AUDIO_OUT_TYPE_MEDIA ; i++) { - if (!strcmp((char *)StreamTypeTable[i], streamType)) { + if (!strcmp((char *)__STREAM_TYPE_TABLE[i], streamType)) { break; } } @@ -116,7 +116,7 @@ void CAudioInfo::convertOutputStreamType2AudioType (char *streamType, CAudioInfo { unsigned int i; for (i = CAudioInfo::AUDIO_OUT_TYPE_MEDIA ; i < CAudioInfo::AUDIO_TYPE_MAX ; i++) { - if (!strcmp((char *)StreamTypeTable[i], streamType)) { + if (!strcmp((char *)__STREAM_TYPE_TABLE[i], streamType)) { break; } } diff --git a/src/cpp/CAudioInput.cpp b/src/cpp/CAudioInput.cpp index 7e1ce87..8d2dc42 100644 --- a/src/cpp/CAudioInput.cpp +++ b/src/cpp/CAudioInput.cpp @@ -27,10 +27,10 @@ using namespace tizen_media_audio; */ CAudioInput::CAudioInput(CAudioInfo& info) : CAudioIO(info), - mpSyncReadDataPtr(NULL), - mSyncReadIndex(0), - mSyncReadLength(0), - mIsUsedSyncRead(true) { + __mpSyncReadDataPtr(NULL), + __mSyncReadIndex(0), + __mSyncReadLength(0), + __mIsUsedSyncRead(true) { } CAudioInput::CAudioInput( @@ -38,10 +38,10 @@ CAudioInput::CAudioInput( CAudioInfo::EChannel channel, CAudioInfo::ESampleType type, CAudioInfo::EAudioType audioType) : - mpSyncReadDataPtr(NULL), - mSyncReadIndex(0), - mSyncReadLength(0), - mIsUsedSyncRead(true) { + __mpSyncReadDataPtr(NULL), + __mSyncReadIndex(0), + __mSyncReadLength(0), + __mIsUsedSyncRead(true) { mAudioInfo = CAudioInfo(sampleRate, channel, type, audioType, -1); } @@ -55,7 +55,7 @@ void CAudioInput::onStream(CPulseAudioClient* pClient, size_t length) { * Does not call CAudioIO::onStream() for synchronization * if a user is using read() */ - if (mIsUsedSyncRead == true) { + if (__mIsUsedSyncRead == true) { #ifdef _AUDIO_IO_DEBUG_TIMING_ AUDIO_IO_LOGD("Sync Read Mode! - signal! - pClient:[%p], length:[%d]", pClient, length); #endif @@ -84,20 +84,20 @@ void CAudioInput::onSignal(CAudioSessionHandler* pHandler, mm_sound_signal_name_ CAudioIO::onSignal(pHandler, signal, value); } -void CAudioInput::setInit(bool flag) { - mIsInit = flag; +void CAudioInput::__setInit(bool flag) { + __mIsInit = flag; } -bool CAudioInput::IsInit() { - return (CAudioIO::isInit() == true && mIsInit == true); +bool CAudioInput::__IsInit() { + return (CAudioIO::isInit() == true && __mIsInit == true); } -bool CAudioInput::IsReady() { +bool CAudioInput::__IsReady() { return CAudioIO::IsReady(); } void CAudioInput::initialize() throw (CAudioError) { - if (IsInit() == true) { + if (__IsInit() == true) { return; } @@ -113,7 +113,7 @@ void CAudioInput::initialize() throw (CAudioError) { // Initialize ASM Handler mpAudioSessionHandler->initialize(); - setInit(true); + __setInit(true); CAudioIO::onStateChanged(CAudioInfo::AUDIO_IO_STATE_IDLE); } catch (CAudioError err) { finalize(); @@ -122,7 +122,7 @@ void CAudioInput::initialize() throw (CAudioError) { } void CAudioInput::finalize() { - if (IsInit() == false) { + if (__IsInit() == false) { AUDIO_IO_LOGD("Did not initialize"); return; } @@ -132,15 +132,15 @@ void CAudioInput::finalize() { CAudioIO::finalize(); - setInit(false); + __setInit(false); } void CAudioInput::prepare() throw (CAudioError) { - if (IsInit() == false) { + if (__IsInit() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput"); } - if (IsReady() == true) { + if (__IsReady() == true) { AUDIO_IO_LOGD("Already prepared CAudioInput"); return; } @@ -193,11 +193,11 @@ void CAudioInput::prepare() throw (CAudioError) { } void CAudioInput::unprepare() throw (CAudioError) { - if (IsInit() == false) { + if (__IsInit() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput"); } - if (IsReady() == false) { + if (__IsReady() == false) { AUDIO_IO_LOGD("Already unprepared"); return; } @@ -233,7 +233,7 @@ void CAudioInput::unprepare() throw (CAudioError) { } void CAudioInput::pause() throw (CAudioError) { - if (IsInit() == false || IsReady() == false) { + if (__IsInit() == false || __IsReady() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput"); } @@ -257,7 +257,7 @@ void CAudioInput::pause() throw (CAudioError) { } void CAudioInput::resume() throw (CAudioError) { - if (IsInit() == false || IsReady() == false) { + if (__IsInit() == false || __IsReady() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput"); } @@ -286,7 +286,7 @@ void CAudioInput::drain() throw (CAudioError) { } void CAudioInput::flush() throw (CAudioError) { - if (IsInit() == false || IsReady() == false) { + if (__IsInit() == false || __IsReady() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput"); } @@ -298,11 +298,11 @@ void CAudioInput::flush() throw (CAudioError) { } int CAudioInput::getBufferSize() throw (CAudioError) { - if (IsInit() == false) { + if (__IsInit() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput"); } - if (IsReady() == false) { + if (__IsReady() == false) { AUDIO_IO_LOGD("Warning: Did not prepare CAudioInput, then return zero"); return 0; } @@ -319,23 +319,23 @@ int CAudioInput::getBufferSize() throw (CAudioError) { } void CAudioInput::setStreamCallback(SStreamCallback callback) throw (CAudioError) { - if (IsInit() == false) { + if (__IsInit() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput"); } if (callback.onStream == NULL) { - AUDIO_IO_LOGD("mIsUsedSyncRead = true"); - mIsUsedSyncRead = true; + AUDIO_IO_LOGD("__mIsUsedSyncRead = true"); + __mIsUsedSyncRead = true; } else { - AUDIO_IO_LOGD("mIsUsedSyncRead = false"); - mIsUsedSyncRead = false; + AUDIO_IO_LOGD("__mIsUsedSyncRead = false"); + __mIsUsedSyncRead = false; } CAudioIO::setStreamCallback(callback); } size_t CAudioInput::read(void* buffer, size_t length) throw (CAudioError) { - if (IsInit() == false || IsReady() == false) { + if (__IsInit() == false || __IsReady() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput"); } @@ -344,7 +344,7 @@ size_t CAudioInput::read(void* buffer, size_t length) throw (CAudioError) { } /* Checks synchronous flag */ - if (mIsUsedSyncRead == false) { + if (__mIsUsedSyncRead == false) { THROW_ERROR_MSG(CAudioError::ERROR_INVALID_OPERATION, "Invalid operation of read() if receive stream callback"); } @@ -357,18 +357,18 @@ size_t CAudioInput::read(void* buffer, size_t length) throw (CAudioError) { while (lengthIter > 0) { size_t l; - while (mpSyncReadDataPtr == NULL) { - ret = mpPulseAudioClient->peek(&mpSyncReadDataPtr, &mSyncReadLength); + 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); } - if (mSyncReadLength <= 0) { + if (__mSyncReadLength <= 0) { #ifdef _AUDIO_IO_DEBUG_TIMING_ - AUDIO_IO_LOGD("readLength(%d byte) is not valid.. wait..", mSyncReadLength); + AUDIO_IO_LOGD("readLength(%d byte) is not valid.. wait..", __mSyncReadLength); #endif internalWait(); - } else if (mpSyncReadDataPtr == NULL) { + } else if (__mpSyncReadDataPtr == NULL) { /* There's a hole in the stream, skip it. We could generate * silence, but that wouldn't work for compressed streams. */ @@ -377,33 +377,33 @@ size_t CAudioInput::read(void* buffer, size_t length) throw (CAudioError) { THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INTERNAL_OPERATION, "Failed CPulseAudioClient::drop() ret:[%d]", ret); } } else { - mSyncReadIndex = 0; + __mSyncReadIndex = 0; } }//end of while (pReadData == NULL) - if (mSyncReadLength < lengthIter) { - l = mSyncReadLength; + if (__mSyncReadLength < lengthIter) { + l = __mSyncReadLength; } else { l = lengthIter; } // Copy partial pcm data on out parameter #ifdef _AUDIO_IO_DEBUG_TIMING_ - AUDIO_IO_LOGD("memcpy() that a peeked buffer(%p), index(%d), length(%d), on out buffer", (const uint8_t*)(mpSyncReadDataPtr) + mSyncReadIndex, mSyncReadIndex, l); + AUDIO_IO_LOGD("memcpy() that a peeked buffer(%p), index(%d), length(%d), on out buffer", (const uint8_t*)(__mpSyncReadDataPtr) + __mSyncReadIndex, __mSyncReadIndex, l); #endif - memcpy(buffer, (const uint8_t*)mpSyncReadDataPtr + mSyncReadIndex, l); + memcpy(buffer, (const uint8_t*)__mpSyncReadDataPtr + __mSyncReadIndex, l); // Move next position buffer = (uint8_t*)buffer + l; lengthIter -= l; // Adjusts the rest length - mSyncReadIndex += l; - mSyncReadLength -= l; + __mSyncReadIndex += l; + __mSyncReadLength -= l; - if (mSyncReadLength == 0) { + if (__mSyncReadLength == 0) { #ifdef _AUDIO_IO_DEBUG_TIMING_ - AUDIO_IO_LOGD("mSyncReadLength is zero - Do drop()"); + AUDIO_IO_LOGD("__mSyncReadLength is zero - Do drop()"); #endif ret = mpPulseAudioClient->drop(); if (ret != 0) { @@ -411,9 +411,9 @@ size_t CAudioInput::read(void* buffer, size_t length) throw (CAudioError) { } // Reset the internal pointer - mpSyncReadDataPtr = NULL; - mSyncReadLength = 0; - mSyncReadIndex = 0; + __mpSyncReadDataPtr = NULL; + __mSyncReadLength = 0; + __mSyncReadIndex = 0; } } // End of while (length > 0) @@ -427,7 +427,7 @@ 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) { + if (__IsInit() == false || __IsReady() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput"); } @@ -436,7 +436,7 @@ int CAudioInput::peek(const void** buffer, size_t* length) throw (CAudioError) { } /* Checks synchronous flag */ - if (mIsUsedSyncRead == true) { + if (__mIsUsedSyncRead == true) { THROW_ERROR_MSG(CAudioError::ERROR_INVALID_OPERATION, "Invalid operation of peek() if does not receive a stream callback"); } @@ -452,12 +452,12 @@ int CAudioInput::peek(const void** buffer, size_t* length) throw (CAudioError) { } int CAudioInput::drop() throw (CAudioError) { - if (IsInit() == false || IsReady() == false) { + if (__IsInit() == false || __IsReady() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput"); } /* Checks synchronous flag */ - if (mIsUsedSyncRead == true) { + if (__mIsUsedSyncRead == true) { THROW_ERROR_MSG(CAudioError::ERROR_INVALID_OPERATION, "Invalid operation of drop() if does not receive a stream callback"); } diff --git a/src/cpp/CAudioOutput.cpp b/src/cpp/CAudioOutput.cpp index 2383b3d..1a34c6a 100644 --- a/src/cpp/CAudioOutput.cpp +++ b/src/cpp/CAudioOutput.cpp @@ -27,7 +27,7 @@ using namespace tizen_media_audio; */ CAudioOutput::CAudioOutput(CAudioInfo& info) : CAudioIO(info), - mIsUsedSyncWrite(false) { + __mIsUsedSyncWrite(false) { } CAudioOutput::CAudioOutput( @@ -35,7 +35,7 @@ CAudioOutput::CAudioOutput( CAudioInfo::EChannel channel, CAudioInfo::ESampleType sampleType, CAudioInfo::EAudioType audioType) : - mIsUsedSyncWrite(false) { + __mIsUsedSyncWrite(false) { mAudioInfo = CAudioInfo(sampleRate, channel, sampleType, audioType, -1); } @@ -50,7 +50,7 @@ void CAudioOutput::onStream(CPulseAudioClient* pClient, size_t length) { * Does not call CAudioIO::onStream() for synchronization * if a user is using write() */ - if (mIsUsedSyncWrite == true) { + if (__mIsUsedSyncWrite == true) { #ifdef _AUDIO_IO_DEBUG_TIMING_ AUDIO_IO_LOGD("Sync Write Mode! - signal! - pClient:[%p], length:[%d]", pClient, length); #endif @@ -79,20 +79,20 @@ void CAudioOutput::onSignal(CAudioSessionHandler* pHandler, mm_sound_signal_name CAudioIO::onSignal(pHandler, signal, value); } -void CAudioOutput::setInit(bool flag) { - mIsInit = flag; +void CAudioOutput::__setInit(bool flag) { + __mIsInit = flag; } -bool CAudioOutput::IsInit() { - return (CAudioIO::isInit() == true && mIsInit == true); +bool CAudioOutput::__IsInit() { + return (CAudioIO::isInit() == true && __mIsInit == true); } -bool CAudioOutput::IsReady() { +bool CAudioOutput::__IsReady() { return CAudioIO::IsReady(); } void CAudioOutput::initialize() throw (CAudioError) { - if (IsInit() == true) { + if (__IsInit() == true) { return; } @@ -108,7 +108,7 @@ void CAudioOutput::initialize() throw (CAudioError) { // Initialize ASM Handler mpAudioSessionHandler->initialize(); - setInit(true); + __setInit(true); CAudioIO::onStateChanged(CAudioInfo::AUDIO_IO_STATE_IDLE); } catch (CAudioError err) { finalize(); @@ -117,7 +117,7 @@ void CAudioOutput::initialize() throw (CAudioError) { } void CAudioOutput::finalize() { - if (IsInit() == false) { + if (__IsInit() == false) { AUDIO_IO_LOGD("Did not initialize"); return; } @@ -127,11 +127,11 @@ void CAudioOutput::finalize() { CAudioIO::finalize(); - setInit(false); + __setInit(false); } void CAudioOutput::prepare() throw (CAudioError) { - if (IsInit() == false) { + if (__IsInit() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioOutput"); } @@ -186,7 +186,7 @@ void CAudioOutput::prepare() throw (CAudioError) { } void CAudioOutput::unprepare() throw (CAudioError) { - if (IsInit() == false) { + if (__IsInit() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioOutput"); } @@ -225,7 +225,7 @@ void CAudioOutput::unprepare() throw (CAudioError) { } void CAudioOutput::pause() throw (CAudioError) { - if (IsInit() == false || IsReady() == false) { + if (__IsInit() == false || IsReady() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput"); } @@ -249,7 +249,7 @@ void CAudioOutput::pause() throw (CAudioError) { } void CAudioOutput::resume() throw (CAudioError) { - if (IsInit() == false || IsReady() == false) { + if (__IsInit() == false || IsReady() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput"); } @@ -274,7 +274,7 @@ void CAudioOutput::resume() throw (CAudioError) { } void CAudioOutput::drain() throw (CAudioError) { - if (IsInit() == false || IsReady() == false) { + if (__IsInit() == false || IsReady() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput"); } @@ -286,7 +286,7 @@ void CAudioOutput::drain() throw (CAudioError) { } void CAudioOutput::flush() throw (CAudioError) { - if (IsInit() == false || IsReady() == false) { + if (__IsInit() == false || IsReady() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput"); } @@ -298,7 +298,7 @@ void CAudioOutput::flush() throw (CAudioError) { } int CAudioOutput::getBufferSize() throw (CAudioError) { - if (IsInit() == false) { + if (__IsInit() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioOutput"); } @@ -319,7 +319,7 @@ int CAudioOutput::getBufferSize() throw (CAudioError) { } size_t CAudioOutput::write(const void* buffer, size_t length) throw (CAudioError) { - if (IsInit() == false || IsReady() == false) { + if (__IsInit() == false || IsReady() == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput"); } @@ -340,7 +340,7 @@ size_t CAudioOutput::write(const void* buffer, size_t length) throw (CAudioError internalLock(); // Sets synchronous flag - mIsUsedSyncWrite = true; + __mIsUsedSyncWrite = true; size_t lengthIter = length; @@ -372,11 +372,11 @@ size_t CAudioOutput::write(const void* buffer, size_t length) throw (CAudioError } // End of while (length > 0) // Unsets synchronous flag - mIsUsedSyncWrite = false; + __mIsUsedSyncWrite = false; internalUnlock(); } catch (CAudioError e) { // Unsets synchronous flag - mIsUsedSyncWrite = false; + __mIsUsedSyncWrite = false; internalUnlock(); throw e; } diff --git a/src/cpp/CAudioSessionHandler.cpp b/src/cpp/CAudioSessionHandler.cpp index 9a6bfe6..aa00520 100644 --- a/src/cpp/CAudioSessionHandler.cpp +++ b/src/cpp/CAudioSessionHandler.cpp @@ -26,91 +26,91 @@ using namespace tizen_media_audio; /** * class CAudioSessionHandler */ -int CAudioSessionHandler::sCaptureRef = 0; +int CAudioSessionHandler::__sCaptureRef = 0; -int CAudioSessionHandler::PCM_CAPTURE_COUNT_INC() { +int CAudioSessionHandler::__pcmCaptureCountInc() { int actual; do { - actual = sCaptureRef; - } while (!__sync_bool_compare_and_swap(&sCaptureRef, actual, actual + 1)); - AUDIO_IO_LOGD("CaptureRefCount+1 > [%d]", sCaptureRef); - return sCaptureRef; + actual = __sCaptureRef; + } while (!__sync_bool_compare_and_swap(&__sCaptureRef, actual, actual + 1)); + AUDIO_IO_LOGD("CaptureRefCount+1 > [%d]", __sCaptureRef); + return __sCaptureRef; } -int CAudioSessionHandler::PCM_CAPTURE_COUNT_DEC() { +int CAudioSessionHandler::__pcmCaptureCountDec() { int actual; do { - actual = sCaptureRef; - } while (!__sync_bool_compare_and_swap(&sCaptureRef, actual, actual - 1)); - AUDIO_IO_LOGD("CaptureRefCount-1 > [%d]", sCaptureRef); - if (sCaptureRef < 0) { - AUDIO_IO_LOGE("A CaptureRef[%d] is not valid! Something is wrong!", sCaptureRef); - sCaptureRef = 0; + actual = __sCaptureRef; + } while (!__sync_bool_compare_and_swap(&__sCaptureRef, actual, actual - 1)); + AUDIO_IO_LOGD("CaptureRefCount-1 > [%d]", __sCaptureRef); + if (__sCaptureRef < 0) { + AUDIO_IO_LOGE("A CaptureRef[%d] is not valid! Something is wrong!", __sCaptureRef); + __sCaptureRef = 0; } - return sCaptureRef; + return __sCaptureRef; } -int CAudioSessionHandler::PCM_CAPTURE_COUNT_GET() { - AUDIO_IO_LOGD("CaptureRefCount > [%d]", sCaptureRef); - return sCaptureRef; +int CAudioSessionHandler::__pcmCaptureCountGet() { + AUDIO_IO_LOGD("CaptureRefCount > [%d]", __sCaptureRef); + return __sCaptureRef; } -int CAudioSessionHandler::sFocusRef = 0; +int CAudioSessionHandler::__sFocusRef = 0; -int CAudioSessionHandler::FOCUS_ID_COUNT_INC() { +int CAudioSessionHandler::__focusIdCountInc() { int actual; do { - actual = sFocusRef; - } while (!__sync_bool_compare_and_swap(&sFocusRef, actual, actual + 1)); - AUDIO_IO_LOGD("FocusRefCount+1 > [%d]", sFocusRef); - return sFocusRef; + actual = __sFocusRef; + } while (!__sync_bool_compare_and_swap(&__sFocusRef, actual, actual + 1)); + AUDIO_IO_LOGD("FocusRefCount+1 > [%d]", __sFocusRef); + return __sFocusRef; } -int CAudioSessionHandler::FOCUS_ID_COUNT_DEC() { +int CAudioSessionHandler::__focusIdCountDec() { int actual; do { - actual = sFocusRef; - } while (!__sync_bool_compare_and_swap(&sFocusRef, actual, actual - 1)); - AUDIO_IO_LOGD("FocusRefCount-1 > [%d]", sFocusRef); - return sFocusRef; + actual = __sFocusRef; + } while (!__sync_bool_compare_and_swap(&__sFocusRef, actual, actual - 1)); + AUDIO_IO_LOGD("FocusRefCount-1 > [%d]", __sFocusRef); + return __sFocusRef; } -int CAudioSessionHandler::FOCUS_ID_COUNT_GET() { - /* AUDIO_IO_LOGD("FocusRefCount > [%d]", sFocusRef); */ - return sFocusRef; +int CAudioSessionHandler::__focusIdCountGet() { + /* AUDIO_IO_LOGD("FocusRefCount > [%d]", __sFocusRef); */ + return __sFocusRef; } CAudioSessionHandler::CAudioSessionHandler(EAudioSessionType sessionType, CAudioInfo& audioInfo, IAudioSessionEventListener* listener) : - mId(-1), - mOptions(0), - mAudioSession(sessionType), - mMultimediaSession(MM_SESSION_TYPE_MEDIA), - mpEventListener(listener), - mIsInit(false), - mUseFocus(false), - mSubscribeId(-1) { - mAudioInfo = audioInfo; + __mId(-1), + __mOptions(0), + __mAudioSession(sessionType), + __mMultimediaSession(MM_SESSION_TYPE_MEDIA), + __mpEventListener(listener), + __mIsInit(false), + __mUseFocus(false), + __mSubscribeId(-1) { + __mAudioInfo = audioInfo; } CAudioSessionHandler::~CAudioSessionHandler() { } -CAudioError CAudioSessionHandler::_convertStreamType(EAudioSessionType type1, MMSessionType type2, int *index) { +CAudioError CAudioSessionHandler::__convertStreamType(EAudioSessionType type1, MMSessionType type2, int *index) { unsigned int i; int idx = -1; assert(index != NULL); if (type1 == 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) { + 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; break; } } } else { - for (i = 0 ; i < sizeof(stream_type_table_out) / sizeof(stream_type_table_out[0]) ; i++) { - if (stream_type_table_out[i].type == type2) { + for (i = 0 ; i < sizeof(__STREAM_TYPE_TABLE_OUT) / sizeof(__STREAM_TYPE_TABLE_OUT[0]) ; i++) { + if (__STREAM_TYPE_TABLE_OUT[i].type == type2) { idx = i; break; } @@ -124,7 +124,7 @@ CAudioError CAudioSessionHandler::_convertStreamType(EAudioSessionType type1, MM RET_ERROR(CAudioError::ERROR_NONE); } -CAudioError CAudioSessionHandler::_getAsmInformation(MMSessionType *type, int *options) { +CAudioError CAudioSessionHandler::__getAsmInformation(MMSessionType *type, int *options) { assert(type != NULL); assert(options != NULL); @@ -147,7 +147,7 @@ CAudioError CAudioSessionHandler::_getAsmInformation(MMSessionType *type, int *o RET_ERROR(CAudioError::ERROR_NONE); } -bool CAudioSessionHandler::_isFocusRequired(MMSessionType type, int options) { +bool CAudioSessionHandler::__isFocusRequired(MMSessionType type, int options) { if ((options & ASM_SESSION_OPTION_PAUSE_OTHERS) || ((type != MM_SESSION_TYPE_MEDIA) && (type != MM_SESSION_TYPE_MEDIA_RECORD))) return true; @@ -156,53 +156,53 @@ bool CAudioSessionHandler::_isFocusRequired(MMSessionType type, int options) { } int CAudioSessionHandler::getId() { - return mId; + return __mId; } int CAudioSessionHandler::getOptions() { - return mOptions; + return __mOptions; } CAudioSessionHandler::EAudioSessionType CAudioSessionHandler::getAudioSession() { - return mAudioSession; + return __mAudioSession; } MMSessionType CAudioSessionHandler::getMultimediaSession() { - return mMultimediaSession; + return __mMultimediaSession; } int CAudioSessionHandler::getSubscribeId() { - return mSubscribeId; + return __mSubscribeId; } CAudioInfo CAudioSessionHandler::getAudioInfo() { - return mAudioInfo; + return __mAudioInfo; } -void CAudioSessionHandler::_sound_pcm_signal_cb(mm_sound_signal_name_t signal, int value, void *user_data) { +void CAudioSessionHandler::__sound_pcm_signal_cb(mm_sound_signal_name_t signal, int value, void *user_data) { assert(user_data); AUDIO_IO_LOGD("[signal:%d], [value:%d], [user_data:0x%x]", signal, value, user_data); CAudioSessionHandler* pHandler = static_cast(user_data); - if (pHandler->mpEventListener != NULL) { - pHandler->mpEventListener->onSignal(pHandler, signal, value); + if (pHandler->__mpEventListener != NULL) { + pHandler->__mpEventListener->onSignal(pHandler, signal, value); } } void CAudioSessionHandler::initialize() throw (CAudioError) { AUDIO_IO_LOGD(""); - if (mIsInit == true) { + if (__mIsInit == true) { return; } MMSessionType currentSession = MM_SESSION_TYPE_MEDIA; int sessionOptions = 0; // Mix with others by default - CAudioError err = _getAsmInformation(¤tSession, &sessionOptions); + CAudioError err = __getAsmInformation(¤tSession, &sessionOptions); if (err == CAudioError::ERROR_NONE) { // Session was configured before, use focus callback - mUseFocus = true; + __mUseFocus = true; AUDIO_IO_LOGD("Use audio focus concept internally!"); } else { if (err == CAudioError::ERROR_INVALID_HANDLE) { @@ -216,29 +216,29 @@ void CAudioSessionHandler::initialize() throw (CAudioError) { if (value == 1) { // stream_info was created or focus watch callback was configured before - mUseFocus = false; + __mUseFocus = false; AUDIO_IO_LOGD("Skip audio focus concept!"); } else if (value == 0) { // No session, No stream_info, No focus watch callback before // 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)); + 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); } - mSubscribeId = (int)subscribe_id; + __mSubscribeId = (int)subscribe_id; AUDIO_IO_LOGD("Subscribed mm_sound signal"); sessionOptions = 0; // Mix with others by default - mUseFocus = true; + __mUseFocus = true; AUDIO_IO_LOGD("Use audio focus(watch) concept internally!"); } } else { - mUseFocus = false; + __mUseFocus = false; AUDIO_IO_LOGD("Skip audio focus concept!"); } - if (mAudioSession == AUDIO_SESSION_TYPE_CAPTURE) { + if (__mAudioSession == AUDIO_SESSION_TYPE_CAPTURE) { AUDIO_IO_LOGD("Set default \"Media_Record\" type"); currentSession = MM_SESSION_TYPE_MEDIA_RECORD; } else { @@ -248,31 +248,31 @@ void CAudioSessionHandler::initialize() throw (CAudioError) { } // Updates session information - mMultimediaSession = currentSession; - mOptions = sessionOptions; + __mMultimediaSession = currentSession; + __mOptions = sessionOptions; - if (this->mAudioSession == AUDIO_SESSION_TYPE_CAPTURE) { - PCM_CAPTURE_COUNT_INC(); + if (this->__mAudioSession == AUDIO_SESSION_TYPE_CAPTURE) { + __pcmCaptureCountInc(); } - mIsInit = true; + __mIsInit = true; } void CAudioSessionHandler::finalize() { AUDIO_IO_LOGD(""); - if (mIsInit == false) { + if (__mIsInit == false) { return; } - if (mAudioSession == AUDIO_SESSION_TYPE_CAPTURE) { - PCM_CAPTURE_COUNT_DEC(); + if (__mAudioSession == AUDIO_SESSION_TYPE_CAPTURE) { + __pcmCaptureCountDec(); } - if (mSubscribeId >= 0) { - mm_sound_unsubscribe_signal(mSubscribeId); + if (__mSubscribeId >= 0) { + mm_sound_unsubscribe_signal(__mSubscribeId); } - mIsInit = false; + __mIsInit = false; } bool CAudioSessionHandler::isSkipSessionEvent() throw (CAudioError) { @@ -286,7 +286,7 @@ bool CAudioSessionHandler::isSkipSessionEvent() throw (CAudioError) { mEvent != ASM_EVENT_MMCAMCORDER_AUDIO && mEvent != ASM_EVENT_MMCAMCORDER_VIDEO) { // Check AudioType - switch (mAudioInfo.getAudioType()) { + switch (__mAudioInfo.getAudioType()) { case CAudioInfo::AUDIO_IN_TYPE_MEDIA: case CAudioInfo::AUDIO_IN_TYPE_VOICECONTROL: ret = false; @@ -302,10 +302,10 @@ bool CAudioSessionHandler::isSkipSessionEvent() throw (CAudioError) { } if (ret == true) { - int captureCount = CAudioSessionHandler::PCM_CAPTURE_COUNT_GET(); + int captureCount = CAudioSessionHandler::__pcmCaptureCountGet(); if (captureCount == 1) {/* If this is last one */ /* Recover session information to MEDIA */ - int sessionResult = _mm_session_util_write_information(-1, MM_SESSION_TYPE_MEDIA, mOptions); + int sessionResult = _mm_session_util_write_information(-1, MM_SESSION_TYPE_MEDIA, __mOptions); if (sessionResult != 0) { THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INTERNAL_OPERATION, "Failed _mm_session_util_write_information() ret:%d", sessionResult); } @@ -317,148 +317,148 @@ bool CAudioSessionHandler::isSkipSessionEvent() throw (CAudioError) { return ret; } -void CAudioSessionHandler::_sound_pcm_focus_cb(int id, mm_sound_focus_type_e focus_type, mm_sound_focus_state_e state, const char *reason_for_change, const char *additional_info, void *user_data) { +void CAudioSessionHandler::__sound_pcm_focus_cb(int id, mm_sound_focus_type_e focus_type, mm_sound_focus_state_e state, const char *reason_for_change, const char *additional_info, void *user_data) { assert(user_data); AUDIO_IO_LOGD("[id:%d], [focus_type:%d], [state:%d], [reason_for_change:%s], [additional_info:%s], [user_data:0x%x]", id, focus_type, state, reason_for_change, additional_info, user_data); CAudioSessionHandler* pHandler = static_cast(user_data); - pHandler->mFocusType = focus_type; - pHandler->mState = state; - pHandler->mReasonForChange = (char *)reason_for_change; - pHandler->mAdditionalInfo = (char *)additional_info; + pHandler->__mFocusType = focus_type; + pHandler->__mState = state; + pHandler->__mReasonForChange = (char *)reason_for_change; + pHandler->__mAdditionalInfo = (char *)additional_info; - if (pHandler->mpEventListener != NULL) { - pHandler->mpEventListener->onInterrupt(pHandler, id, focus_type, state, reason_for_change, additional_info); + if (pHandler->__mpEventListener != NULL) { + pHandler->__mpEventListener->onInterrupt(pHandler, id, focus_type, state, reason_for_change, additional_info); } return; } -void CAudioSessionHandler::_sound_pcm_focus_watch_cb(int id, mm_sound_focus_type_e focus_type, mm_sound_focus_state_e state, const char *reason_for_change, const char *additional_info, void *user_data) { +void CAudioSessionHandler::__sound_pcm_focus_watch_cb(int id, mm_sound_focus_type_e focus_type, mm_sound_focus_state_e state, const char *reason_for_change, const char *additional_info, void *user_data) { AUDIO_IO_LOGD("[id:%d], [focus_type:%d], [state:%d], [reason_for_change:%s], [additional_info:%s], [user_data:0x%x]", id, focus_type, state, reason_for_change, additional_info, user_data); - CAudioSessionHandler::_sound_pcm_focus_cb(-1, focus_type, state, reason_for_change, additional_info, user_data); + CAudioSessionHandler::__sound_pcm_focus_cb(-1, focus_type, state, reason_for_change, additional_info, user_data); return; } void CAudioSessionHandler::registerSound() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::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); + if (__mUseFocus == true) { + if (__mId >= 0) { + THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_POLICY_BLOCKED, "Already registered [id:%d]", __mId); } int errorCode = 0; - if (_isFocusRequired(mMultimediaSession, mOptions)) { + if (__isFocusRequired(__mMultimediaSession, __mOptions)) { int index = 0; - CAudioError err = _convertStreamType(mAudioSession, mMultimediaSession, &index); + CAudioError err = __convertStreamType(__mAudioSession, __mMultimediaSession, &index); if (err != CAudioError::ERROR_NONE) { throw err; } - errorCode = mm_sound_focus_get_id(&mId); + 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); } // 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, - _sound_pcm_focus_cb, + errorCode = mm_sound_register_focus(__mId, + __mAudioSession == 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); } - FOCUS_ID_COUNT_INC(); + __focusIdCountInc(); - AUDIO_IO_LOGD("Focus callback registered successfully [id:%d]", mId); - } else if (!(mOptions & ASM_SESSION_OPTION_UNINTERRUPTIBLE)) { + AUDIO_IO_LOGD("Focus callback registered successfully [id:%d]", __mId); + } else if (!(__mOptions & ASM_SESSION_OPTION_UNINTERRUPTIBLE)) { // Register focus watch callback - errorCode = mm_sound_set_focus_watch_callback(FOCUS_FOR_BOTH, _sound_pcm_focus_watch_cb, static_cast(this), &mId); + 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); } - FOCUS_ID_COUNT_INC(); + __focusIdCountInc(); - AUDIO_IO_LOGD("Focus watch callback registered successfully [id:%d]", mId); + AUDIO_IO_LOGD("Focus watch callback registered successfully [id:%d]", __mId); } } } void CAudioSessionHandler::unregisterSound() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::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); + if (__mUseFocus == true) { + if (__mId < 0) { + THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_POLICY_BLOCKED, "Did not register [id:%d]", __mId); } int errorCode = 0; - if (_isFocusRequired(mMultimediaSession, mOptions)) { + if (__isFocusRequired(__mMultimediaSession, __mOptions)) { // Unregister focus callback - errorCode = mm_sound_unregister_focus(mId); + 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); } - FOCUS_ID_COUNT_DEC(); + __focusIdCountDec(); - AUDIO_IO_LOGD("Focus callback unregistered successfully [id:%d]", mId); - mId = -1; - } else if (!(mOptions & ASM_SESSION_OPTION_UNINTERRUPTIBLE)) { + AUDIO_IO_LOGD("Focus callback unregistered successfully [id:%d]", __mId); + __mId = -1; + } else if (!(__mOptions & ASM_SESSION_OPTION_UNINTERRUPTIBLE)) { // Unregister focus watch callback. - errorCode = mm_sound_unset_focus_watch_callback(mId); + 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); } - FOCUS_ID_COUNT_DEC(); + __focusIdCountDec(); - AUDIO_IO_LOGD("Focus watch callback unregistered successfully [id:%d]", mId); - mId = -1; + AUDIO_IO_LOGD("Focus watch callback unregistered successfully [id:%d]", __mId); + __mId = -1; } } } void CAudioSessionHandler::updatePlaying() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::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 (__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); } - AUDIO_IO_LOGD("Focus acquired successfully [id:%d]", mId); + AUDIO_IO_LOGD("Focus acquired successfully [id:%d]", __mId); } } } void CAudioSessionHandler::updateStop() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::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 (__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); } - AUDIO_IO_LOGD("Focus released successfully [id:%d]", mId); + AUDIO_IO_LOGD("Focus released successfully [id:%d]", __mId); } } } @@ -467,7 +467,7 @@ void CAudioSessionHandler::disableSessionHandler() throw (CAudioError) { CAudioSessionHandler::updateStop(); CAudioSessionHandler::unregisterSound(); - CAudioSessionHandler::mUseFocus = false; + CAudioSessionHandler::__mUseFocus = false; } /** diff --git a/src/cpp/CPulseAudioClient.cpp b/src/cpp/CPulseAudioClient.cpp index ae8e4e8..733fe05 100644 --- a/src/cpp/CPulseAudioClient.cpp +++ b/src/cpp/CPulseAudioClient.cpp @@ -31,22 +31,22 @@ const char* CPulseAudioClient::CLIENT_NAME = "AUDIO_IO_PA_CLIENT"; CPulseAudioClient::CPulseAudioClient(EStreamDirection direction, CPulseStreamSpec& spec, IPulseStreamListener* listener) : - mDirection(direction), - mSpec(spec), - mpListener(listener), - mpMainloop(NULL), - mpContext(NULL), - mpStream(NULL), - mpPropList(NULL), - mIsInit(false), - mIsOperationSuccess(false) { + __mDirection(direction), + __mSpec(spec), + __mpListener(listener), + __mpMainloop(NULL), + __mpContext(NULL), + __mpStream(NULL), + __mpPropList(NULL), + __mIsInit(false), + __mIsOperationSuccess(false) { } CPulseAudioClient::~CPulseAudioClient() { finalize(); } -void CPulseAudioClient::_contextStateChangeCb(pa_context* c, void* user_data) { +void CPulseAudioClient::__contextStateChangeCb(pa_context* c, void* user_data) { CPulseAudioClient* pClient = static_cast(user_data); assert(pClient); assert(c); @@ -56,7 +56,7 @@ void CPulseAudioClient::_contextStateChangeCb(pa_context* c, void* user_data) { AUDIO_IO_LOGD("The context is ready!"); case PA_CONTEXT_FAILED: case PA_CONTEXT_TERMINATED: - pa_threaded_mainloop_signal(pClient->mpMainloop, 0); + pa_threaded_mainloop_signal(pClient->__mpMainloop, 0); break; case PA_CONTEXT_UNCONNECTED: @@ -67,18 +67,18 @@ void CPulseAudioClient::_contextStateChangeCb(pa_context* c, void* user_data) { } } -void CPulseAudioClient::_successContextCb(pa_context* c, int success, void* user_data) { +void CPulseAudioClient::__successContextCb(pa_context* c, int success, void* user_data) { AUDIO_IO_LOGD("pa_context[%p], success[%d], user_data[%p]", c, success, user_data); assert(c); assert(user_data); CPulseAudioClient* pClient = static_cast(user_data); - pClient->mIsOperationSuccess = static_cast(success); + pClient->__mIsOperationSuccess = static_cast(success); - pa_threaded_mainloop_signal(pClient->mpMainloop, 0); + pa_threaded_mainloop_signal(pClient->__mpMainloop, 0); } -void CPulseAudioClient::_streamStateChangeCb(pa_stream* s, void* user_data) { +void CPulseAudioClient::__streamStateChangeCb(pa_stream* s, void* user_data) { assert(s); assert(user_data); @@ -87,10 +87,10 @@ 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::AUDIO_IO_STATE_RUNNING); case PA_STREAM_FAILED: case PA_STREAM_TERMINATED: - pa_threaded_mainloop_signal(pClient->mpMainloop, 0); + pa_threaded_mainloop_signal(pClient->__mpMainloop, 0); break; case PA_STREAM_UNCONNECTED: @@ -100,25 +100,25 @@ void CPulseAudioClient::_streamStateChangeCb(pa_stream* s, void* user_data) { } } -void CPulseAudioClient::_streamCaptureCb(pa_stream* s, size_t length, void* user_data) { +void CPulseAudioClient::__streamCaptureCb(pa_stream* s, size_t length, void* user_data) { assert(s); assert(user_data); CPulseAudioClient* pClient = static_cast(user_data); - assert(pClient->mpListener); + assert(pClient->__mpListener); - pClient->mpListener->onStream(pClient, length); + pClient->__mpListener->onStream(pClient, length); } -void CPulseAudioClient::_streamPlaybackCb(pa_stream* s, size_t length, void* user_data) { - //AUDIO_IO_LOGD("_streamPlaybackCb()"); +void CPulseAudioClient::__streamPlaybackCb(pa_stream* s, size_t length, void* user_data) { + //AUDIO_IO_LOGD("__streamPlaybackCb()"); assert(s); assert(user_data); CPulseAudioClient* pClient = static_cast(user_data); - assert(pClient->mpListener); + assert(pClient->__mpListener); - if (pClient->mIsInit == false) { + if (pClient->__mIsInit == false) { AUDIO_IO_LOGD("Occurred this listener when an out stream is on the way to create - Dummy write[length:%d]", length); char* dummy = new char[length]; @@ -129,32 +129,32 @@ void CPulseAudioClient::_streamPlaybackCb(pa_stream* s, size_t length, void* use return; } - pClient->mpListener->onStream(pClient, length); + pClient->__mpListener->onStream(pClient, length); } -void CPulseAudioClient::_streamLatencyUpdateCb(pa_stream* s, void* user_data) { +void CPulseAudioClient::__streamLatencyUpdateCb(pa_stream* s, void* user_data) { assert(s); assert(user_data); CPulseAudioClient* pClient = static_cast(user_data); - pa_threaded_mainloop_signal(pClient->mpMainloop, 0); + pa_threaded_mainloop_signal(pClient->__mpMainloop, 0); } -void CPulseAudioClient::_successStreamCb(pa_stream* s, int success, void* user_data) { +void CPulseAudioClient::__successStreamCb(pa_stream* s, int success, void* user_data) { AUDIO_IO_LOGD("pa_stream[%p], success[%d], user_data[%p]", s, success, user_data); assert(s); assert(user_data); CPulseAudioClient* pClient = static_cast(user_data); - pClient->mIsOperationSuccess = static_cast(success); + pClient->__mIsOperationSuccess = static_cast(success); - pa_threaded_mainloop_signal(pClient->mpMainloop, 0); + pa_threaded_mainloop_signal(pClient->__mpMainloop, 0); } void CPulseAudioClient::initialize() throw (CAudioError) { AUDIO_IO_LOGD(""); - if (mIsInit == true) { + if (__mIsInit == true) { return; } @@ -163,52 +163,52 @@ void CPulseAudioClient::initialize() throw (CAudioError) { try { // Allocates PA proplist - mpPropList = pa_proplist_new(); - if (mpPropList == NULL) { + __mpPropList = pa_proplist_new(); + if (__mpPropList == NULL) { THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed pa_proplist_new()"); } // Adds values on proplist for delivery to PULSEAUDIO char *streamType = NULL; - CAudioInfo::EAudioType audioType = mSpec.getAudioInfo().getAudioType(); - mSpec.getAudioInfo().convertAudioType2StreamType(audioType, &streamType); - pa_proplist_sets(mpPropList, PA_PROP_MEDIA_ROLE, streamType); + CAudioInfo::EAudioType audioType = __mSpec.getAudioInfo().getAudioType(); + __mSpec.getAudioInfo().convertAudioType2StreamType(audioType, &streamType); + pa_proplist_sets(__mpPropList, PA_PROP_MEDIA_ROLE, streamType); - int index = mSpec.getAudioInfo().getAudioIndex(); + int index = __mSpec.getAudioInfo().getAudioIndex(); if (index >= 0) { - pa_proplist_setf(mpPropList, PA_PROP_MEDIA_PARENT_ID, "%u", (unsigned int) index); + pa_proplist_setf(__mpPropList, PA_PROP_MEDIA_PARENT_ID, "%u", (unsigned int) index); } // Adds latency on proplist for delivery to PULSEAUDIO - AUDIO_IO_LOGD("LATENCY : %s(%d)", mSpec.getStreamLatencyToString(), mSpec.getStreamLatency()); - pa_proplist_setf(mpPropList, PA_PROP_MEDIA_TIZEN_AUDIO_LATENCY, "%s", mSpec.getStreamLatencyToString()); + AUDIO_IO_LOGD("LATENCY : %s(%d)", __mSpec.getStreamLatencyToString(), __mSpec.getStreamLatency()); + pa_proplist_setf(__mpPropList, PA_PROP_MEDIA_TIZEN_AUDIO_LATENCY, "%s", __mSpec.getStreamLatencyToString()); // Allocates PA mainloop - mpMainloop = pa_threaded_mainloop_new(); - if (mpMainloop == NULL) { + __mpMainloop = pa_threaded_mainloop_new(); + if (__mpMainloop == NULL) { THROW_ERROR_MSG(CAudioError::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) { + __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()"); } // Sets context state changed callback - pa_context_set_state_callback(mpContext, _contextStateChangeCb, this); + pa_context_set_state_callback(__mpContext, __contextStateChangeCb, this); // Connects this client with PA server - if (pa_context_connect(mpContext, NULL, PA_CONTEXT_NOFLAGS, NULL) < 0) { + if (pa_context_connect(__mpContext, NULL, PA_CONTEXT_NOFLAGS, NULL) < 0) { THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed pa_context_connect()"); } // LOCK for synchronous connection - pa_threaded_mainloop_lock(mpMainloop); + pa_threaded_mainloop_lock(__mpMainloop); // Start mainloop - if (pa_threaded_mainloop_start(mpMainloop) < 0) { - pa_threaded_mainloop_unlock(mpMainloop); + if (pa_threaded_mainloop_start(__mpMainloop) < 0) { + pa_threaded_mainloop_unlock(__mpMainloop); THROW_ERROR_MSG(CAudioError::ERROR_FAILED_OPERATION, "Failed pa_threaded_mainloop_start()"); } @@ -217,65 +217,65 @@ void CPulseAudioClient::initialize() throw (CAudioError) { // If I got a signal, do next processing while (true) { pa_context_state_t state; - state = pa_context_get_state(mpContext); + state = pa_context_get_state(__mpContext); if (state == PA_CONTEXT_READY) { break; } if (!PA_CONTEXT_IS_GOOD(state)) { - err = pa_context_errno(mpContext); - pa_threaded_mainloop_unlock(mpMainloop); + 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); } /* Wait until the context is ready */ - pa_threaded_mainloop_wait(mpMainloop); + pa_threaded_mainloop_wait(__mpMainloop); } // Allocates PA stream - pa_sample_spec ss = mSpec.getSampleSpec(); - pa_channel_map map = mSpec.getChannelMap(); + pa_sample_spec ss = __mSpec.getSampleSpec(); + pa_channel_map map = __mSpec.getChannelMap(); - mpStream = pa_stream_new_with_proplist(mpContext, mSpec.getStreamName(), &ss, &map, mpPropList); - if (mpStream == NULL) { - pa_threaded_mainloop_unlock(mpMainloop); + __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()()"); } // Sets stream callbacks - pa_stream_set_state_callback(mpStream, _streamStateChangeCb, this); - pa_stream_set_read_callback(mpStream, _streamCaptureCb, this); - pa_stream_set_write_callback(mpStream, _streamPlaybackCb, this); - pa_stream_set_latency_update_callback(mpStream, _streamLatencyUpdateCb, this); + pa_stream_set_state_callback(__mpStream, __streamStateChangeCb, this); + pa_stream_set_read_callback(__mpStream, __streamCaptureCb, this); + pa_stream_set_write_callback(__mpStream, __streamPlaybackCb, this); + pa_stream_set_latency_update_callback(__mpStream, __streamLatencyUpdateCb, this); // Connect stream with PA Server - if (mDirection == STREAM_DIRECTION_PLAYBACK) { + if (__mDirection == STREAM_DIRECTION_PLAYBACK) { pa_stream_flags_t flags = static_cast( PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_ADJUST_LATENCY | PA_STREAM_AUTO_TIMING_UPDATE); - ret = pa_stream_connect_playback(mpStream, NULL, NULL, flags, NULL, NULL); + ret = pa_stream_connect_playback(__mpStream, NULL, NULL, flags, NULL, NULL); } else { pa_stream_flags_t flags = static_cast( PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_ADJUST_LATENCY | PA_STREAM_AUTO_TIMING_UPDATE); - ret = pa_stream_connect_record(mpStream, NULL, NULL, flags); + ret = pa_stream_connect_record(__mpStream, NULL, NULL, flags); } if (ret != 0) { - err = pa_context_errno(mpContext); - pa_threaded_mainloop_unlock(mpMainloop); + 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); } while (true) { pa_stream_state_t state; - state = pa_stream_get_state(mpStream); + state = pa_stream_get_state(__mpStream); if (state == PA_STREAM_READY) { AUDIO_IO_LOGD("STREAM READY"); @@ -283,19 +283,19 @@ void CPulseAudioClient::initialize() throw (CAudioError) { } if (!PA_STREAM_IS_GOOD(state)) { - err = pa_context_errno(mpContext); - pa_threaded_mainloop_unlock(mpMainloop); + 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); } /* Wait until the stream is ready */ - pa_threaded_mainloop_wait(mpMainloop); + pa_threaded_mainloop_wait(__mpMainloop); } // End of synchronous - pa_threaded_mainloop_unlock(mpMainloop); + pa_threaded_mainloop_unlock(__mpMainloop); - mIsInit = true; + __mIsInit = true; } catch (CAudioError e) { finalize(); throw e; @@ -304,39 +304,39 @@ void CPulseAudioClient::initialize() throw (CAudioError) { void CPulseAudioClient::finalize() { AUDIO_IO_LOGD(""); - if (mIsInit == false) { + if (__mIsInit == false) { return; } - if (mpMainloop != NULL) { - pa_threaded_mainloop_stop(mpMainloop); + if (__mpMainloop != NULL) { + pa_threaded_mainloop_stop(__mpMainloop); } - if (mpStream != NULL) { - pa_stream_disconnect(mpStream); - mpStream = NULL; + if (__mpStream != NULL) { + pa_stream_disconnect(__mpStream); + __mpStream = NULL; } - if (mpContext != NULL) { - pa_context_disconnect(mpContext); - pa_context_unref(mpContext); - mpContext = NULL; + if (__mpContext != NULL) { + pa_context_disconnect(__mpContext); + pa_context_unref(__mpContext); + __mpContext = NULL; } - if (mpMainloop != NULL) { - pa_threaded_mainloop_free(mpMainloop); - mpMainloop = NULL; + if (__mpMainloop != NULL) { + pa_threaded_mainloop_free(__mpMainloop); + __mpMainloop = NULL; } - if (mpPropList != NULL) { - pa_proplist_free(mpPropList); - mpPropList = NULL; + if (__mpPropList != NULL) { + pa_proplist_free(__mpPropList); + __mpPropList = NULL; } - mIsInit = false; + __mIsInit = false; } int CPulseAudioClient::peek(const void** data, size_t* length) throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient"); } @@ -350,18 +350,18 @@ int CPulseAudioClient::peek(const void** data, size_t* length) throw (CAudioErro THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "The parameter is invalid - data:%p, length:%p", data, length); } - if (mDirection == STREAM_DIRECTION_PLAYBACK) { + if (__mDirection == STREAM_DIRECTION_PLAYBACK) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_SUPPORTED, "The Playback client couldn't use this function"); } int ret = 0; if (isInThread() == false) { - pa_threaded_mainloop_lock(mpMainloop); - ret = pa_stream_peek(mpStream, data, length); - pa_threaded_mainloop_unlock(mpMainloop); + pa_threaded_mainloop_lock(__mpMainloop); + ret = pa_stream_peek(__mpStream, data, length); + pa_threaded_mainloop_unlock(__mpMainloop); } else { - ret = pa_stream_peek(mpStream, data, length); + ret = pa_stream_peek(__mpStream, data, length); } if (ret < 0) { @@ -372,7 +372,7 @@ int CPulseAudioClient::peek(const void** data, size_t* length) throw (CAudioErro } int CPulseAudioClient::drop() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient"); } @@ -382,18 +382,18 @@ int CPulseAudioClient::drop() throw (CAudioError) { checkRunningState(); - if (mDirection == STREAM_DIRECTION_PLAYBACK) { + if (__mDirection == STREAM_DIRECTION_PLAYBACK) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_SUPPORTED, "The Playback client couldn't use this function"); } int ret = 0; if (isInThread() == false) { - pa_threaded_mainloop_lock(mpMainloop); - ret = pa_stream_drop(mpStream); - pa_threaded_mainloop_unlock(mpMainloop); + pa_threaded_mainloop_lock(__mpMainloop); + ret = pa_stream_drop(__mpStream); + pa_threaded_mainloop_unlock(__mpMainloop); } else { - ret = pa_stream_drop(mpStream); + ret = pa_stream_drop(__mpStream); } if (ret < 0) { @@ -404,7 +404,7 @@ int CPulseAudioClient::drop() throw (CAudioError) { } int CPulseAudioClient::write(const void* data, size_t length) throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient"); } @@ -418,18 +418,18 @@ int CPulseAudioClient::write(const void* data, size_t length) throw (CAudioError THROW_ERROR_MSG(CAudioError::ERROR_INVALID_ARGUMENT, "The parameter is invalid"); } - if (mDirection == STREAM_DIRECTION_RECORD) { + if (__mDirection == STREAM_DIRECTION_RECORD) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_SUPPORTED, "The Playback client couldn't use this function"); } int ret = 0; if (isInThread() == false) { - pa_threaded_mainloop_lock(mpMainloop); - ret = pa_stream_write(mpStream, data, length, NULL, 0LL, PA_SEEK_RELATIVE); - pa_threaded_mainloop_unlock(mpMainloop); + pa_threaded_mainloop_lock(__mpMainloop); + ret = pa_stream_write(__mpStream, data, length, NULL, 0LL, PA_SEEK_RELATIVE); + pa_threaded_mainloop_unlock(__mpMainloop); } else { - ret = pa_stream_write(mpStream, data, length, NULL, 0LL, PA_SEEK_RELATIVE); + ret = pa_stream_write(__mpStream, data, length, NULL, 0LL, PA_SEEK_RELATIVE); } if (ret < 0) { @@ -442,7 +442,7 @@ int CPulseAudioClient::write(const void* data, size_t length) throw (CAudioError void CPulseAudioClient::cork(bool cork) throw (CAudioError) { AUDIO_IO_LOGD("bool cork:%d", cork); - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient"); } @@ -453,18 +453,18 @@ void CPulseAudioClient::cork(bool cork) throw (CAudioError) { checkRunningState(); if (isInThread() == false) { - pa_threaded_mainloop_lock(mpMainloop); - pa_operation_unref(pa_stream_cork(mpStream, static_cast(cork), _successStreamCb, this)); - pa_threaded_mainloop_unlock(mpMainloop); + pa_threaded_mainloop_lock(__mpMainloop); + pa_operation_unref(pa_stream_cork(__mpStream, static_cast(cork), __successStreamCb, this)); + pa_threaded_mainloop_unlock(__mpMainloop); } else { - pa_operation_unref(pa_stream_cork(mpStream, static_cast(cork), _successStreamCb, this)); + pa_operation_unref(pa_stream_cork(__mpStream, static_cast(cork), __successStreamCb, this)); } return; } bool CPulseAudioClient::isCorked() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient"); } @@ -473,11 +473,11 @@ bool CPulseAudioClient::isCorked() throw (CAudioError) { int isCork = 0; if (isInThread() == false) { - pa_threaded_mainloop_lock(mpMainloop); - isCork = pa_stream_is_corked(mpStream); - pa_threaded_mainloop_unlock(mpMainloop); + pa_threaded_mainloop_lock(__mpMainloop); + isCork = pa_stream_is_corked(__mpStream); + pa_threaded_mainloop_unlock(__mpMainloop); } else { - isCork = pa_stream_is_corked(mpStream); + isCork = pa_stream_is_corked(__mpStream); } AUDIO_IO_LOGD("isCork:%d", isCork); @@ -487,18 +487,18 @@ bool CPulseAudioClient::isCorked() throw (CAudioError) { bool CPulseAudioClient::drain() throw (CAudioError) { AUDIO_IO_LOGD("drain"); - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient"); } checkRunningState(); if (isInThread() == false) { - pa_threaded_mainloop_lock(mpMainloop); - pa_operation_unref(pa_stream_drain(mpStream, _successStreamCb, this)); - pa_threaded_mainloop_unlock(mpMainloop); + pa_threaded_mainloop_lock(__mpMainloop); + pa_operation_unref(pa_stream_drain(__mpStream, __successStreamCb, this)); + pa_threaded_mainloop_unlock(__mpMainloop); } else { - pa_operation_unref(pa_stream_drain(mpStream, _successStreamCb, this)); + pa_operation_unref(pa_stream_drain(__mpStream, __successStreamCb, this)); } return true; @@ -507,60 +507,60 @@ bool CPulseAudioClient::drain() throw (CAudioError) { bool CPulseAudioClient::flush() throw (CAudioError) { AUDIO_IO_LOGD("flush"); - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient"); } checkRunningState(); if (isInThread() == false) { - pa_threaded_mainloop_lock(mpMainloop); - pa_operation_unref(pa_stream_flush(mpStream, _successStreamCb, this)); - pa_threaded_mainloop_unlock(mpMainloop); + pa_threaded_mainloop_lock(__mpMainloop); + pa_operation_unref(pa_stream_flush(__mpStream, __successStreamCb, this)); + pa_threaded_mainloop_unlock(__mpMainloop); } else { - pa_operation_unref(pa_stream_flush(mpStream, _successStreamCb, this)); + pa_operation_unref(pa_stream_flush(__mpStream, __successStreamCb, this)); } return true; } size_t CPulseAudioClient::getWritableSize() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient"); } checkRunningState(); - if (mDirection != STREAM_DIRECTION_PLAYBACK) { + if (__mDirection != STREAM_DIRECTION_PLAYBACK) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_SUPPORTED, "This client is used for Playback"); } size_t ret = 0; if (isInThread() == false) { - pa_threaded_mainloop_lock(mpMainloop); - ret = pa_stream_writable_size(mpStream); - pa_threaded_mainloop_unlock(mpMainloop); + pa_threaded_mainloop_lock(__mpMainloop); + ret = pa_stream_writable_size(__mpStream); + pa_threaded_mainloop_unlock(__mpMainloop); } else { - ret = pa_stream_writable_size(mpStream); + ret = pa_stream_writable_size(__mpStream); } return ret; } void CPulseAudioClient::checkRunningState() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::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); + 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); } - 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); + 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); } - 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); + 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); } #ifdef _AUDIO_IO_DEBUG_TIMING_ @@ -569,11 +569,11 @@ void CPulseAudioClient::checkRunningState() throw (CAudioError) { } bool CPulseAudioClient::isInThread() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient"); } - int ret = pa_threaded_mainloop_in_thread(mpMainloop); + int ret = pa_threaded_mainloop_in_thread(__mpMainloop); #ifdef _AUDIO_IO_DEBUG_TIMING_ AUDIO_IO_LOGD("isInThread : [%d][TRUE:1][FALSE:0]", ret); @@ -582,31 +582,31 @@ bool CPulseAudioClient::isInThread() throw (CAudioError) { } size_t CPulseAudioClient::getReadableSize() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient"); } checkRunningState(); - if (mDirection != STREAM_DIRECTION_RECORD) { + if (__mDirection != STREAM_DIRECTION_RECORD) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_SUPPORTED, "This client is used for Capture"); } size_t ret = 0; if (isInThread() == false) { - pa_threaded_mainloop_lock(mpMainloop); - ret = pa_stream_writable_size(mpStream); - pa_threaded_mainloop_unlock(mpMainloop); + pa_threaded_mainloop_lock(__mpMainloop); + ret = pa_stream_writable_size(__mpStream); + pa_threaded_mainloop_unlock(__mpMainloop); } else { - ret = pa_stream_writable_size(mpStream); + ret = pa_stream_writable_size(__mpStream); } return ret; } size_t CPulseAudioClient::getBufferSize() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient"); } @@ -616,16 +616,16 @@ size_t CPulseAudioClient::getBufferSize() throw (CAudioError) { try { if (isInThread() == false) { - pa_threaded_mainloop_lock(mpMainloop); + pa_threaded_mainloop_lock(__mpMainloop); } - const pa_buffer_attr* attr = pa_stream_get_buffer_attr(mpStream); + const pa_buffer_attr* attr = pa_stream_get_buffer_attr(__mpStream); if (attr == NULL) { - int _err = pa_context_errno(mpContext); + int _err = pa_context_errno(__mpContext); THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_FAILED_OPERATION, "Failed pa_stream_get_buffer_attr() err:%d", _err); } - if (mDirection == STREAM_DIRECTION_PLAYBACK) { + if (__mDirection == STREAM_DIRECTION_PLAYBACK) { ret = attr->tlength; AUDIO_IO_LOGD("PLAYBACK buffer size : %d", ret); } else { @@ -634,20 +634,20 @@ size_t CPulseAudioClient::getBufferSize() throw (CAudioError) { } } catch (CAudioError err) { if (isInThread() == false) { - pa_threaded_mainloop_unlock(mpMainloop); + pa_threaded_mainloop_unlock(__mpMainloop); } throw err; } if (isInThread() == false) { - pa_threaded_mainloop_unlock(mpMainloop); + pa_threaded_mainloop_unlock(__mpMainloop); } return ret; } pa_usec_t CPulseAudioClient::getLatency() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient"); } @@ -657,8 +657,8 @@ pa_usec_t CPulseAudioClient::getLatency() throw (CAudioError) { int negative = 0; if (isInThread() == false) { - if (pa_stream_get_latency(mpStream, &ret, &negative) < 0) { - int _err = pa_context_errno(mpContext); + 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); } @@ -666,34 +666,34 @@ pa_usec_t CPulseAudioClient::getLatency() throw (CAudioError) { return negative ? 0 : ret; } - pa_threaded_mainloop_lock(mpMainloop); + pa_threaded_mainloop_lock(__mpMainloop); try { while (true) { - if (pa_stream_get_latency(mpStream, &ret, &negative) >= 0) { + if (pa_stream_get_latency(__mpStream, &ret, &negative) >= 0) { break; } - int _err = pa_context_errno(mpContext); + 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); } /* Wait until latency data is available again */ - pa_threaded_mainloop_wait(mpMainloop); + pa_threaded_mainloop_wait(__mpMainloop); } } catch (CAudioError e) { - pa_threaded_mainloop_unlock(mpMainloop); + pa_threaded_mainloop_unlock(__mpMainloop); throw e; } - pa_threaded_mainloop_unlock(mpMainloop); + pa_threaded_mainloop_unlock(__mpMainloop); return negative ? 0 : ret; } pa_usec_t CPulseAudioClient::getFinalLatency() throw (CAudioError) { - if (mIsInit == false) { + if (__mIsInit == false) { THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient"); } @@ -704,21 +704,21 @@ pa_usec_t CPulseAudioClient::getFinalLatency() throw (CAudioError) { try { if (isInThread() == false) { - pa_threaded_mainloop_lock(mpMainloop); + pa_threaded_mainloop_lock(__mpMainloop); } - ver = pa_context_get_server_protocol_version(mpContext); + ver = pa_context_get_server_protocol_version(__mpContext); if (ver >= 13) { - const pa_buffer_attr* buffer_attr = pa_stream_get_buffer_attr(mpStream); - const pa_sample_spec* sample_spec = pa_stream_get_sample_spec(mpStream); - const pa_timing_info* timing_info = pa_stream_get_timing_info(mpStream); + const pa_buffer_attr* buffer_attr = pa_stream_get_buffer_attr(__mpStream); + const pa_sample_spec* sample_spec = pa_stream_get_sample_spec(__mpStream); + 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", buffer_attr, sample_spec, timing_info); } - if (mDirection == STREAM_DIRECTION_PLAYBACK) { + if (__mDirection == 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 { @@ -730,11 +730,11 @@ pa_usec_t CPulseAudioClient::getFinalLatency() throw (CAudioError) { } if (isInThread() == false) { - pa_threaded_mainloop_unlock(mpMainloop); + pa_threaded_mainloop_unlock(__mpMainloop); } } catch (CAudioError e) { if (isInThread() == false) { - pa_threaded_mainloop_unlock(mpMainloop); + pa_threaded_mainloop_unlock(__mpMainloop); } throw e; } @@ -743,9 +743,9 @@ pa_usec_t CPulseAudioClient::getFinalLatency() throw (CAudioError) { } CPulseAudioClient::EStreamDirection CPulseAudioClient::getStreamDirection() { - return mDirection; + return __mDirection; } CPulseStreamSpec CPulseAudioClient::getStreamSpec() { - return mSpec; + return __mSpec; } diff --git a/src/cpp/CPulseAudioPolicy.cpp b/src/cpp/CPulseAudioPolicy.cpp index d419ddd..429c896 100644 --- a/src/cpp/CPulseAudioPolicy.cpp +++ b/src/cpp/CPulseAudioPolicy.cpp @@ -27,11 +27,11 @@ using namespace tizen_media_audio; * class CPulseAudioPolicy */ CPulseAudioPolicy::CPulseAudioPolicy() : - mPolicy(POLICY_DEFAULT) { + __mPolicy(POLICY_DEFAULT) { } CPulseAudioPolicy::CPulseAudioPolicy(EPolicy policy) : - mPolicy(policy) { + __mPolicy(policy) { } CPulseAudioPolicy::~CPulseAudioPolicy() { @@ -42,18 +42,18 @@ void CPulseAudioPolicy::setPolicy(EPolicy policy) throw (CAudioError) { THROW_ERROR_MSG(CAudioError::ERROR_INVALID_ARGUMENT, "The argument is out of range"); } - mPolicy = policy; + __mPolicy = policy; } CPulseAudioPolicy::EPolicy CPulseAudioPolicy::getPolicy() { - return mPolicy; + return __mPolicy; } bool CPulseAudioPolicy::operator != (const EPolicy policy) { - return (mPolicy != policy); + return (__mPolicy != policy); } bool CPulseAudioPolicy::operator == (const EPolicy policy) { - return (mPolicy == policy); + return (__mPolicy == policy); } #endif diff --git a/src/cpp/CPulseAudioVolume.cpp b/src/cpp/CPulseAudioVolume.cpp index a8467c2..5e7ceeb 100644 --- a/src/cpp/CPulseAudioVolume.cpp +++ b/src/cpp/CPulseAudioVolume.cpp @@ -26,30 +26,30 @@ using namespace tizen_media_audio; /** * class CPulseAudioVolume */ -CPulseAudioVolume::CPulseAudioVolume() : mVolume(VOLUME_MEDIA), mVolumeGain(VOLUME_GAIN_DEFAULT) { +CPulseAudioVolume::CPulseAudioVolume() : __mVolume(VOLUME_MEDIA), __mVolumeGain(VOLUME_GAIN_DEFAULT) { } CPulseAudioVolume::CPulseAudioVolume(EVolume volume, EVolumeGain gain) : - mVolume(volume), - mVolumeGain(gain) { + __mVolume(volume), + __mVolumeGain(gain) { } CPulseAudioVolume::~CPulseAudioVolume() { } void CPulseAudioVolume::setVolume(EVolume volume) { - mVolume = volume; + __mVolume = volume; } CPulseAudioVolume::EVolume CPulseAudioVolume::getVolume() { - return mVolume; + return __mVolume; } void CPulseAudioVolume::setVolumeGain(EVolumeGain volumeGain) { - mVolumeGain = volumeGain; + __mVolumeGain = volumeGain; } CPulseAudioVolume::EVolumeGain CPulseAudioVolume::getVolumeGain() { - return mVolumeGain; + return __mVolumeGain; } #endif diff --git a/src/cpp/CPulseStreamSpec.cpp b/src/cpp/CPulseStreamSpec.cpp index d2ab34c..73025e2 100644 --- a/src/cpp/CPulseStreamSpec.cpp +++ b/src/cpp/CPulseStreamSpec.cpp @@ -39,104 +39,104 @@ static const char* STREAM_LATENCY_VOIP = "voip"; CPulseStreamSpec::CPulseStreamSpec() throw (CAudioError) : - mLatency(STREAM_LATENCY_INPUT_MID), - mStreamName(NULL) { - _adjustSpec(); + __mLatency(STREAM_LATENCY_INPUT_MID), + __mStreamName(NULL) { + __adjustSpec(); } CPulseStreamSpec::CPulseStreamSpec(EStreamLatency latency, CAudioInfo& audioInfo) throw (CAudioError) : - mLatency(latency), - mAudioInfo(audioInfo), - mStreamName(NULL) { - _adjustSpec(); + __mLatency(latency), + __mAudioInfo(audioInfo), + __mStreamName(NULL) { + __adjustSpec(); } CPulseStreamSpec::CPulseStreamSpec(EStreamLatency latency, CAudioInfo& audioInfo, int customLatency) throw (CAudioError) : - mLatency(latency), - mAudioInfo(audioInfo), - mStreamName(NULL) { - _adjustSpec(); + __mLatency(latency), + __mAudioInfo(audioInfo), + __mStreamName(NULL) { + __adjustSpec(); } CPulseStreamSpec::~CPulseStreamSpec() { } -void CPulseStreamSpec::_adjustSpec() throw (CAudioError) { +void CPulseStreamSpec::__adjustSpec() throw (CAudioError) { // Sets a sampleRate - mSampleSpec.rate = mAudioInfo.getSampleRate(); + __mSampleSpec.rate = __mAudioInfo.getSampleRate(); // Convert channels for PA - switch (mAudioInfo.getChannel()) { + switch (__mAudioInfo.getChannel()) { case CAudioInfo::CHANNEL_MONO: - mSampleSpec.channels = 1; + __mSampleSpec.channels = 1; break; case CAudioInfo::CHANNEL_STEREO: default: - mSampleSpec.channels = 2; + __mSampleSpec.channels = 2; break; } // Convert format for PA - switch (mAudioInfo.getSampleType()) { + switch (__mAudioInfo.getSampleType()) { case CAudioInfo::SAMPLE_TYPE_U8: - mSampleSpec.format = PA_SAMPLE_U8; + __mSampleSpec.format = PA_SAMPLE_U8; break; case CAudioInfo::SAMPLE_TYPE_S16_LE: default: - mSampleSpec.format = PA_SAMPLE_S16LE; + __mSampleSpec.format = PA_SAMPLE_S16LE; break; } // Sets channelmap - pa_channel_map_init_auto(&mChannelMap, mSampleSpec.channels, PA_CHANNEL_MAP_ALSA); + pa_channel_map_init_auto(&__mChannelMap, __mSampleSpec.channels, PA_CHANNEL_MAP_ALSA); // Sets stream name - switch (mLatency) { + switch (__mLatency) { case STREAM_LATENCY_OUTPUT_MID: - mStreamName = STREAM_NAME_OUTPUT; + __mStreamName = STREAM_NAME_OUTPUT; break; case STREAM_LATENCY_OUTPUT_HIGH: - mStreamName = STREAM_NAME_OUTPUT_HIGH_LATENCY; + __mStreamName = STREAM_NAME_OUTPUT_HIGH_LATENCY; break; case STREAM_LATENCY_OUTPUT_LOW: - mStreamName = STREAM_NAME_OUTPUT_LOW_LATENCY; + __mStreamName = STREAM_NAME_OUTPUT_LOW_LATENCY; break; case STREAM_LATENCY_OUTPUT_VOIP: - mStreamName = STREAM_NAME_OUTPUT_VOIP; + __mStreamName = STREAM_NAME_OUTPUT_VOIP; break; case STREAM_LATENCY_INPUT_HIGH: - mStreamName = STREAM_NAME_INPUT_HIGH_LATENCY; + __mStreamName = STREAM_NAME_INPUT_HIGH_LATENCY; break; case STREAM_LATENCY_INPUT_LOW: - mStreamName = STREAM_NAME_INPUT_LOW_LATENCY; + __mStreamName = STREAM_NAME_INPUT_LOW_LATENCY; break; case STREAM_LATENCY_INPUT_VOIP: - mStreamName = STREAM_NAME_INPUT_VOIP; + __mStreamName = STREAM_NAME_INPUT_VOIP; break; case STREAM_LATENCY_INPUT_MID: default: - mStreamName = STREAM_NAME_INPUT; + __mStreamName = STREAM_NAME_INPUT; break; } } CPulseStreamSpec::EStreamLatency CPulseStreamSpec::getStreamLatency() { - return mLatency; + return __mLatency; } const char* CPulseStreamSpec::getStreamLatencyToString() { const char* latency; - switch (mLatency) { + switch (__mLatency) { case STREAM_LATENCY_INPUT_LOW: case STREAM_LATENCY_OUTPUT_LOW: latency = STREAM_LATENCY_LOW; @@ -162,17 +162,17 @@ const char* CPulseStreamSpec::getStreamLatencyToString() { } CAudioInfo CPulseStreamSpec::getAudioInfo() { - return mAudioInfo; + return __mAudioInfo; } pa_sample_spec CPulseStreamSpec::getSampleSpec() { - return mSampleSpec; + return __mSampleSpec; } pa_channel_map CPulseStreamSpec::getChannelMap() { - return mChannelMap; + return __mChannelMap; } const char* CPulseStreamSpec::getStreamName() { - return mStreamName; + return __mStreamName; } -- 2.34.1