*/
class CAudioError {
public:
- /* Constants Definition */
- static const unsigned int MSG_LENGTH = 512;
-
+ /* Enums Definition */
enum EError {
ERROR_NONE,
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);
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
void (*onStream)(size_t nbytes, void* user_data);
SStreamCallback() : mUserData(NULL), onStream(NULL)
- {/* Empty Body */}
+ { /* Empty Body */ }
};
struct SStateChangedCallback {
void (*onStateChanged)(CAudioInfo::EAudioIOState state, CAudioInfo::EAudioIOState statePrev, bool byPolicy, void* user_data);
SStateChangedCallback() : mUserData(NULL), onStateChanged(NULL)
- {/* Empty Body */}
+ { /* Empty Body */ }
};
struct SInterruptCallback {
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);
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
*/
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 */
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 */
//"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
* 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);
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
* 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);
/* 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
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},
{"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},
};
/* 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;
};
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,
/* 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);
};
*/
class CPulseAudioPolicy {
public:
- /* Constants */
+ /* Enums */
enum EPolicy {
POLICY_DEFAULT,
POLICY_OUT_AUTO,
POLICY_MAX
};
- private:
- /* Members */
- EPolicy mPolicy;
-
- public:
/* Constructors */
CPulseAudioPolicy();
CPulseAudioPolicy(EPolicy policy);
/* Override */
bool operator != (const EPolicy policy);
bool operator == (const EPolicy policy);
+
+ private:
+ /* Members */
+ EPolicy __mPolicy;
};
*/
class CPulseAudioVolume {
public:
- /* Constants */
+ /* Enums */
enum EVolume {
VOLUME_SYSTEM, /**< System volume type */
VOLUME_NOTIFICATION, /**< Notification volume type */
VOLUME_GAIN_MAX
};
- private:
- /* Members */
- EVolume mVolume;
- EVolumeGain mVolumeGain;
-
- public:
/* Constructor & Destructor */
CPulseAudioVolume();
CPulseAudioVolume(EVolume volume, EVolumeGain gain);
void setVolumeGain(EVolumeGain volumeGain);
EVolumeGain getVolumeGain();
+
+ private:
+ /* Members */
+ EVolume __mVolume;
+ EVolumeGain __mVolumeGain;
};
*/
class CPulseStreamSpec {
public:
- /* Constants */
+ /* Enums */
enum EStreamLatency {
STREAM_LATENCY_INPUT_LOW,
STREAM_LATENCY_INPUT_MID,
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);
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;
};
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
/**
* 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() {
}
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;
//}
* 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;
}
void CAudioIO::setInit(bool flag) {
- mIsInit = flag;
+ __mIsInit = flag;
}
bool CAudioIO::isInit() {
- return mIsInit;
+ return __mIsInit;
}
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_
}
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_
}
void CAudioIO::internalWait() throw (CAudioError) {
- if (mIsInit == false) {
+ if (__mIsInit == false) {
THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
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");
}
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);
}
void CAudioIO::onStateChanged(CAudioInfo::EAudioIOState state, bool byPolicy) {
- assert(mIsInit == true);
+ assert(__mIsInit == true);
assert(state > 0);
mStatePrev = mState;
}
void CAudioIO::prepare() throw (CAudioError) {
- if (mIsInit == false) {
+ if (__mIsInit == false) {
THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
}
void CAudioIO::unprepare() throw (CAudioError) {
- if (mIsInit == false) {
+ if (__mIsInit == false) {
THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
}
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");
}
}
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");
}
}
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");
}
}
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");
}
}
CAudioInfo CAudioIO::getAudioInfo() throw (CAudioError) {
- if (mIsInit == false) {
+ if (__mIsInit == false) {
THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
}
void CAudioIO::setStreamCallback(SStreamCallback callback) throw (CAudioError) {
- if (mIsInit == false) {
+ if (__mIsInit == false) {
THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
}
CAudioIO::SStreamCallback CAudioIO::getStreamCallback() throw (CAudioError) {
- if (mIsInit == false) {
+ if (__mIsInit == false) {
THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
}
void CAudioIO::setStateChangedCallback(SStateChangedCallback callback) throw (CAudioError) {
- if (mIsInit == false) {
+ if (__mIsInit == false) {
THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
}
CAudioIO::SStateChangedCallback CAudioIO::getStateChangedCallback() throw (CAudioError) {
- if (mIsInit == false) {
+ if (__mIsInit == false) {
THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
}
void CAudioIO::setInterruptCallback(SInterruptCallback callback) throw (CAudioError) {
- if (mIsInit == false) {
+ if (__mIsInit == false) {
THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
}
CAudioIO::SInterruptCallback CAudioIO::getInterruptCallback() throw (CAudioError) {
- if (mIsInit == false) {
+ if (__mIsInit == false) {
THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
void CAudioIO::ignoreSession() throw (CAudioError) {
- if (mIsInit == false) {
+ if (__mIsInit == false) {
THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
}
bool isSkip = mpAudioSessionHandler->isSkipSessionEvent();
if (isSkip == false && mpAudioSessionHandler->getId() >= 0) {
mpAudioSessionHandler->unregisterSound();
- mForceIgnore = true;
+ __mForceIgnore = true;
}
internalUnlock();
* 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);
}
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;
}
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;
}
{
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;
}
}
{
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;
}
}
*/
CAudioInput::CAudioInput(CAudioInfo& info) :
CAudioIO(info),
- mpSyncReadDataPtr(NULL),
- mSyncReadIndex(0),
- mSyncReadLength(0),
- mIsUsedSyncRead(true) {
+ __mpSyncReadDataPtr(NULL),
+ __mSyncReadIndex(0),
+ __mSyncReadLength(0),
+ __mIsUsedSyncRead(true) {
}
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);
}
* 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
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;
}
// Initialize ASM Handler
mpAudioSessionHandler->initialize();
- setInit(true);
+ __setInit(true);
CAudioIO::onStateChanged(CAudioInfo::AUDIO_IO_STATE_IDLE);
} catch (CAudioError err) {
finalize();
}
void CAudioInput::finalize() {
- if (IsInit() == false) {
+ if (__IsInit() == false) {
AUDIO_IO_LOGD("Did not initialize");
return;
}
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;
}
}
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;
}
}
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");
}
}
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");
}
}
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");
}
}
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;
}
}
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");
}
}
/* Checks synchronous flag */
- if (mIsUsedSyncRead == false) {
+ if (__mIsUsedSyncRead == false) {
THROW_ERROR_MSG(CAudioError::ERROR_INVALID_OPERATION, "Invalid operation of read() if receive stream callback");
}
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.
*/
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) {
}
// Reset the internal pointer
- mpSyncReadDataPtr = NULL;
- mSyncReadLength = 0;
- mSyncReadIndex = 0;
+ __mpSyncReadDataPtr = NULL;
+ __mSyncReadLength = 0;
+ __mSyncReadIndex = 0;
}
} // End of while (length > 0)
}
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");
}
}
/* 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");
}
}
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");
}
*/
CAudioOutput::CAudioOutput(CAudioInfo& info) :
CAudioIO(info),
- mIsUsedSyncWrite(false) {
+ __mIsUsedSyncWrite(false) {
}
CAudioOutput::CAudioOutput(
CAudioInfo::EChannel channel,
CAudioInfo::ESampleType sampleType,
CAudioInfo::EAudioType audioType) :
- mIsUsedSyncWrite(false) {
+ __mIsUsedSyncWrite(false) {
mAudioInfo = CAudioInfo(sampleRate, channel, sampleType, audioType, -1);
}
* 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
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;
}
// Initialize ASM Handler
mpAudioSessionHandler->initialize();
- setInit(true);
+ __setInit(true);
CAudioIO::onStateChanged(CAudioInfo::AUDIO_IO_STATE_IDLE);
} catch (CAudioError err) {
finalize();
}
void CAudioOutput::finalize() {
- if (IsInit() == false) {
+ if (__IsInit() == false) {
AUDIO_IO_LOGD("Did not initialize");
return;
}
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");
}
}
void CAudioOutput::unprepare() throw (CAudioError) {
- if (IsInit() == false) {
+ if (__IsInit() == false) {
THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioOutput");
}
}
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");
}
}
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");
}
}
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");
}
}
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");
}
}
int CAudioOutput::getBufferSize() throw (CAudioError) {
- if (IsInit() == false) {
+ if (__IsInit() == false) {
THROW_ERROR_MSG(CAudioError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioOutput");
}
}
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");
}
internalLock();
// Sets synchronous flag
- mIsUsedSyncWrite = true;
+ __mIsUsedSyncWrite = true;
size_t lengthIter = length;
} // 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;
}
/**
* 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;
}
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);
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;
}
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<CAudioSessionHandler*>(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) {
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<void*>(this));
+ errorCode = mm_sound_subscribe_signal(MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS, &subscribe_id, __sound_pcm_signal_cb, static_cast<void*>(this));
if (errorCode != MM_ERROR_NONE) {
THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_POLICY_BLOCKED, "Failed mm_sound_get_signal_value() err:0x%x", errorCode);
}
- 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 {
}
// 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) {
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;
}
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);
}
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<CAudioSessionHandler*>(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<void*>(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<void*>(this), &mId);
+ errorCode = mm_sound_set_focus_watch_callback(FOCUS_FOR_BOTH, __sound_pcm_focus_watch_cb, static_cast<void*>(this), &__mId);
if (errorCode < 0) {
THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_POLICY_BLOCKED, "Failed mm_sound_set_focus_watch_callback() err:0x%x", errorCode);
}
- 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);
}
}
}
CAudioSessionHandler::updateStop();
CAudioSessionHandler::unregisterSound();
- CAudioSessionHandler::mUseFocus = false;
+ CAudioSessionHandler::__mUseFocus = false;
}
/**
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<CPulseAudioClient*>(user_data);
assert(pClient);
assert(c);
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:
}
}
-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<CPulseAudioClient*>(user_data);
- pClient->mIsOperationSuccess = static_cast<bool>(success);
+ pClient->__mIsOperationSuccess = static_cast<bool>(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);
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:
}
}
-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<CPulseAudioClient*>(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<CPulseAudioClient*>(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];
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<CPulseAudioClient*>(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<CPulseAudioClient*>(user_data);
- pClient->mIsOperationSuccess = static_cast<bool>(success);
+ pClient->__mIsOperationSuccess = static_cast<bool>(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;
}
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()");
}
// 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_flags_t>(
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_flags_t>(
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");
}
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;
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");
}
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) {
}
int CPulseAudioClient::drop() 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, "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) {
}
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");
}
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) {
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");
}
checkRunningState();
if (isInThread() == false) {
- pa_threaded_mainloop_lock(mpMainloop);
- pa_operation_unref(pa_stream_cork(mpStream, static_cast<int>(cork), _successStreamCb, this));
- pa_threaded_mainloop_unlock(mpMainloop);
+ pa_threaded_mainloop_lock(__mpMainloop);
+ pa_operation_unref(pa_stream_cork(__mpStream, static_cast<int>(cork), __successStreamCb, this));
+ pa_threaded_mainloop_unlock(__mpMainloop);
} else {
- pa_operation_unref(pa_stream_cork(mpStream, static_cast<int>(cork), _successStreamCb, this));
+ pa_operation_unref(pa_stream_cork(__mpStream, static_cast<int>(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");
}
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);
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;
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_
}
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);
}
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");
}
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 {
}
} 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");
}
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);
}
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");
}
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 {
}
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;
}
}
CPulseAudioClient::EStreamDirection CPulseAudioClient::getStreamDirection() {
- return mDirection;
+ return __mDirection;
}
CPulseStreamSpec CPulseAudioClient::getStreamSpec() {
- return mSpec;
+ return __mSpec;
}
* class CPulseAudioPolicy
*/
CPulseAudioPolicy::CPulseAudioPolicy() :
- mPolicy(POLICY_DEFAULT) {
+ __mPolicy(POLICY_DEFAULT) {
}
CPulseAudioPolicy::CPulseAudioPolicy(EPolicy policy) :
- mPolicy(policy) {
+ __mPolicy(policy) {
}
CPulseAudioPolicy::~CPulseAudioPolicy() {
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
/**
* 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
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;
}
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;
}
projects / platform / core / api / audio-io.git / commitdiff