audio-io fixed memory corruption issue on 64bit target, C++ conding rule updated

[Version] 0.3.10
[Profile] Common
[Issue Type] Bug
[Dependency module] NA
[Dependency commit] NA
[Comment]

Signed-off-by: KimJeongYeon <jeongyeon.kim@samsung.com>
Change-Id: Ib84cc8812cc5819488e72e0a30c3bca26e3f7a85

diff --git a/include/CAudioError.h b/include/CAudioError.h
index 3dc36b9..80fe8f5 100644 (file)
--- a/include/CAudioError.h
+++ b/include/CAudioError.h
@@ -71,7 +71,7 @@ namespace tizen_media_audio {
         EError        mError;
         char          mErrorMsg[MSG_LENGTH];
 
-        const char* _convertErrorToString(EError err);
+        const char* __convertErrorToString(EError err);
 
     public:
         /* Constructor & Destructor */

diff --git a/include/audio_io.h b/include/audio_io.h
index 397235a..5d586f4 100644 (file)
--- a/include/audio_io.h
+++ b/include/audio_io.h
@@ -17,9 +17,9 @@
 #ifndef __TIZEN_MEDIA_AUDIO_IO_H__
 #define __TIZEN_MEDIA_AUDIO_IO_H__
 
+#include <sys/types.h>
 #include <tizen.h>
 #include <sound_manager.h>
-#include <sys/types.h>
 
 #ifdef __cplusplus
 extern "C"

diff --git a/packaging/capi-media-audio-io.spec b/packaging/capi-media-audio-io.spec
index b568aa1..fb81cf8 100644 (file)
--- a/packaging/capi-media-audio-io.spec
+++ b/packaging/capi-media-audio-io.spec
@@ -1,6 +1,6 @@
 Name:       capi-media-audio-io
 Summary:    An Audio Input & Audio Output library in Tizen Native API
-Version:    0.3.9
+Version:    0.3.10
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/cpp/CAudioError.cpp b/src/cpp/CAudioError.cpp
index 8244bbd..48e89e5 100644 (file)
--- a/src/cpp/CAudioError.cpp
+++ b/src/cpp/CAudioError.cpp
@@ -30,16 +30,18 @@ using namespace tizen_media_audio;
 CAudioError::EError CAudioError::mLastError = CAudioError::ERROR_NONE;
 char CAudioError::mLastErrorMsg[CAudioError::MSG_LENGTH];
 
-CAudioError::CAudioError(EError err) : mError(err) {
+CAudioError::CAudioError(EError err) :
+    mError(err) {
     mLastError = mError;
 }
 
-CAudioError::CAudioError(EError err, const char* fileName, const char* parentFunc, int lineNum) : mError(err) {
+CAudioError::CAudioError(EError err, const char* fileName, const char* parentFunc, int lineNum) :
+    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, "["
             COLOR_RED    "THROW" COLOR_END ":%s|"
@@ -49,12 +51,13 @@ CAudioError::CAudioError(EError err, const char* fileName, const char* parentFun
     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) {
+CAudioError::CAudioError(EError err, const char* msg, const char* fileName, const char* parentFunc, int lineNum) :
+    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, "["
             COLOR_RED    "THROW" COLOR_END ":%s|"
@@ -74,7 +77,7 @@ CAudioError::CAudioError(EError err, const char* msg, const char* fileName, cons
 CAudioError::~CAudioError() {
 }
 
-const char* CAudioError::_convertErrorToString(EError err) {
+const char* CAudioError::__convertErrorToString(EError err) {
     switch (err) {
     default:
     case ERROR_NONE:                return COLOR_GREEN "ERROR_NONE"               COLOR_END;

diff --git a/src/cpp/CAudioIO.cpp b/src/cpp/CAudioIO.cpp
index 6d33316..e641fab 100644 (file)
--- a/src/cpp/CAudioIO.cpp
+++ b/src/cpp/CAudioIO.cpp
@@ -30,7 +30,11 @@ using namespace tizen_media_audio;
 /**
  * class CAudioIO
  */
-CAudioIO::CAudioIO() : mIsInit(false), mForceIgnore(false), mpAudioSessionHandler(NULL), mpPulseAudioClient(NULL) {
+CAudioIO::CAudioIO() :
+    mIsInit(false),
+    mForceIgnore(false),
+    mpAudioSessionHandler(NULL),
+    mpPulseAudioClient(NULL) {
     mState = CAudioInfo::AUDIO_IO_STATE_NONE;
     mStatePrev = CAudioInfo::AUDIO_IO_STATE_NONE;
     mByPolicy = false;

diff --git a/src/cpp/CAudioInfo.cpp b/src/cpp/CAudioInfo.cpp
index c6c3d1d..302d348 100644 (file)
--- a/src/cpp/CAudioInfo.cpp
+++ b/src/cpp/CAudioInfo.cpp
@@ -26,14 +26,20 @@ using namespace tizen_media_audio;
 /**
  * class CAudioInfo
  */
-CAudioInfo::CAudioInfo()
-    :  mSampleRate(MAX_SYSTEM_SAMPLERATE), mChannel(CHANNEL_MONO),
-       mSampleType(SAMPLE_TYPE_U8), mAudioType(AUDIO_IN_TYPE_MEDIA),
-       mAudioIndex(-1) {
+CAudioInfo::CAudioInfo() :
+    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) {
+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) {
     // 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);

diff --git a/src/cpp/CAudioInput.cpp b/src/cpp/CAudioInput.cpp
index c95b72c..7e1ce87 100644 (file)
--- a/src/cpp/CAudioInput.cpp
+++ b/src/cpp/CAudioInput.cpp
@@ -25,23 +25,23 @@ using namespace tizen_media_audio;
 /**
  * class CAudioInput inherited by CAudioIO
  */
-CAudioInput::CAudioInput(CAudioInfo& info)
-    : CAudioIO(info),
-      mpSyncReadDataPtr(NULL),
-      mSyncReadIndex(0),
-      mSyncReadLength(0),
-      mIsUsedSyncRead(true) {
+CAudioInput::CAudioInput(CAudioInfo& info) :
+    CAudioIO(info),
+    mpSyncReadDataPtr(NULL),
+    mSyncReadIndex(0),
+    mSyncReadLength(0),
+    mIsUsedSyncRead(true) {
 }
 
 CAudioInput::CAudioInput(
         unsigned int            sampleRate,
         CAudioInfo::EChannel    channel,
         CAudioInfo::ESampleType type,
-        CAudioInfo::EAudioType  audioType)
-      : mpSyncReadDataPtr(NULL),
-        mSyncReadIndex(0),
-        mSyncReadLength(0),
-        mIsUsedSyncRead(true) {
+        CAudioInfo::EAudioType  audioType) :
+    mpSyncReadDataPtr(NULL),
+    mSyncReadIndex(0),
+    mSyncReadLength(0),
+    mIsUsedSyncRead(true) {
     mAudioInfo = CAudioInfo(sampleRate, channel, type, audioType, -1);
 }
 

diff --git a/src/cpp/CAudioOutput.cpp b/src/cpp/CAudioOutput.cpp
index 2661e13..ba673e0 100644 (file)
--- a/src/cpp/CAudioOutput.cpp
+++ b/src/cpp/CAudioOutput.cpp
@@ -25,14 +25,17 @@ using namespace tizen_media_audio;
 /**
  * class CAudioOutput
  */
-CAudioOutput::CAudioOutput(CAudioInfo& info) : CAudioIO(info), mIsUsedSyncWrite(false) {
+CAudioOutput::CAudioOutput(CAudioInfo& info) :
+    CAudioIO(info),
+    mIsUsedSyncWrite(false) {
 }
 
 CAudioOutput::CAudioOutput(
         unsigned int            sampleRate,
         CAudioInfo::EChannel    channel,
         CAudioInfo::ESampleType sampleType,
-        CAudioInfo::EAudioType  audioType) : mIsUsedSyncWrite(false) {
+        CAudioInfo::EAudioType  audioType) :
+    mIsUsedSyncWrite(false) {
     mAudioInfo = CAudioInfo(sampleRate, channel, sampleType, audioType, -1);
 }
 

diff --git a/src/cpp/CAudioSessionHandler.cpp b/src/cpp/CAudioSessionHandler.cpp
index f6a37b1..9a6bfe6 100644 (file)
--- a/src/cpp/CAudioSessionHandler.cpp
+++ b/src/cpp/CAudioSessionHandler.cpp
@@ -80,15 +80,15 @@ int CAudioSessionHandler::FOCUS_ID_COUNT_GET() {
     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) {
+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;
 }
 
@@ -134,7 +134,7 @@ CAudioError CAudioSessionHandler::_getAsmInformation(MMSessionType *type, int *o
     /* Read session information */
     int ret = 0;
     if ((ret = _mm_session_util_read_information(-1, (int*)&currentSession, &sessionOptions)) < 0) {
-        if(ret == (int) MM_ERROR_INVALID_HANDLE) {
+        if (ret == (int) MM_ERROR_INVALID_HANDLE) {
             RET_ERROR_MSG(CAudioError::ERROR_INVALID_HANDLE, "Failed _mm_session_util_read_information(). Invalid handle");
         } else {
             RET_ERROR_MSG(CAudioError::ERROR_FAILED_OPERATION, "Failed _mm_session_util_read_information(). Not exist");
@@ -148,7 +148,7 @@ CAudioError CAudioSessionHandler::_getAsmInformation(MMSessionType *type, int *o
 }
 
 bool CAudioSessionHandler::_isFocusRequired(MMSessionType type, int options) {
-    if((options & ASM_SESSION_OPTION_PAUSE_OTHERS)
+    if ((options & ASM_SESSION_OPTION_PAUSE_OTHERS)
         || ((type != MM_SESSION_TYPE_MEDIA) && (type != MM_SESSION_TYPE_MEDIA_RECORD)))
         return true;
     else

diff --git a/src/cpp/CPulseAudioClient.cpp b/src/cpp/CPulseAudioClient.cpp
index 55d2f39..c301802 100644 (file)
--- a/src/cpp/CPulseAudioClient.cpp
+++ b/src/cpp/CPulseAudioClient.cpp
@@ -30,10 +30,16 @@ const char* CPulseAudioClient::CLIENT_NAME = "AUDIO_IO_PA_CLIENT";
 
 CPulseAudioClient::CPulseAudioClient(EStreamDirection      direction,
                                      CPulseStreamSpec&     spec,
-                                     IPulseStreamListener* listener)
-    : mDirection(direction), mSpec(spec),     mpListener(listener),
-      mpMainloop(NULL),      mpContext(NULL), mpStream(NULL),
-      mpPropList(NULL),      mIsInit(false),  mIsOperationSuccess(false) {
+                                     IPulseStreamListener* listener) :
+    mDirection(direction),
+    mSpec(spec),
+    mpListener(listener),
+    mpMainloop(NULL),
+    mpContext(NULL),
+    mpStream(NULL),
+    mpPropList(NULL),
+    mIsInit(false),
+    mIsOperationSuccess(false) {
 }
 
 CPulseAudioClient::~CPulseAudioClient() {

diff --git a/src/cpp/CPulseAudioPolicy.cpp b/src/cpp/CPulseAudioPolicy.cpp
index 0c96f84..d419ddd 100644 (file)
--- a/src/cpp/CPulseAudioPolicy.cpp
+++ b/src/cpp/CPulseAudioPolicy.cpp
@@ -26,10 +26,12 @@ using namespace tizen_media_audio;
 /**
  * class CPulseAudioPolicy
  */
-CPulseAudioPolicy::CPulseAudioPolicy() : mPolicy(POLICY_DEFAULT) {
+CPulseAudioPolicy::CPulseAudioPolicy() :
+    mPolicy(POLICY_DEFAULT) {
 }
 
-CPulseAudioPolicy::CPulseAudioPolicy(EPolicy policy) : mPolicy(policy) {
+CPulseAudioPolicy::CPulseAudioPolicy(EPolicy policy) :
+    mPolicy(policy) {
 }
 
 CPulseAudioPolicy::~CPulseAudioPolicy() {

diff --git a/src/cpp/CPulseAudioVolume.cpp b/src/cpp/CPulseAudioVolume.cpp
index 12aaf05..1a5743d 100644 (file)
--- a/src/cpp/CPulseAudioVolume.cpp
+++ b/src/cpp/CPulseAudioVolume.cpp
@@ -26,10 +26,12 @@ using namespace tizen_media_audio;
 /**
  * class CPulseAudioVolume
  */
-CPulseAudioVolume::CPulseAudioVolume() : mVolume(VOLUME_MEDIA), mVolumeGain(VOLUME_GAIN_DEFAULT) {
+CPulseAudioVolume/::CPulseAudioVolume() : mVolume(VOLUME_MEDIA), mVolumeGain(VOLUME_GAIN_DEFAULT) {
 }
 
-CPulseAudioVolume::CPulseAudioVolume(EVolume volume, EVolumeGain gain) : mVolume(volume), mVolumeGain(gain) {
+CPulseAudioVolume::CPulseAudioVolume(EVolume volume, EVolumeGain gain) :
+    mVolume(volume),
+    mVolumeGain(gain) {
 }
 
 CPulseAudioVolume::~CPulseAudioVolume() {

diff --git a/src/cpp/CPulseStreamSpec.cpp b/src/cpp/CPulseStreamSpec.cpp
index c564944..8a38acf 100644 (file)
--- a/src/cpp/CPulseStreamSpec.cpp
+++ b/src/cpp/CPulseStreamSpec.cpp
@@ -33,18 +33,23 @@ static const char* STREAM_NAME_OUTPUT_HIGH_LATENCY = "HIGH LATENCY PLAYBACK";
 static const char* STREAM_NAME_OUTPUT_VOIP         = "VOIP PLAYBACK";
 
 
-CPulseStreamSpec::CPulseStreamSpec() throw (CAudioError)
-        : mLatency(STREAM_LATENCY_INPUT_MID), mStreamName(NULL) {
+CPulseStreamSpec::CPulseStreamSpec() throw (CAudioError) :
+    mLatency(STREAM_LATENCY_INPUT_MID),
+    mStreamName(NULL) {
     _adjustSpec();
 }
 
-CPulseStreamSpec::CPulseStreamSpec(EStreamLatency latency, CAudioInfo& audioInfo) throw (CAudioError)
-        : mLatency(latency), mAudioInfo(audioInfo), mStreamName(NULL) {
+CPulseStreamSpec::CPulseStreamSpec(EStreamLatency latency, CAudioInfo& audioInfo) throw (CAudioError) :
+    mLatency(latency),
+    mAudioInfo(audioInfo),
+    mStreamName(NULL) {
     _adjustSpec();
 }
 
-CPulseStreamSpec::CPulseStreamSpec(EStreamLatency latency, CAudioInfo& audioInfo, int customLatency) throw (CAudioError)
-        : mLatency(latency), mAudioInfo(audioInfo), mStreamName(NULL) {
+CPulseStreamSpec::CPulseStreamSpec(EStreamLatency latency, CAudioInfo& audioInfo, int customLatency) throw (CAudioError) :
+    mLatency(latency),
+    mAudioInfo(audioInfo),
+    mStreamName(NULL) {
     _adjustSpec();
 }
 

diff --git a/src/cpp/cpp_audio_io.cpp b/src/cpp/cpp_audio_io.cpp
index 3fddd75..f2a0174 100644 (file)
--- a/src/cpp/cpp_audio_io.cpp
+++ b/src/cpp/cpp_audio_io.cpp
@@ -15,10 +15,10 @@
  */
 
 
-#include "audio_io.h"
 #include "cpp_audio_io.h"
-#include "CAudioIODef.h"
 #include <sound_manager_internal.h>
+#include "audio_io.h"
+#include "CAudioIODef.h"
 
 
 using namespace std;
@@ -90,7 +90,7 @@ typedef struct audio_io_s {
 /**
  * Internal functions
  */
-static audio_io_error_e _convert_CAudioError(CAudioError& error) {
+static audio_io_error_e __convert_CAudioError(CAudioError& error) {
     audio_io_error_e    ret = AUDIO_IO_ERROR_NONE;
     CAudioError::EError err = error.getError();
 
@@ -142,7 +142,7 @@ static audio_io_error_e _convert_CAudioError(CAudioError& error) {
     return ret;
 }
 
-static void _convert_channel_2_audio_info_channel(const audio_channel_e& src_channel, CAudioInfo::EChannel& dst_channel) {
+static void __convert_channel_2_audio_info_channel(const audio_channel_e& src_channel, CAudioInfo::EChannel& dst_channel) {
     switch (src_channel) {
     case AUDIO_CHANNEL_MONO:
         dst_channel = CAudioInfo::CHANNEL_MONO;
@@ -155,7 +155,7 @@ static void _convert_channel_2_audio_info_channel(const audio_channel_e& src_cha
     }
 }
 
-static void _convert_audio_info_channel_2_channel(const CAudioInfo::EChannel& src_channel, audio_channel_e& dst_channel) {
+static void __convert_audio_info_channel_2_channel(const CAudioInfo::EChannel& src_channel, audio_channel_e& dst_channel) {
     switch (src_channel) {
     case CAudioInfo::CHANNEL_MONO:
         dst_channel = AUDIO_CHANNEL_MONO;
@@ -168,7 +168,7 @@ static void _convert_audio_info_channel_2_channel(const CAudioInfo::EChannel& sr
     }
 }
 
-static void _convert_sample_type_2_audio_info_sample_type(const audio_sample_type_e& src_type, CAudioInfo::ESampleType& dst_type) {
+static void __convert_sample_type_2_audio_info_sample_type(const audio_sample_type_e& src_type, CAudioInfo::ESampleType& dst_type) {
     switch (src_type) {
     case AUDIO_SAMPLE_TYPE_U8:
         dst_type = CAudioInfo::SAMPLE_TYPE_U8;
@@ -181,7 +181,7 @@ static void _convert_sample_type_2_audio_info_sample_type(const audio_sample_typ
     }
 }
 
-static void _convert_audio_info_sample_type_2_sample_type(const CAudioInfo::ESampleType& src_type, audio_sample_type_e& dst_type) {
+static void __convert_audio_info_sample_type_2_sample_type(const CAudioInfo::ESampleType& src_type, audio_sample_type_e& dst_type) {
     switch (src_type) {
     case CAudioInfo::SAMPLE_TYPE_U8:
         dst_type = AUDIO_SAMPLE_TYPE_U8;
@@ -194,7 +194,7 @@ static void _convert_audio_info_sample_type_2_sample_type(const CAudioInfo::ESam
     }
 }
 
-static void _convert_sound_type_2_audio_info_audio_type(const sound_type_e& src_type, CAudioInfo::EAudioType& dst_type) {
+static void __convert_sound_type_2_audio_info_audio_type(const sound_type_e& src_type, CAudioInfo::EAudioType& dst_type) {
     switch (src_type) {
     case SOUND_TYPE_SYSTEM:
         dst_type = CAudioInfo::AUDIO_OUT_TYPE_SYSTEM;
@@ -226,7 +226,7 @@ static void _convert_sound_type_2_audio_info_audio_type(const sound_type_e& src_
     }
 }
 
-static void _convert_audio_info_audio_type_2_sound_type(const CAudioInfo::EAudioType& src_type, sound_type_e& dst_type) {
+static void __convert_audio_info_audio_type_2_sound_type(const CAudioInfo::EAudioType& src_type, sound_type_e& dst_type) {
     switch (src_type) {
     case CAudioInfo::AUDIO_OUT_TYPE_MEDIA:
         dst_type = SOUND_TYPE_MEDIA;
@@ -256,7 +256,7 @@ static void _convert_audio_info_audio_type_2_sound_type(const CAudioInfo::EAudio
     }
 }
 
-static audio_io_state_e _convert_state_type(const CAudioInfo::EAudioIOState src_state) {
+static audio_io_state_e __convert_state_type(const CAudioInfo::EAudioIOState src_state) {
     audio_io_state_e dst_state;
     switch (src_state) {
     case CAudioInfo::AUDIO_IO_STATE_NONE:
@@ -277,8 +277,7 @@ static audio_io_state_e _convert_state_type(const CAudioInfo::EAudioIOState src_
     return dst_state;
 }
 
-static void _check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type)  throw (CAudioError) {
-
+static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type)  throw (CAudioError) {
     if (sample_rate < 0) {
         THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Invalid sample rate :%d", sample_rate);
     }
@@ -292,50 +291,49 @@ static void _check_audio_param(int sample_rate, audio_channel_e channel, audio_s
     }
 }
 
-static void _check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type, sound_type_e sound_type) throw (CAudioError) {
-
-    _check_audio_param(sample_rate, channel, type);
+static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type, sound_type_e sound_type) throw (CAudioError) {
+    __check_audio_param(sample_rate, channel, type);
 
     if (sound_type < SOUND_TYPE_SYSTEM || sound_type > SOUND_TYPE_VOICE) {
         THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Invalid sound type : %d", sound_type);
     }
 }
 
-static CAudioInfo _generate_audio_input_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw (CAudioError) {
+static CAudioInfo __generate_audio_input_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw (CAudioError) {
     CAudioInfo::EChannel     dstChannel;
     CAudioInfo::ESampleType dstSampleType;
     CAudioInfo::EAudioType  dstAudioType = CAudioInfo::AUDIO_IN_TYPE_MEDIA;
 
-    _convert_channel_2_audio_info_channel(channel, dstChannel);
-    _convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
+    __convert_channel_2_audio_info_channel(channel, dstChannel);
+    __convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
 
     return CAudioInfo(sampleRate, dstChannel, dstSampleType, dstAudioType, -1);
 }
 
-static CAudioInfo _generate_audio_input_loopback_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw (CAudioError) {
+static CAudioInfo __generate_audio_input_loopback_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw (CAudioError) {
     CAudioInfo::EChannel     dstChannel;
     CAudioInfo::ESampleType dstSampleType;
     CAudioInfo::EAudioType  dstAudioType = CAudioInfo::AUDIO_IN_TYPE_LOOPBACK;
 
-    _convert_channel_2_audio_info_channel(channel, dstChannel);
-    _convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
+    __convert_channel_2_audio_info_channel(channel, dstChannel);
+    __convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
 
     return CAudioInfo(sampleRate, dstChannel, dstSampleType, dstAudioType, -1);
 }
 
-static CAudioInfo _generate_audio_output_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type, sound_type_e sound_type) throw (CAudioError) {
+static CAudioInfo __generate_audio_output_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type, sound_type_e sound_type) throw (CAudioError) {
     CAudioInfo::EChannel     dstChannel;
     CAudioInfo::ESampleType dstSampleType;
     CAudioInfo::EAudioType  dstAudioType;
 
-    _convert_channel_2_audio_info_channel(channel, dstChannel);
-    _convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
-    _convert_sound_type_2_audio_info_audio_type(sound_type, dstAudioType);
+    __convert_channel_2_audio_info_channel(channel, dstChannel);
+    __convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
+    __convert_sound_type_2_audio_info_audio_type(sound_type, dstAudioType);
 
     return CAudioInfo(sampleRate, dstChannel, dstSampleType, dstAudioType, -1);
 }
 
-static audio_io_interrupted_code_e _convert_interrupted_code(IAudioSessionEventListener::EInterruptCode code) {
+static audio_io_interrupted_code_e __convert_interrupted_code(IAudioSessionEventListener::EInterruptCode code) {
     switch (code) {
     case IAudioSessionEventListener::INTERRUPT_COMPLETED:
         return AUDIO_IO_INTERRUPTED_COMPLETED;
@@ -368,14 +366,14 @@ int cpp_audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_t
             THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
         }
 
-        _check_audio_param(sample_rate, channel, type);
+        __check_audio_param(sample_rate, channel, type);
 
         handle = new audio_io_s;
         if (handle == NULL) {
             THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
         }
 
-        CAudioInfo audioInfo = _generate_audio_input_info(sample_rate, channel, type);
+        CAudioInfo audioInfo = __generate_audio_input_info(sample_rate, channel, type);
 
         handle->audioIoHandle = new CAudioInput(audioInfo);
         if (handle == NULL) {
@@ -398,7 +396,7 @@ int cpp_audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_t
             *input = NULL;
         VALID_POINTER_END
 
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -412,14 +410,14 @@ int cpp_audio_in_create_loopback(int sample_rate, audio_channel_e channel, audio
             THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
         }
 
-        _check_audio_param(sample_rate, channel, type);
+        __check_audio_param(sample_rate, channel, type);
 
         handle = new audio_io_s;
         if (handle == NULL) {
             THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
         }
 
-        CAudioInfo audioInfo = _generate_audio_input_loopback_info(sample_rate, channel, type);
+        CAudioInfo audioInfo = __generate_audio_input_loopback_info(sample_rate, channel, type);
 
         handle->audioIoHandle = new CAudioInput(audioInfo);
         if (handle == NULL) {
@@ -442,7 +440,7 @@ int cpp_audio_in_create_loopback(int sample_rate, audio_channel_e channel, audio
             *input = NULL;
         VALID_POINTER_END
 
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -463,7 +461,7 @@ int cpp_audio_in_destroy(audio_in_h input) {
         SAFE_DELETE(handle);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -496,7 +494,7 @@ int cpp_audio_in_set_stream_info(audio_in_h input, sound_stream_info_h stream_in
         handle->audioIoHandle->getAudioInfo().setAudioIndex(index);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -515,7 +513,7 @@ int cpp_audio_in_prepare(audio_in_h input) {
         handle->audioIoHandle->prepare();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -534,7 +532,7 @@ int cpp_audio_in_unprepare(audio_in_h input) {
         handle->audioIoHandle->unprepare();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -553,7 +551,7 @@ int cpp_audio_in_pause(audio_in_h input) {
         handle->audioIoHandle->pause();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -572,7 +570,7 @@ int cpp_audio_in_resume(audio_in_h input) {
         handle->audioIoHandle->resume();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -591,7 +589,7 @@ int cpp_audio_in_drain(audio_in_h input) {
         handle->audioIoHandle->drain();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -610,7 +608,7 @@ int cpp_audio_in_flush(audio_in_h input) {
         handle->audioIoHandle->flush();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -635,7 +633,7 @@ int cpp_audio_in_read(audio_in_h input, void *buffer, unsigned int length) {
 #endif
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return ret;
@@ -655,7 +653,7 @@ int cpp_audio_in_get_buffer_size(audio_in_h input, int *size) {
         *size = inputHandle->getBufferSize();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -673,7 +671,7 @@ int cpp_audio_in_get_sample_rate(audio_in_h input, int *sample_rate) {
         *sample_rate = handle->audioIoHandle->getAudioInfo().getSampleRate();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -691,12 +689,12 @@ int cpp_audio_in_get_channel(audio_in_h input, audio_channel_e *channel) {
 
         const CAudioInfo::EChannel srcChannel = handle->audioIoHandle->getAudioInfo().getChannel();
         audio_channel_e dstChannel = AUDIO_CHANNEL_MONO;
-        _convert_audio_info_channel_2_channel(srcChannel, dstChannel);
+        __convert_audio_info_channel_2_channel(srcChannel, dstChannel);
 
         *channel = dstChannel;
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -714,20 +712,20 @@ int cpp_audio_in_get_sample_type(audio_in_h input, audio_sample_type_e *type) {
 
         const CAudioInfo::ESampleType srcSampleType = handle->audioIoHandle->getAudioInfo().getSampleType();
         audio_sample_type_e     dstSampleType = AUDIO_SAMPLE_TYPE_U8;
-        _convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType);
+        __convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType);
 
         *type = dstSampleType;
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
 }
 
-static void _interrupt_cb_internal(IAudioSessionEventListener::EInterruptCode _code, void* user_data) {
+static void __interrupt_cb_internal(IAudioSessionEventListener::EInterruptCode _code, void* user_data) {
     audio_io_s* handle = static_cast<audio_io_s*>(user_data);
-    audio_io_interrupted_code_e code = _convert_interrupted_code(_code);
+    audio_io_interrupted_code_e code = __convert_interrupted_code(_code);
 
     assert(handle);
 
@@ -751,12 +749,12 @@ int cpp_audio_in_set_interrupted_cb(audio_in_h input, audio_io_interrupted_cb ca
 
         CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
         cb.mUserData   = static_cast<void*>(handle);
-        cb.onInterrupt = _interrupt_cb_internal;
+        cb.onInterrupt = __interrupt_cb_internal;
 
         handle->audioIoHandle->setInterruptCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -782,7 +780,7 @@ int cpp_audio_in_unset_interrupted_cb(audio_in_h input) {
         handle->audioIoHandle->setInterruptCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -805,13 +803,13 @@ int cpp_audio_in_ignore_session(audio_in_h input) {
         handle->audioIoHandle->ignoreSession();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
 }
 
-static void _stream_cb_internal(size_t nbytes, void *user_data) {
+static void __stream_cb_internal(size_t nbytes, void *user_data) {
     audio_io_s* audioIo = static_cast<audio_io_s*>(user_data);
     assert(audioIo);
 
@@ -820,12 +818,12 @@ static void _stream_cb_internal(size_t nbytes, void *user_data) {
     }
 }
 
-static void _state_changed_cb_internal(CAudioInfo::EAudioIOState state, CAudioInfo::EAudioIOState state_prev, bool by_policy, void *user_data) {
+static void __state_changed_cb_internal(CAudioInfo::EAudioIOState state, CAudioInfo::EAudioIOState state_prev, bool by_policy, void *user_data) {
     audio_io_s* audioIo = static_cast<audio_io_s*>(user_data);
     assert(audioIo);
 
     if (audioIo->state_changed_callback.onStateChanged != NULL) {
-        audioIo->state_changed_callback.onStateChanged(audioIo, _convert_state_type(state_prev), _convert_state_type(state), by_policy, audioIo->state_changed_callback.user_data);
+        audioIo->state_changed_callback.onStateChanged(audioIo, __convert_state_type(state_prev), __convert_state_type(state), by_policy, audioIo->state_changed_callback.user_data);
     }
 }
 
@@ -844,12 +842,12 @@ int cpp_audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, vo
 
         CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback();
         cb.mUserData = static_cast<void*>(handle);
-        cb.onStream  = _stream_cb_internal;
+        cb.onStream  = __stream_cb_internal;
 
         handle->audioIoHandle->setStreamCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -875,7 +873,7 @@ int cpp_audio_in_unset_stream_cb(audio_in_h input) {
         handle->audioIoHandle->setStreamCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -883,6 +881,7 @@ int cpp_audio_in_unset_stream_cb(audio_in_h input) {
 
 int cpp_audio_in_peek(audio_in_h input, const void **buffer, unsigned int *length) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
+    size_t _length = 0;
 
     try {
         if (handle == NULL || buffer == NULL) {
@@ -892,12 +891,14 @@ int cpp_audio_in_peek(audio_in_h input, const void **buffer, unsigned int *lengt
         CAudioInput* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
         assert(inputHandle);
 
-        inputHandle->peek(buffer, (size_t*)length);
+        inputHandle->peek(buffer, &_length);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
+    *length = (unsigned int)_length;
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -915,7 +916,7 @@ int cpp_audio_in_drop(audio_in_h input) {
         inputHandle->drop();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -936,12 +937,12 @@ int cpp_audio_in_set_state_changed_cb(audio_in_h input, audio_in_state_changed_c
 
         CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback();
         cb.mUserData = static_cast<void*>(handle);
-        cb.onStateChanged = _state_changed_cb_internal;
+        cb.onStateChanged = __state_changed_cb_internal;
 
         handle->audioIoHandle->setStateChangedCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -967,7 +968,7 @@ int cpp_audio_in_unset_state_changed_cb(audio_in_h input) {
         handle->audioIoHandle->setStateChangedCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -984,14 +985,14 @@ int cpp_audio_out_create(int sample_rate, audio_channel_e channel, audio_sample_
             THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
         }
 
-        _check_audio_param(sample_rate, channel, type, sound_type);
+        __check_audio_param(sample_rate, channel, type, sound_type);
 
         handle = new audio_io_s;
         if (handle == NULL) {
             THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
         }
 
-        CAudioInfo audioInfo = _generate_audio_output_info(sample_rate, channel, type, sound_type);
+        CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, sound_type);
 
         handle->audioIoHandle = new CAudioOutput(audioInfo);
         if (handle == NULL) {
@@ -1014,7 +1015,7 @@ int cpp_audio_out_create(int sample_rate, audio_channel_e channel, audio_sample_
             *output = NULL;
         VALID_POINTER_END
 
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1027,14 +1028,14 @@ int cpp_audio_out_create_new(int sample_rate, audio_channel_e channel, audio_sam
             THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
         }
 
-        _check_audio_param(sample_rate, channel, type, SOUND_TYPE_SYSTEM /*default check */);
+        __check_audio_param(sample_rate, channel, type, SOUND_TYPE_SYSTEM /*default check */);
 
         handle = new audio_io_s;
         if (handle == NULL) {
             THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
         }
 
-        CAudioInfo audioInfo = _generate_audio_output_info(sample_rate, channel, type, SOUND_TYPE_MEDIA /* default sound_type */);
+        CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, SOUND_TYPE_MEDIA /* default sound_type */);
 
         handle->audioIoHandle = new CAudioOutput(audioInfo);
         if (handle == NULL) {
@@ -1057,7 +1058,7 @@ int cpp_audio_out_create_new(int sample_rate, audio_channel_e channel, audio_sam
             *output = NULL;
         VALID_POINTER_END
 
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1078,7 +1079,7 @@ int cpp_audio_out_destroy(audio_out_h output) {
         SAFE_DELETE(handle);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1111,7 +1112,7 @@ int cpp_audio_out_set_stream_info(audio_out_h output, sound_stream_info_h stream
         handle->audioIoHandle->getAudioInfo().setAudioIndex(index);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1130,7 +1131,7 @@ int cpp_audio_out_prepare(audio_out_h output) {
         handle->audioIoHandle->prepare();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1149,7 +1150,7 @@ int cpp_audio_out_unprepare(audio_out_h output) {
         handle->audioIoHandle->unprepare();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1168,7 +1169,7 @@ int cpp_audio_out_pause(audio_out_h output) {
         handle->audioIoHandle->pause();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1187,7 +1188,7 @@ int cpp_audio_out_resume(audio_out_h output) {
         handle->audioIoHandle->resume();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1206,7 +1207,7 @@ int cpp_audio_out_drain(audio_out_h output) {
         handle->audioIoHandle->drain();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1225,7 +1226,7 @@ int cpp_audio_out_flush(audio_out_h output) {
         handle->audioIoHandle->flush();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1250,7 +1251,7 @@ int cpp_audio_out_write(audio_out_h output, void *buffer, unsigned int length) {
 #endif
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return ret;
@@ -1270,7 +1271,7 @@ int cpp_audio_out_get_buffer_size(audio_out_h output, int *size) {
         *size = outputHandle->getBufferSize();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1288,7 +1289,7 @@ int cpp_audio_out_get_sample_rate(audio_out_h output, int *sample_rate) {
         *sample_rate = handle->audioIoHandle->getAudioInfo().getSampleRate();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1306,12 +1307,12 @@ int cpp_audio_out_get_channel(audio_out_h output, audio_channel_e *channel) {
 
         const CAudioInfo::EChannel srcChannel = handle->audioIoHandle->getAudioInfo().getChannel();
         audio_channel_e dstChannel = AUDIO_CHANNEL_MONO;
-        _convert_audio_info_channel_2_channel(srcChannel, dstChannel);
+        __convert_audio_info_channel_2_channel(srcChannel, dstChannel);
 
         *channel = dstChannel;
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1329,12 +1330,12 @@ int cpp_audio_out_get_sample_type(audio_out_h output, audio_sample_type_e *type)
 
         const CAudioInfo::ESampleType srcSampleType = handle->audioIoHandle->getAudioInfo().getSampleType();
         audio_sample_type_e     dstSampleType = AUDIO_SAMPLE_TYPE_U8;
-        _convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType);
+        __convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType);
 
         *type = dstSampleType;
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1352,12 +1353,12 @@ int cpp_audio_out_get_sound_type(audio_out_h output, sound_type_e *type) {
 
         const CAudioInfo::EAudioType srcAudioType = handle->audioIoHandle->getAudioInfo().getAudioType();
         sound_type_e                 dstSoundType = SOUND_TYPE_MEDIA;
-        _convert_audio_info_audio_type_2_sound_type(srcAudioType, dstSoundType);
+        __convert_audio_info_audio_type_2_sound_type(srcAudioType, dstSoundType);
 
         *type = dstSoundType;
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1378,12 +1379,12 @@ int cpp_audio_out_set_interrupted_cb(audio_out_h output, audio_io_interrupted_cb
 
         CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
         cb.mUserData   = static_cast<void*>(handle);
-        cb.onInterrupt = _interrupt_cb_internal;
+        cb.onInterrupt = __interrupt_cb_internal;
 
         handle->audioIoHandle->setInterruptCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1409,7 +1410,7 @@ int cpp_audio_out_unset_interrupted_cb(audio_out_h output) {
         handle->audioIoHandle->setInterruptCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1432,7 +1433,7 @@ int cpp_audio_out_ignore_session(audio_out_h output) {
         handle->audioIoHandle->ignoreSession();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1453,12 +1454,12 @@ int cpp_audio_out_set_stream_cb(audio_out_h output, audio_out_stream_cb callback
 
         CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback();
         cb.mUserData = static_cast<void*>(handle);
-        cb.onStream  = _stream_cb_internal;
+        cb.onStream  = __stream_cb_internal;
 
         handle->audioIoHandle->setStreamCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1484,7 +1485,7 @@ int cpp_audio_out_unset_stream_cb(audio_out_h output) {
         handle->audioIoHandle->setStreamCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1505,12 +1506,12 @@ int cpp_audio_out_set_state_changed_cb(audio_out_h output, audio_in_state_change
 
         CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback();
         cb.mUserData = static_cast<void*>(handle);
-        cb.onStateChanged = _state_changed_cb_internal;
+        cb.onStateChanged = __state_changed_cb_internal;
 
         handle->audioIoHandle->setStateChangedCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1536,7 +1537,7 @@ int cpp_audio_out_unset_state_changed_cb(audio_out_h output) {
         handle->audioIoHandle->setStateChangedCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;

diff --git a/test/audio_io_test.c b/test/audio_io_test.c
index 548a9bc..ad97bdd 100644 (file)
--- a/test/audio_io_test.c
+++ b/test/audio_io_test.c
@@ -19,8 +19,8 @@
 #include <string.h>
 #include <unistd.h>
 #include <math.h>
-#include <audio_io.h>
 #include <sound_manager.h>
+#include <audio_io.h>
 
 //#define _NEW_SOUND_MANAGER_API_
 #define _SESSION_SOUND_MANAGER_API_
@@ -85,7 +85,7 @@ void play_file_sample(char *file, int frequency, int ch, int type)
     int buffer_size = 0;
     char * buf = NULL;
 
-    if(ch < 0 || ch > 2) {
+    if (ch < 0 || ch > 2) {
         ch = 0;
     }
 
@@ -193,7 +193,7 @@ int audio_io_loopback_in_test()
     audio_in_h input;
     FILE* fp = fopen ("/tmp/dump_test.raw", "wb+");
 
-    if(fp == NULL) {
+    if (fp == NULL) {
         printf("open failed \n");
         return 0;
     }
@@ -212,12 +212,12 @@ int audio_io_loopback_in_test()
         }
 
         ret = audio_in_get_buffer_size(input, &size);
-        if(ret != AUDIO_IO_ERROR_NONE) {
+        if (ret != AUDIO_IO_ERROR_NONE) {
             printf ("audio_in_get_buffer_size failed.\n");
             goto exit;
         }
 
-        while(1) {
+        while (1) {
             char *buffer = alloca(size);
             if ((ret = audio_in_read(input, (void*)buffer, size)) > AUDIO_IO_ERROR_NONE) {
                 fwrite (buffer, size, sizeof(char), fp);
@@ -245,14 +245,14 @@ int audio_io_loopback_test()
     char *buffer = NULL;
 
     ret = audio_in_create(16000, AUDIO_CHANNEL_MONO , AUDIO_SAMPLE_TYPE_S16_LE, &input);
-    if(ret != AUDIO_IO_ERROR_NONE) {
+    if (ret != AUDIO_IO_ERROR_NONE) {
         printf ("audio_in_create_ex failed. \n");
         return 0;
     }
 
     //ret = audio_out_create(16000, AUDIO_CHANNEL_MONO , AUDIO_SAMPLE_TYPE_S16_LE, SOUND_TYPE_CALL, &output);
     ret = audio_out_create_new(16000, AUDIO_CHANNEL_MONO , AUDIO_SAMPLE_TYPE_S16_LE, &output);
-    if(ret != AUDIO_IO_ERROR_NONE) {
+    if (ret != AUDIO_IO_ERROR_NONE) {
         printf ("audio_out_create failed. \n");
         return 0;
     }
@@ -264,7 +264,7 @@ int audio_io_loopback_test()
         return 0;
     } else {
         ret = audio_in_get_buffer_size(input, &size);
-        if(ret != AUDIO_IO_ERROR_NONE) {
+        if (ret != AUDIO_IO_ERROR_NONE) {
             printf ("audio_in_get_buffer_size failed.\n");
             return 0;
         } else {
@@ -280,16 +280,16 @@ int audio_io_loopback_test()
         return 0;
     }
 
-    if(buffer == NULL) {
+    if (buffer == NULL) {
         printf("buffer is null\n");
         return 0;
     }
 
-    while(1) {
+    while (1) {
         ret = audio_in_read(input, (void*)buffer, size);
-        if(ret > AUDIO_IO_ERROR_NONE) {
+        if (ret > AUDIO_IO_ERROR_NONE) {
             ret = audio_out_write(output, buffer, size);
-            if(ret > AUDIO_IO_ERROR_NONE) {
+            if (ret > AUDIO_IO_ERROR_NONE) {
                 printf("audio read/write success. buffer(%p), size(%d)\n", buffer, size);
             } else {
                 printf("audio read success, write failed. buffer(%p), size(%d)\n", buffer, size);
@@ -388,18 +388,18 @@ static void _audio_io_stream_write_cb (audio_out_h handle, size_t nbytes, void *
         }
         memset (buffer, 0, nbytes);
 
-        for(i=0; i<nbytes/2; i+=2)
+        for (i=0; i<nbytes/2; i+=2)
         {
             buffer[i]   = (short) 32768 * test_wav.sine[test_wav.left_channel];   /* left */
             buffer[i+1] = (short) 32768 * test_wav.sine[test_wav.right_channel];  /* right */
             test_wav.left_channel += 1;
-            if( test_wav.left_channel >= TABLE_SIZE ) test_wav.left_channel -= TABLE_SIZE;
+            if (test_wav.left_channel >= TABLE_SIZE) test_wav.left_channel -= TABLE_SIZE;
             test_wav.right_channel += 3;
-            if( test_wav.right_channel >= TABLE_SIZE ) test_wav.right_channel -= TABLE_SIZE;
+            if (test_wav.right_channel >= TABLE_SIZE) test_wav.right_channel -= TABLE_SIZE;
         }
 
         ret = audio_out_write(handle, buffer, nbytes);
-        if(ret > AUDIO_IO_ERROR_NONE) {
+        if (ret > AUDIO_IO_ERROR_NONE) {
             //printf("audio write success. buffer(%p), nbytes(%d)\n", buffer, nbytes);
         }
 
@@ -421,28 +421,28 @@ int _convert_cmd_and_run(char cmd, int mode) {
     int ret = 0;
     switch (cmd) {
         case 'P':
-            if(mode & 0x01)  ret = audio_out_prepare(output);
-            if(mode & 0x02)  ret = audio_in_prepare(input);
+            if (mode & 0x01)  ret = audio_out_prepare(output);
+            if (mode & 0x02)  ret = audio_in_prepare(input);
             break;
         case 'u':
-            if(mode & 0x01)  ret = audio_out_unprepare(output);
-            if(mode & 0x02)  ret = audio_in_unprepare(input);
+            if (mode & 0x01)  ret = audio_out_unprepare(output);
+            if (mode & 0x02)  ret = audio_in_unprepare(input);
             break;
         case 'p':
-            if(mode & 0x01)  ret = audio_out_pause(output);
-            if(mode & 0x02)  ret = audio_in_pause(input);
+            if (mode & 0x01)  ret = audio_out_pause(output);
+            if (mode & 0x02)  ret = audio_in_pause(input);
             break;
         case 'r':
-            if(mode & 0x01)  ret = audio_out_resume(output);
-            if(mode & 0x02)  ret = audio_in_resume(input);
+            if (mode & 0x01)  ret = audio_out_resume(output);
+            if (mode & 0x02)  ret = audio_in_resume(input);
             break;
         case 'd':
-            if(mode & 0x01)  ret = audio_out_drain(output);
-            //if(mode & 0x02)  ret = audio_in_drain(input);
+            if (mode & 0x01)  ret = audio_out_drain(output);
+            //if (mode & 0x02)  ret = audio_in_drain(input);
             break;
         case 'f':
-            if(mode & 0x01)  ret = audio_out_flush(output);
-            if(mode & 0x02)  ret = audio_in_flush(input);
+            if (mode & 0x01)  ret = audio_out_flush(output);
+            if (mode & 0x02)  ret = audio_in_flush(input);
             break;
         case 'i':
 #ifdef _NEW_SOUND_MANAGER_API_
@@ -484,7 +484,7 @@ int audio_io_async_test(int mode)
     int write_mode = (mode & 0x01);
     int read_mode = (mode & 0x02);
 
-    if((write_mode == 0) && (read_mode == 0)) {
+    if ((write_mode == 0) && (read_mode == 0)) {
         printf ("not vaild mode.\n");
         return 0;
     }
@@ -507,21 +507,21 @@ int audio_io_async_test(int mode)
 
         printf ("audio_in_create\n");
         ret = audio_in_create(44100, AUDIO_CHANNEL_STEREO , AUDIO_SAMPLE_TYPE_S16_LE, &input);
-        if(ret != AUDIO_IO_ERROR_NONE) {
+        if (ret != AUDIO_IO_ERROR_NONE) {
             printf ("audio_in_create_ex failed. \n");
             return 0;
         }
         printf ("audio_in_create success!!! [%p]\n", input);
 
         ret = audio_in_set_stream_cb(input, _audio_io_stream_read_cb, NULL);
-        if(ret != AUDIO_IO_ERROR_NONE) {
+        if (ret != AUDIO_IO_ERROR_NONE) {
             printf ("audio_in_set_stream_cb failed. \n");
             return 0;
         }
         printf ("audio_in_set_stream_cb success!!! [%p]\n", input);
 
         ret = audio_in_set_state_changed_cb(input, _audio_in_state_cb, NULL);
-        if(ret != AUDIO_IO_ERROR_NONE) {
+        if (ret != AUDIO_IO_ERROR_NONE) {
             printf ("audio_out_set_state_changed_cb failed. \n");
             return 0;
         }
@@ -562,21 +562,21 @@ int audio_io_async_test(int mode)
         printf ("audio_out_create\n");
         //ret = audio_out_create(44100, AUDIO_CHANNEL_STEREO , AUDIO_SAMPLE_TYPE_S16_LE, SOUND_TYPE_MEDIA, &output);
         ret = audio_out_create_new(44100, AUDIO_CHANNEL_STEREO , AUDIO_SAMPLE_TYPE_S16_LE, &output);
-        if(ret != AUDIO_IO_ERROR_NONE) {
+        if (ret != AUDIO_IO_ERROR_NONE) {
             printf ("audio_out_create failed. \n");
             return 0;
         }
         printf ("audio_out_create success!!! [%p]\n", output);
 
         ret = audio_out_set_stream_cb(output, _audio_io_stream_write_cb, NULL);
-        if(ret != AUDIO_IO_ERROR_NONE) {
+        if (ret != AUDIO_IO_ERROR_NONE) {
             printf ("audio_out_set_stream_cb failed. \n");
             return 0;
         }
         printf ("audio_out_set_stream_cb success!!! [%p]\n", output);
 
         ret = audio_out_set_state_changed_cb(output, _audio_out_state_cb, NULL);
-        if(ret != AUDIO_IO_ERROR_NONE) {
+        if (ret != AUDIO_IO_ERROR_NONE) {
             printf ("audio_out_set_state_changed_cb failed. \n");
             return 0;
         }
@@ -594,7 +594,7 @@ int audio_io_async_test(int mode)
         ret = audio_out_set_interrupted_cb(output, interrupted_callback_write, NULL);
 
         //generate wave data
-        for(i=0; i<TABLE_SIZE; i++) {
+        for (i=0; i<TABLE_SIZE; i++) {
             test_wav.sine[i] = 0.9 * (float) sin( ((double)i/(double)TABLE_SIZE) * M_PI * 2. );
         }
         test_wav.left_channel = test_wav.right_channel = 0;
@@ -611,7 +611,7 @@ int audio_io_async_test(int mode)
             return 0;
         } else {
             ret = audio_in_get_buffer_size(input, &size);
-            if(ret != AUDIO_IO_ERROR_NONE) {
+            if (ret != AUDIO_IO_ERROR_NONE) {
                 printf ("audio_in_get_buffer_size failed.\n");
                 return 0;
             } else {
@@ -620,7 +620,7 @@ int audio_io_async_test(int mode)
             }
         }
 
-        if(buffer == NULL) {
+        if (buffer == NULL) {
             printf("buffer is null\n");
             return 0;
         }
@@ -641,7 +641,7 @@ int audio_io_async_test(int mode)
     do {
         printf ("command(q:quit) : ");
         cmd = (char) getchar();
-        if(cmd != '\n')  getchar();
+        if (cmd != '\n')  getchar();
         cmd_ret = _convert_cmd_and_run(cmd, mode);
         printf ("  - result code : %d\n", cmd_ret);
     } while (cmd != 'q');