Cleanup code

[Version] 0.3.61
[Profile] Common
[Issue Type] Cleanup

Change-Id: I9d45df442e268d33c02bd6acefa94265138f03f9

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8200dcea8269fa61705ddb2346e8373c40fe37cc..1dcb532f26937e12eb53e64418797b99ce8ee44e 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -9,7 +9,7 @@ SET(PREFIX ${CMAKE_INSTALL_PREFIX})
 SET(INC_DIR include)
 INCLUDE_DIRECTORIES(${INC_DIR})
 
-SET(dependents "dlog mm-sound capi-base-common capi-media-sound-manager mm-common mm-session libpulse vconf dpm capi-system-info")
+SET(dependents "dlog mm-sound capi-base-common capi-media-sound-manager mm-common mm-session libpulse dpm capi-system-info")
 SET(pc_dependents "capi-base-common capi-media-sound-manager")
 
 INCLUDE(FindPkgConfig)

diff --git a/include/CAudioError.h b/include/CAudioError.h
index 43ec587bfd775aa585e215d60bd22c5c1cee77f4..2b5fae90ce09fc8b4a1919273e9eec49c06a1df3 100644 (file)
--- a/include/CAudioError.h
+++ b/include/CAudioError.h
@@ -102,4 +102,4 @@ namespace tizen_media_audio {
 } /* namespace tizen_media_audio */
 
 #endif
-#endif /* __TIZEN_MEDIA_CPP_OBJECTS_IO_H__ */
+#endif /* __TIZEN_MEDIA_AUDIO_IO_CAUDIOERROR_H__ */

diff --git a/include/CAudioIODef.h b/include/CAudioIODef.h
index 404e6833375525152857f8257b1a8000516415ae..71ef83a454cf55c10fcb55edf75d07dda6883d61 100644 (file)
--- a/include/CAudioIODef.h
+++ b/include/CAudioIODef.h
@@ -23,7 +23,6 @@
 
 #include <stdio.h>
 #include <dlog.h>
-#include <vconf.h>
 
 #include "CAudioError.h"
 #include "CAudioInfo.h"

diff --git a/include/CAudioInput.h b/include/CAudioInput.h
index 3511a679f4978cd457aacc3f797ead56620369f4..7ec61e8d82b45c5336e36de0db2f2fcb289d8467 100644 (file)
--- a/include/CAudioInput.h
+++ b/include/CAudioInput.h
@@ -40,7 +40,9 @@ namespace tizen_media_audio {
 
         /* Overridden Handler */
         virtual void onStream(CPulseAudioClient* pClient, size_t length);
-        virtual void onInterrupt(CAudioSessionHandler* pHandler, int id, mm_sound_focus_type_e focus_type, mm_sound_focus_state_e state, const char *reason_for_change, const char *additional_info);
+        virtual void onInterrupt(CAudioSessionHandler* pHandler, int id,
+                                 mm_sound_focus_type_e focus_type, mm_sound_focus_state_e state,
+                                 const char *reason_for_change, const char *additional_info);
         virtual void onSignal(CAudioSessionHandler* pHandler, mm_sound_signal_name_t signal, int value);
 
         /* Implemented Methods */

diff --git a/packaging/capi-media-audio-io.spec b/packaging/capi-media-audio-io.spec
index 35d8af105fda9df97d4230ccfb05fccd4f296899..365e90918a297f201d52805a3ee364ec50193018 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.60
+Version:        0.3.61
 Release:        0
 Group:          Multimedia/API
 License:        Apache-2.0
@@ -11,7 +11,6 @@ BuildRequires:  pkgconfig(dlog)
 BuildRequires:  pkgconfig(mm-common)
 BuildRequires:  pkgconfig(mm-session)
 BuildRequires:  pkgconfig(mm-sound)
-BuildRequires:  pkgconfig(vconf)
 BuildRequires:  pkgconfig(capi-media-sound-manager)
 BuildRequires:  pkgconfig(capi-base-common)
 BuildRequires:  pkgconfig(libpulse)

diff --git a/src/cpp/CAudioInput.cpp b/src/cpp/CAudioInput.cpp
index 9ef53dd7f5f4a034007a98be5d0535cceb676ba0..1e0c59370ae3bc783151bfdfa20ae39026d8fb9b 100644 (file)
--- a/src/cpp/CAudioInput.cpp
+++ b/src/cpp/CAudioInput.cpp
@@ -74,9 +74,11 @@ void CAudioInput::onStream(CPulseAudioClient* pClient, size_t length) {
     CAudioIO::onStream(pClient, length);
 }
 
-void CAudioInput::onInterrupt(CAudioSessionHandler* pHandler, 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 CAudioInput::onInterrupt(CAudioSessionHandler* pHandler, int id, mm_sound_focus_type_e focus_type,
+                              mm_sound_focus_state_e state, const char *reason_for_change, const char *additional_info) {
     assert(pHandler);
-    AUDIO_IO_LOGD("[pHandler:0x%x], [focus_type:%d], [state:%d], [reason_for_change:%s], [additional_info:%s]", pHandler, focus_type, state, reason_for_change, additional_info);
+    AUDIO_IO_LOGD("[pHandler:0x%x], [focus_type:%d], [state:%d], [reason_for_change:%s], [additional_info:%s]",
+                   pHandler, focus_type, state, reason_for_change, additional_info);
     CAudioIO::onInterrupt(pHandler, id, focus_type, state, reason_for_change, additional_info);
 }
 
@@ -169,7 +171,8 @@ static bool __IsPrivilegeAllowed() {
         if (!PA_CONTEXT_IS_GOOD(state)) {
             err = pa_context_errno(c);
             pa_threaded_mainloop_unlock(prData.paMainloop);
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, "pa_context's state is not good : err[%d]", err);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION,
+                                   "pa_context's state is not good : err[%d]", err);
         }
 
         /* Wait until the context is ready */
@@ -252,7 +255,8 @@ void CAudioInput::prepare() throw(CAudioError) {
         // Check to invalid AudioType
         CAudioInfo::EAudioType audioType = mAudioInfo.getAudioType();
         if (audioType < CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA || audioType > CAudioInfo::EAudioType::AUDIO_IN_TYPE_LOOPBACK) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "The audioType is invalid [type:%d]", static_cast<int>(audioType));
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "The audioType is invalid [type:%d]", static_cast<int>(audioType));
         }
 
         if (mpAudioSessionHandler->getId() < 0) {  // Did not registerSound()
@@ -272,7 +276,8 @@ void CAudioInput::prepare() throw(CAudioError) {
         // Create PulseAudio Handler
         mpPulseAudioClient = new CPulseAudioClient(CPulseAudioClient::EStreamDirection::STREAM_DIRECTION_RECORD, spec, this);
         if (mpPulseAudioClient == NULL) {
-            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to allocate CPulseAudioClient object");
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY,
+                            "Failed to allocate CPulseAudioClient object");
         }
 
         // Initialize PulseAudio Handler
@@ -295,7 +300,8 @@ void CAudioInput::prepare() throw(CAudioError) {
 
 void CAudioInput::unprepare() throw(CAudioError) {
     if (__IsInit() == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput");
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
+                        "Did not initialize CAudioInput");
     }
 
     if (__IsReady() == false) {
@@ -335,7 +341,8 @@ void CAudioInput::unprepare() throw(CAudioError) {
 
 void CAudioInput::pause() throw(CAudioError) {
     if (__IsInit() == false || __IsReady() == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput");
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
+                        "Did not initialize or prepare CAudioInput");
     }
 
     if (CAudioIO::getState() != CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING) {
@@ -368,7 +375,8 @@ void CAudioInput::pause() throw(CAudioError) {
 
 void CAudioInput::resume() throw(CAudioError) {
     if (__IsInit() == false || __IsReady() == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput");
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
+                        "Did not initialize or prepare CAudioInput");
     }
 
     if (CAudioIO::getState() != CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED) {
@@ -405,7 +413,8 @@ void CAudioInput::drain() throw(CAudioError) {
 
 void CAudioInput::flush() throw(CAudioError) {
     if (__IsInit() == false || __IsReady() == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput");
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
+                        "Did not initialize or prepare CAudioInput");
     }
 
     try {
@@ -442,11 +451,12 @@ void CAudioInput::setStreamCallback(SStreamCallback callback) throw(CAudioError)
 
 size_t CAudioInput::read(void* buffer, size_t length) throw(CAudioError) {
     if (__IsInit() == false || __IsReady() == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput");
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
+                        "Did not initialize or prepare CAudioInput");
     }
-
     if (buffer == NULL) {
-        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL buffer:%p", buffer);
+        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                               "Parameters are NULL buffer:%p", buffer);
     }
     if (CAudioIO::getState() != CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
@@ -454,7 +464,8 @@ size_t CAudioInput::read(void* buffer, size_t length) throw(CAudioError) {
     }
     /* Checks synchronous flag */
     if (__mIsUsedSyncRead == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION, "Invalid operation of read() if receive stream callback");
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
+                        "Invalid operation of read() if receive stream callback");
     }
 
     int ret = 0;
@@ -464,7 +475,8 @@ size_t CAudioInput::read(void* buffer, size_t length) throw(CAudioError) {
 
         // If another thread did call unprepare, do not read
         if (mpPulseAudioClient == NULL)
-            THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
+                            "Did not initialize CPulseAudioClient");
 
         // Block until read done
         ret = mpPulseAudioClient->read(buffer, length);
@@ -480,16 +492,19 @@ size_t CAudioInput::read(void* buffer, size_t length) throw(CAudioError) {
 
 int CAudioInput::peek(const void** buffer, size_t* length) throw(CAudioError) {
     if (__IsInit() == false || __IsReady() == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput");
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
+                        "Did not initialize or prepare CAudioInput");
     }
 
     if (buffer == NULL || length == NULL) {
-        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL buffer:%p, length:%p", buffer, length);
+        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                               "Parameters are NULL buffer:%p, length:%p", buffer, length);
     }
 
     /* Checks synchronous flag */
     if (__mIsUsedSyncRead == true) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION, "Invalid operation of peek() if does not receive a stream callback");
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
+                        "Invalid operation of peek() if does not receive a stream callback");
     }
 
     int ret = 0;
@@ -505,12 +520,14 @@ int CAudioInput::peek(const void** buffer, size_t* length) throw(CAudioError) {
 
 int CAudioInput::drop() throw(CAudioError) {
     if (__IsInit() == false || __IsReady() == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioInput");
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
+                        "Did not initialize or prepare CAudioInput");
     }
 
     /* Checks synchronous flag */
     if (__mIsUsedSyncRead == true) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION, "Invalid operation of drop() if does not receive a stream callback");
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
+                        "Invalid operation of drop() if does not receive a stream callback");
     }
 
     int ret = 0;

diff --git a/src/cpp/CAudioOutput.cpp b/src/cpp/CAudioOutput.cpp
index 5a44bd929557df17cf3c5004c63e50406fb1548a..e6a7d94dcbdbd01d7a3dbf25e9ff9fcdd4a49912 100644 (file)
--- a/src/cpp/CAudioOutput.cpp
+++ b/src/cpp/CAudioOutput.cpp
@@ -15,7 +15,6 @@
  */
 
 
-#include <vconf.h>
 #include "CAudioIODef.h"
 
 using namespace std;
@@ -67,9 +66,11 @@ void CAudioOutput::onStream(CPulseAudioClient* pClient, size_t length) {
     CAudioIO::onStream(pClient, length);
 }
 
-void CAudioOutput::onInterrupt(CAudioSessionHandler* pHandler, 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 CAudioOutput::onInterrupt(CAudioSessionHandler* pHandler, int id, mm_sound_focus_type_e focus_type,
+                               mm_sound_focus_state_e state, const char *reason_for_change, const char *additional_info) {
     assert(pHandler);
-    AUDIO_IO_LOGD("[pHandler:0x%x], [focus_type:%d], [state:%d], [reason_for_change:%s], [additional_info:%s]", pHandler, focus_type, state, reason_for_change, additional_info);
+    AUDIO_IO_LOGD("[pHandler:0x%x], [focus_type:%d], [state:%d], [reason_for_change:%s], [additional_info:%s]",
+                   pHandler, focus_type, state, reason_for_change, additional_info);
     CAudioIO::onInterrupt(pHandler, id, focus_type, state, reason_for_change, additional_info);
 }
 
@@ -102,7 +103,8 @@ void CAudioOutput::initialize() throw(CAudioError) {
         // Create ASM Handler
         mpAudioSessionHandler = new CAudioSessionHandler(CAudioSessionHandler::EAudioSessionType::AUDIO_SESSION_TYPE_PLAYBACK, mAudioInfo, this);
         if (mpAudioSessionHandler == NULL) {
-            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to allocate CAudioSessionHandler object");
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY,
+                            "Failed to allocate CAudioSessionHandler object");
         }
 
         // Initialize ASM Handler
@@ -146,7 +148,8 @@ void CAudioOutput::prepare() throw(CAudioError) {
         // Check to invalid AudioType
         CAudioInfo::EAudioType audioType = mAudioInfo.getAudioType();
         if (audioType < CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA || audioType >= CAudioInfo::EAudioType::AUDIO_TYPE_MAX) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "The audioType is invalid [type:%d]", static_cast<int>(audioType));
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "The audioType is invalid [type:%d]", static_cast<int>(audioType));
         }
 
         if (mpAudioSessionHandler->getId() < 0) {  // Did not registerSound()
@@ -165,13 +168,15 @@ void CAudioOutput::prepare() throw(CAudioError) {
         // Create PulseAudio Handler
         mpPulseAudioClient = new CPulseAudioClient(CPulseAudioClient::EStreamDirection::STREAM_DIRECTION_PLAYBACK, spec, this);
         if (mpPulseAudioClient == NULL) {
-            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to allocate CPulseAudioClient object");
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY,
+                            "Failed to allocate CPulseAudioClient object");
         }
 
         // Initialize PulseAudio Handler
         mpPulseAudioClient->initialize();
 
-        if (isForceIgnore() == false && mpAudioSessionHandler->isSkipSessionEvent() == false) {
+        if (isForceIgnore() == false &&
+            mpAudioSessionHandler->isSkipSessionEvent() == false) {
             /* Updates ASM to PLAYING */
             mpAudioSessionHandler->updatePlaying();
         }
@@ -187,7 +192,8 @@ void CAudioOutput::prepare() throw(CAudioError) {
 
 void CAudioOutput::unprepare() throw(CAudioError) {
     if (__IsInit() == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioOutput");
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
+                        "Did not initialize CAudioOutput");
     }
 
     if (__IsReady() == false) {
@@ -205,7 +211,8 @@ void CAudioOutput::unprepare() throw(CAudioError) {
 
         if (mpAudioSessionHandler->getId() >= 0) {
             /* Updates ASM to STOP */
-            if (isForceIgnore() == false && mpAudioSessionHandler->isSkipSessionEvent() == false) {
+            if (isForceIgnore() == false &&
+                mpAudioSessionHandler->isSkipSessionEvent() == false) {
                 mpAudioSessionHandler->updateStop();
             }
 
@@ -226,7 +233,8 @@ void CAudioOutput::unprepare() throw(CAudioError) {
 
 void CAudioOutput::pause() throw(CAudioError) {
     if (__IsInit() == false || __IsReady() == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput");
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
+                        "Did not initialize or prepare CAudioOutput");
     }
 
     if (CAudioIO::getState() != CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING) {
@@ -244,7 +252,8 @@ void CAudioOutput::pause() throw(CAudioError) {
         internalLock();
 
         /* Updates ASM to STOP */
-        if (isForceIgnore() == false && mpAudioSessionHandler->isSkipSessionEvent() == false) {
+        if (isForceIgnore() == false &&
+            mpAudioSessionHandler->isSkipSessionEvent() == false) {
             mpAudioSessionHandler->updateStop();
         }
 
@@ -259,7 +268,8 @@ void CAudioOutput::pause() throw(CAudioError) {
 
 void CAudioOutput::resume() throw(CAudioError) {
     if (__IsInit() == false || __IsReady() == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput");
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
+                        "Did not initialize or prepare CAudioOutput");
     }
 
     if (CAudioIO::getState() != CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED) {
@@ -274,7 +284,8 @@ void CAudioOutput::resume() throw(CAudioError) {
     try {
         internalLock();
 
-        if (isForceIgnore() == false && mpAudioSessionHandler->isSkipSessionEvent() == false) {
+        if (isForceIgnore() == false &&
+            mpAudioSessionHandler->isSkipSessionEvent() == false) {
             /* Updates ASM to PLAYING */
             mpAudioSessionHandler->updatePlaying();
         }
@@ -292,7 +303,8 @@ void CAudioOutput::resume() throw(CAudioError) {
 
 void CAudioOutput::drain() throw(CAudioError) {
     if (__IsInit() == false || __IsReady() == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput");
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
+                        "Did not initialize or prepare CAudioOutput");
     }
 
     try {
@@ -304,7 +316,8 @@ void CAudioOutput::drain() throw(CAudioError) {
 
 void CAudioOutput::flush() throw(CAudioError) {
     if (__IsInit() == false || __IsReady() == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput");
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
+                        "Did not initialize or prepare CAudioOutput");
     }
 
     try {
@@ -316,7 +329,8 @@ void CAudioOutput::flush() throw(CAudioError) {
 
 int CAudioOutput::getBufferSize() throw(CAudioError) {
     if (__IsInit() == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioOutput");
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
+                        "Did not initialize or prepare CAudioOutput");
     }
 
     /* FIXME : return calculated size here to satisfy backward compatibility */
@@ -325,11 +339,13 @@ int CAudioOutput::getBufferSize() throw(CAudioError) {
 
 size_t CAudioOutput::write(const void* buffer, size_t length) throw(CAudioError) {
     if (__IsInit() == false || __IsReady() == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioOutput");
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
+                        "Did not initialize or prepare CAudioOutput");
     }
 
     if (buffer == NULL) {
-        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are invalid - buffer:%p, length:%zu", buffer, length);
+        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                               "Parameters are invalid - buffer:%p, length:%zu", buffer, length);
     }
     if (CAudioIO::getState() != CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
@@ -340,7 +356,8 @@ size_t CAudioOutput::write(const void* buffer, size_t length) throw(CAudioError)
     if (mpPulseAudioClient->isInThread() == true) {
         int ret = mpPulseAudioClient->write(buffer, length);
         if (ret < 0) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, "The written result is invalid ret:%d", ret);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION,
+                                   "The written result is invalid ret:%d", ret);
         }
 
 #ifdef _AUDIO_IO_DEBUG_TIMING_
@@ -356,7 +373,8 @@ size_t CAudioOutput::write(const void* buffer, size_t length) throw(CAudioError)
 
         // If another thread did call unprepare, do not write
         if (mpPulseAudioClient == NULL)
-            THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
+                            "Did not initialize CPulseAudioClient");
 
         // Sets synchronous flag
         __mIsUsedSyncWrite = true;
@@ -383,18 +401,17 @@ size_t CAudioOutput::write(const void* buffer, size_t length) throw(CAudioError)
 
             int ret = mpPulseAudioClient->write(buffer, l);
             if (ret < 0) {
-                THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, "The written result is invalid ret:%d", ret);
+                THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION,
+                                       "The written result is invalid ret:%d", ret);
             }
 
             buffer = static_cast<const uint8_t*>(buffer) + l;
             lengthIter -= l;
         }  // End of while (length > 0)
 
-        // Unsets synchronous flag
         __mIsUsedSyncWrite = false;
         internalUnlock();
     } catch (CAudioError e) {
-        // Unsets synchronous flag
         __mIsUsedSyncWrite = false;
         internalUnlock();
         throw e;

diff --git a/src/cpp/cpp_audio_io.cpp b/src/cpp/cpp_audio_io.cpp
index bbb30b609fd57df56911cd41d5da454366f39e1f..4096a88b42791ef42c3753021ddddb2258aacf5f 100644 (file)
--- a/src/cpp/cpp_audio_io.cpp
+++ b/src/cpp/cpp_audio_io.cpp
@@ -150,7 +150,8 @@ 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::EChannel::CHANNEL_MONO;
@@ -160,10 +161,12 @@ static void __convert_channel_2_audio_info_channel(const audio_channel_e& src_ch
         break;
     default:
         dst_channel = CAudioInfo::EChannel::CHANNEL_MONO;
+        break;
     }
 }
 
-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::EChannel::CHANNEL_MONO:
         dst_channel = AUDIO_CHANNEL_MONO;
@@ -173,10 +176,12 @@ static void __convert_audio_info_channel_2_channel(const CAudioInfo::EChannel& s
         break;
     default:
         dst_channel = AUDIO_CHANNEL_MONO;
+        break;
     }
 }
 
-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::ESampleType::SAMPLE_TYPE_U8;
@@ -186,10 +191,12 @@ static void __convert_sample_type_2_audio_info_sample_type(const audio_sample_ty
         break;
     default:
         dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_U8;
+        break;
     }
 }
 
-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::ESampleType::SAMPLE_TYPE_U8:
         dst_type = AUDIO_SAMPLE_TYPE_U8;
@@ -199,10 +206,12 @@ static void __convert_audio_info_sample_type_2_sample_type(const CAudioInfo::ESa
         break;
     default:
         dst_type = AUDIO_SAMPLE_TYPE_U8;
+        break;
     }
 }
 
-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::EAudioType::AUDIO_OUT_TYPE_SYSTEM;
@@ -234,7 +243,8 @@ 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::EAudioType::AUDIO_OUT_TYPE_MEDIA:
         dst_type = SOUND_TYPE_MEDIA;
@@ -266,6 +276,7 @@ static void __convert_audio_info_audio_type_2_sound_type(const CAudioInfo::EAudi
 
 static audio_io_state_e __convert_state_type(const CAudioInfo::EAudioIOState src_state) {
     audio_io_state_e dst_state;
+
     switch (src_state) {
     case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE:
         dst_state = AUDIO_IO_STATE_IDLE;
@@ -281,6 +292,7 @@ static audio_io_state_e __convert_state_type(const CAudioInfo::EAudioIOState src
         break;
     default:
         dst_state = AUDIO_IO_STATE_IDLE;
+        break;
     }
     return dst_state;
 }
@@ -373,7 +385,8 @@ int cpp_audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_t
     int ret = 0;
     try {
         if (input == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                  "Parameters are NULL input:%p", input);
         }
 
         __check_audio_param(sample_rate, channel, type);
@@ -423,7 +436,8 @@ int cpp_audio_in_create_loopback(int sample_rate, audio_channel_e channel, audio
     audio_io_s* handle = NULL;
     try {
         if (input == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                  "Parameters are NULL input:%p", input);
         }
 
         __check_audio_param(sample_rate, channel, type);
@@ -467,7 +481,8 @@ int cpp_audio_in_destroy(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                  "Parameters are NULL input:%p", input);
         }
 
         assert(handle->audioIoHandle);
@@ -491,7 +506,8 @@ int cpp_audio_in_set_sound_stream_info(audio_in_h input, sound_stream_info_h str
 
     try {
         if (handle == NULL || stream_info == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, stream_info:%p", input, stream_info);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p, stream_info:%p", input, stream_info);
         }
 
         assert(handle->audioIoHandle);
@@ -533,7 +549,8 @@ int cpp_audio_in_prepare(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p", input);
         }
 
         assert(handle->audioIoHandle);
@@ -552,9 +569,9 @@ int cpp_audio_in_unprepare(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p", input);
         }
-
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->unprepare();
@@ -571,9 +588,9 @@ int cpp_audio_in_pause(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p", input);
         }
-
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->pause();
@@ -590,9 +607,9 @@ int cpp_audio_in_resume(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p", input);
         }
-
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->resume();
@@ -609,9 +626,9 @@ int cpp_audio_in_drain(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p", input);
         }
-
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->drain();
@@ -628,7 +645,8 @@ int cpp_audio_in_flush(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p", input);
         }
 
         assert(handle->audioIoHandle);
@@ -648,15 +666,16 @@ int cpp_audio_in_read(audio_in_h input, void *buffer, unsigned int length) {
 
     try {
         if (handle == NULL || buffer == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, buffer:%p", input, buffer);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p, buffer:%p", input, buffer);
         }
-
         assert(handle->audioIoHandle);
 
         CAudioInput* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
         if (inputHandle == NULL) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
         }
+
         size_t readn = inputHandle->read(buffer, static_cast<size_t>(length));
         ret = static_cast<int>(readn);
 #ifdef _AUDIO_IO_DEBUG_TIMING_
@@ -675,7 +694,8 @@ int cpp_audio_in_get_buffer_size(audio_in_h input, int *size) {
 
     try {
         if (handle == NULL || size == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, size:%p", input, size);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p, size:%p", input, size);
         }
 
         assert(handle->audioIoHandle);
@@ -698,7 +718,8 @@ int cpp_audio_in_get_sample_rate(audio_in_h input, int *sample_rate) {
 
     try {
         if (handle == NULL || sample_rate == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, sample_rate:%p", input, sample_rate);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p, sample_rate:%p", input, sample_rate);
         }
 
         assert(handle->audioIoHandle);
@@ -716,7 +737,8 @@ int cpp_audio_in_get_channel(audio_in_h input, audio_channel_e *channel) {
 
     try {
         if (handle == NULL || channel == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, channel:%p", input, channel);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p, channel:%p", input, channel);
         }
 
         assert(handle->audioIoHandle);
@@ -739,13 +761,13 @@ int cpp_audio_in_get_sample_type(audio_in_h input, audio_sample_type_e *type) {
 
     try {
         if (handle == NULL || type == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, type:%p", input, type);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p, type:%p", input, type);
         }
-
         assert(handle->audioIoHandle);
 
         const CAudioInfo::ESampleType srcSampleType = handle->audioIoHandle->getAudioInfo().getSampleType();
-        audio_sample_type_e     dstSampleType = AUDIO_SAMPLE_TYPE_U8;
+        audio_sample_type_e dstSampleType = AUDIO_SAMPLE_TYPE_U8;
         __convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType);
 
         *type = dstSampleType;
@@ -763,7 +785,7 @@ static void __interrupt_cb_internal(IAudioSessionEventListener::EInterruptCode _
 
     assert(handle);
 
-    if (handle->interrupt_callback.onInterrupt != NULL) {
+    if (handle->interrupt_callback.onInterrupt) {
         handle->interrupt_callback.onInterrupt(code, handle->interrupt_callback.user_data);
     }
 }
@@ -773,16 +795,17 @@ int cpp_audio_in_set_interrupted_cb(audio_in_h input, audio_io_interrupted_cb ca
 
     try {
         if (handle == NULL || callback == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p, callback:%p", input, callback);
         }
 
         assert(handle->audioIoHandle);
 
         handle->interrupt_callback.onInterrupt = callback;
-        handle->interrupt_callback.user_data    = user_data;
+        handle->interrupt_callback.user_data = user_data;
 
         CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
-        cb.mUserData   = static_cast<void*>(handle);
+        cb.mUserData = static_cast<void*>(handle);
         cb.onInterrupt = __interrupt_cb_internal;
 
         handle->audioIoHandle->setInterruptCallback(cb);
@@ -799,7 +822,8 @@ int cpp_audio_in_unset_interrupted_cb(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p", input);
         }
 
         assert(handle->audioIoHandle);
@@ -808,7 +832,7 @@ int cpp_audio_in_unset_interrupted_cb(audio_in_h input) {
         handle->interrupt_callback.user_data    = NULL;
 
         CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
-        cb.mUserData   = NULL;
+        cb.mUserData = NULL;
         cb.onInterrupt = NULL;
 
         handle->audioIoHandle->setInterruptCallback(cb);
@@ -825,11 +849,13 @@ int cpp_audio_in_ignore_session(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p", input);
         }
 
         if (handle->stream_callback.onStream) {
-            THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION, "Not support ignore session in async mode");
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
+                            "Not support ignore session in async mode");
         }
 
         assert(handle->audioIoHandle);
@@ -847,17 +873,22 @@ static void __stream_cb_internal(size_t nbytes, void *user_data) {
     audio_io_s* audioIo = static_cast<audio_io_s*>(user_data);
     assert(audioIo);
 
-    if (audioIo->stream_callback.onStream != NULL) {
+    if (audioIo->stream_callback.onStream) {
         audioIo->stream_callback.onStream(audioIo, nbytes, audioIo->stream_callback.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);
+    if (audioIo->state_changed_callback.onStateChanged) {
+        audioIo->state_changed_callback.onStateChanged(audioIo, __convert_state_type(state_prev),
+                                                       __convert_state_type(state), by_policy,
+                                                       audioIo->state_changed_callback.user_data);
     }
 }
 
@@ -866,7 +897,8 @@ int cpp_audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, vo
 
     try {
         if (handle == NULL || callback == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p, callback:%p", input, callback);
         }
 
         assert(handle->audioIoHandle);
@@ -892,7 +924,8 @@ int cpp_audio_in_unset_stream_cb(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p", input);
         }
 
         assert(handle->audioIoHandle);
@@ -919,7 +952,8 @@ int cpp_audio_in_peek(audio_in_h input, const void **buffer, unsigned int *lengt
 
     try {
         if (handle == NULL || buffer == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, buffer:%p", input, buffer);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p, buffer:%p", input, buffer);
         }
 
         CAudioInput* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
@@ -941,7 +975,8 @@ int cpp_audio_in_drop(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p", input);
         }
 
         CAudioInput* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
@@ -961,7 +996,8 @@ int cpp_audio_in_set_state_changed_cb(audio_in_h input, audio_in_state_changed_c
 
     try {
         if (handle == NULL || callback == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL input:%p, callback:%p", input, callback);
         }
 
         assert(handle->audioIoHandle);
@@ -987,7 +1023,8 @@ int cpp_audio_in_unset_state_changed_cb(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL output:%p", input);
         }
 
         assert(handle->audioIoHandle);
@@ -1016,7 +1053,8 @@ int cpp_audio_out_create(int sample_rate, audio_channel_e channel, audio_sample_
     audio_io_s* handle = NULL;
     try {
         if (output == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL output:%p", output);
         }
 
         __check_audio_param(sample_rate, channel, type, sound_type);
@@ -1059,7 +1097,8 @@ int cpp_audio_out_create_new(int sample_rate, audio_channel_e channel, audio_sam
     audio_io_s* handle = NULL;
     try {
         if (output == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL output:%p", output);
         }
 
         __check_audio_param(sample_rate, channel, type, SOUND_TYPE_SYSTEM /*default check */);
@@ -1069,7 +1108,7 @@ int cpp_audio_out_create_new(int sample_rate, audio_channel_e channel, audio_sam
             THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
         }
 
-        CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, SOUND_TYPE_MEDIA /* default sound_type */);
+        CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, SOUND_TYPE_MEDIA);
 
         handle->audioIoHandle = new CAudioOutput(audioInfo);
         if (handle->audioIoHandle == NULL) {
@@ -1103,7 +1142,8 @@ int cpp_audio_out_destroy(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameter is NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
@@ -1127,7 +1167,8 @@ int cpp_audio_out_set_sound_stream_info(audio_out_h output, sound_stream_info_h
 
     try {
         if (handle == NULL || stream_info == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, stream_info:%p", output, stream_info);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL output:%p, stream_info:%p", output, stream_info);
         }
 
         assert(handle->audioIoHandle);
@@ -1154,7 +1195,8 @@ int cpp_audio_out_set_sound_stream_info(audio_out_h output, sound_stream_info_h
             }
             handle->audioIoHandle->getAudioInfo().setAudioIndex(index);
         } else {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE, "Output stream is not supported");
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE,
+                                   "Output stream is not supported");
         }
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
@@ -1169,7 +1211,8 @@ int cpp_audio_out_prepare(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameter is NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
@@ -1188,7 +1231,8 @@ int cpp_audio_out_unprepare(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameter is NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
@@ -1207,7 +1251,8 @@ int cpp_audio_out_pause(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameter is NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
@@ -1226,7 +1271,8 @@ int cpp_audio_out_resume(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameter is NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
@@ -1245,7 +1291,8 @@ int cpp_audio_out_drain(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameter is NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
@@ -1264,7 +1311,8 @@ int cpp_audio_out_flush(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameter is NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
@@ -1284,7 +1332,8 @@ int cpp_audio_out_write(audio_out_h output, void *buffer, unsigned int length) {
 
     try {
         if (handle == NULL || buffer == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p, buffer:%p", output, buffer);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameter is NULL output:%p, buffer:%p", output, buffer);
         }
 
         assert(handle->audioIoHandle);
@@ -1293,6 +1342,7 @@ int cpp_audio_out_write(audio_out_h output, void *buffer, unsigned int length) {
         if (outputHandle == NULL) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
         }
+
         size_t written = outputHandle->write(buffer, static_cast<size_t>(length));
         ret = static_cast<int>(written);
 #ifdef _AUDIO_IO_DEBUG_TIMING_
@@ -1311,7 +1361,8 @@ int cpp_audio_out_get_buffer_size(audio_out_h output, int *size) {
 
     try {
         if (handle == NULL || size == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, size:%p", output, size);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL output:%p, size:%p", output, size);
         }
 
         assert(handle->audioIoHandle);
@@ -1334,7 +1385,8 @@ int cpp_audio_out_get_sample_rate(audio_out_h output, int *sample_rate) {
 
     try {
         if (handle == NULL || sample_rate == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, sample_rate:%p", output, sample_rate);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL output:%p, sample_rate:%p", output, sample_rate);
         }
 
         assert(handle->audioIoHandle);
@@ -1352,7 +1404,8 @@ int cpp_audio_out_get_channel(audio_out_h output, audio_channel_e *channel) {
 
     try {
         if (handle == NULL || channel == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, channel:%p", output, channel);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL output:%p, channel:%p", output, channel);
         }
 
         assert(handle->audioIoHandle);
@@ -1375,7 +1428,8 @@ int cpp_audio_out_get_sample_type(audio_out_h output, audio_sample_type_e *type)
 
     try {
         if (handle == NULL || type == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, type:%p", output, type);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL output:%p, type:%p", output, type);
         }
 
         assert(handle->audioIoHandle);
@@ -1398,7 +1452,8 @@ int cpp_audio_out_get_sound_type(audio_out_h output, sound_type_e *type) {
 
     try {
         if (handle == NULL || type == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, type:%p", output, type);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL output:%p, type:%p", output, type);
         }
 
         assert(handle->audioIoHandle);
@@ -1421,7 +1476,8 @@ int cpp_audio_out_set_interrupted_cb(audio_out_h output, audio_io_interrupted_cb
 
     try {
         if (handle == NULL || callback == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL output:%p, callback:%p", output, callback);
         }
 
         assert(handle->audioIoHandle);
@@ -1447,16 +1503,17 @@ int cpp_audio_out_unset_interrupted_cb(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
 
         handle->interrupt_callback.onInterrupt = NULL;
-        handle->interrupt_callback.user_data    = NULL;
+        handle->interrupt_callback.user_data = NULL;
 
         CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
-        cb.mUserData   = NULL;
+        cb.mUserData = NULL;
         cb.onInterrupt = NULL;
 
         handle->audioIoHandle->setInterruptCallback(cb);
@@ -1473,11 +1530,13 @@ int cpp_audio_out_ignore_session(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL output:%p", output);
         }
 
         if (handle->stream_callback.onStream) {
-            THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION, "Not support ignore session in async mode");
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
+                            "Not support ignore session in async mode");
         }
 
         assert(handle->audioIoHandle);
@@ -1496,7 +1555,8 @@ int cpp_audio_out_set_stream_cb(audio_out_h output, audio_out_stream_cb callback
 
     try {
         if (handle == NULL || callback == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL output:%p, callback:%p", output, callback);
         }
 
         assert(handle->audioIoHandle);
@@ -1522,7 +1582,8 @@ int cpp_audio_out_unset_stream_cb(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
@@ -1532,7 +1593,7 @@ int cpp_audio_out_unset_stream_cb(audio_out_h output) {
 
         CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback();
         cb.mUserData = NULL;
-        cb.onStream  = NULL;
+        cb.onStream = NULL;
 
         handle->audioIoHandle->setStreamCallback(cb);
     } catch (CAudioError e) {
@@ -1548,7 +1609,8 @@ int cpp_audio_out_set_state_changed_cb(audio_out_h output, audio_in_state_change
 
     try {
         if (handle == NULL || callback == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL output:%p, callback:%p", output, callback);
         }
 
         assert(handle->audioIoHandle);
@@ -1574,7 +1636,8 @@ int cpp_audio_out_unset_state_changed_cb(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
+                                   "Parameters are NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
@@ -1584,7 +1647,7 @@ int cpp_audio_out_unset_state_changed_cb(audio_out_h output) {
 
         CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback();
         cb.mUserData = NULL;
-        cb.onStateChanged  = NULL;
+        cb.onStateChanged = NULL;
 
         handle->audioIoHandle->setStateChangedCallback(cb);
     } catch (CAudioError e) {

diff --git a/test/audio_io_test.c b/test/audio_io_test.c
index 717b8d20db49ae7abe9a6f18ceecb02fc6d052b0..70e6e3a1550518f941e1507b8f6e5478dc19be6a 100644 (file)
--- a/test/audio_io_test.c
+++ b/test/audio_io_test.c
@@ -36,8 +36,25 @@ test_wav_t test_wav;
 
 static int ch_table[3] = { 0, AUDIO_CHANNEL_MONO, AUDIO_CHANNEL_STEREO };
 
-void play_file(char *file, int length, int ch)
+static char *state_str[] = { "IDLE", "RUNNING", "PAUSED" };
+
+static void _audio_in_state_cb(audio_in_h handle, audio_io_state_e previous, audio_io_state_e current, bool by_policy, void *user_data)
+{
+       printf(">>> _audio_in_state_cb() : handle(%p), previous(%d,%s) => current(%d,%s), by_policy(%d), user_data(%p)\n",
+                       handle, previous, state_str[previous], current, state_str[current], by_policy, user_data);
+}
+
+static void _audio_out_state_cb(audio_in_h handle, audio_io_state_e previous, audio_io_state_e current, bool by_policy, void *user_data)
 {
+       printf(">>> _audio_out_state_cb() : handle(%p), previous(%d,%s) => current(%d,%s), by_policy(%d), user_data(%p)\n",
+                       handle, previous, state_str[previous], current, state_str[current], by_policy, user_data);
+}
+
+void play_file(char *file, int length, int num, int ch)
+{
+       int i = 0;
+       int ret = 0;
+       int total_length = length * num;
        audio_out_h output;
        FILE *fp = fopen(file, "r");
        if (fp == NULL) {
@@ -45,23 +62,39 @@ void play_file(char *file, int length, int ch)
                return;
        }
 
-       char *buf = malloc(length);
+       char *buf = malloc(total_length);
        if (buf == NULL) {
                printf("malloc failed\n");
                fclose(fp);
                return;
        }
 
-       printf("start to play [%s][%d][%d]\n", file, length, ch);
+       printf("start to play [%s][%d][%d]\n", file, total_length, ch);
+       printf("create\n");
        audio_out_create_new(44100, ch_table[ch], AUDIO_SAMPLE_TYPE_S16_LE, &output);
-       if (fread(buf, 1, length, fp) != length)
+       if (fread(buf, 1, total_length, fp) != length)
                printf("error!!!!\n");
 
+       ret = audio_out_set_state_changed_cb(output, _audio_out_state_cb, NULL);
+       if (ret != AUDIO_IO_ERROR_NONE) {
+               printf("audio_out_set_state_changed_cb failed. \n");
+       }
+
+       printf("prepare\n");
        audio_out_prepare(output);
-       audio_out_write(output, buf, length);
+
+       char *pbuf = buf;
+       for (i = 0; i < num; i++) {
+               printf("### write = (%d/%d) ============== \n", i, num);
+               audio_out_write(output, pbuf, length);
+               pbuf += length;
+
+       }
+       printf("unprepare\n");
        audio_out_drain(output);
        audio_out_unprepare(output);
 
+       printf("destroy\n");
        audio_out_destroy(output);
 
        fclose(fp);
@@ -133,26 +166,22 @@ int audio_io_test(int length, int num, int ch)
        int ret, size, i;
        audio_in_h input;
        if ((ret = audio_in_create(44100, ch_table[ch], AUDIO_SAMPLE_TYPE_S16_LE, &input)) == AUDIO_IO_ERROR_NONE) {
-               ret = audio_in_ignore_session(input);
-               if (ret != 0) {
-                       printf("ERROR, set session mix\n");
-                       audio_in_destroy(input);
-                       return 0;
+               ret = audio_in_set_state_changed_cb(input, _audio_in_state_cb, NULL);
+               if (ret != AUDIO_IO_ERROR_NONE) {
+                       printf("audio_in_set_state_changed_cb failed. \n");
+                       goto error;
                }
 
                ret = audio_in_prepare(input);
                if (ret != 0) {
                        printf("ERROR, prepare\n");
-                       audio_in_destroy(input);
-                       return 0;
+                       goto error;
                }
 
                FILE *fp = fopen(DUMP_FILE, "wb+");
-
                if (fp == NULL) {
                        printf("ERROR, file open failed\n");
-                       audio_in_destroy(input);
-                       return 0;
+                       goto error;
                }
 
                if ((ret = audio_in_get_buffer_size(input, &size)) == AUDIO_IO_ERROR_NONE) {
@@ -160,12 +189,12 @@ int audio_io_test(int length, int num, int ch)
                        char *buffer = alloca(size);
 
                        for (i = 0; i < num; i++) {
-                               printf("### loop = %d ============== \n", i);
+                               printf("### read = (%d/%d) ============== ", i, num);
                                if ((ret = audio_in_read(input, (void *)buffer, size)) > AUDIO_IO_ERROR_NONE) {
                                        fwrite(buffer, size, sizeof(char), fp);
-                                       printf("PASS, size=%d, ret=%d\n", size, ret);
+                                       printf("PASS, size=%d, ret=0x%x\n", size, ret);
                                } else {
-                                       printf("FAIL, size=%d, ret=%d\n", size, ret);
+                                       printf("FAIL, size=%d, ret=0x%x\n", size, ret);
                                }
                        }
                }
@@ -176,9 +205,12 @@ int audio_io_test(int length, int num, int ch)
                audio_in_destroy(input);
        }
 
-       play_file(DUMP_FILE, length * num, ch);
+       play_file(DUMP_FILE, length, num, ch);
 
-       return 1;
+       return 0;
+error:
+       audio_in_destroy(input);
+       return -1;
 }
 
 int audio_io_loopback_in_test()
@@ -189,7 +221,7 @@ int audio_io_loopback_in_test()
 
        if (fp == NULL) {
                printf("open failed \n");
-               return 0;
+               return -1;
        }
 
        if ((ret = audio_in_create(16000, AUDIO_CHANNEL_MONO, AUDIO_SAMPLE_TYPE_S16_LE, &input)) == AUDIO_IO_ERROR_NONE) {
@@ -215,9 +247,9 @@ int audio_io_loopback_in_test()
                        char *buffer = alloca(size);
                        if ((ret = audio_in_read(input, (void *)buffer, size)) > AUDIO_IO_ERROR_NONE) {
                                fwrite(buffer, size, sizeof(char), fp);
-                               printf("PASS, size=%d, ret=%d\n", size, ret);
+                               printf("PASS, size=%d, ret=0x%x\n", size, ret);
                        } else {
-                               printf("FAIL, size=%d, ret=%d\n", size, ret);
+                               printf("FAIL, size=%d, ret=0x%x\n", size, ret);
                        }
                }
        }
@@ -241,19 +273,19 @@ int audio_io_loopback_test()
        ret = audio_in_create(16000, AUDIO_CHANNEL_MONO, AUDIO_SAMPLE_TYPE_S16_LE, &input);
        if (ret != AUDIO_IO_ERROR_NONE) {
                printf("audio_in_create_ex failed. \n");
-               return 0;
+               return ret;
        }
        ret = audio_out_create_new(16000, AUDIO_CHANNEL_MONO, AUDIO_SAMPLE_TYPE_S16_LE, &output);
        if (ret != AUDIO_IO_ERROR_NONE) {
                printf("audio_out_create failed. \n");
-               return 0;
+               return ret;
        }
 
        ret = audio_in_prepare(input);
        if (ret != 0) {
                printf("audio_in_prepare failed, err(0x%x)\n", ret);
                audio_in_destroy(input);
-               return 0;
+               return ret;
        } else {
                ret = audio_in_get_buffer_size(input, &size);
                if (ret != AUDIO_IO_ERROR_NONE) {
@@ -269,12 +301,12 @@ int audio_io_loopback_test()
        if (ret != 0) {
                printf("audio_out_prepare failed, err(0x%x)\n", ret);
                audio_out_destroy(output);
-               return 0;
+               return ret;
        }
 
        if (buffer == NULL) {
                printf("buffer is null\n");
-               return 0;
+               return -1;
        }
 
        while (1) {
@@ -352,16 +384,6 @@ static void _audio_io_stream_write_cb(audio_out_h handle, size_t nbytes, void *u
        }
 }
 
-static void _audio_in_state_cb(audio_in_h handle, audio_io_state_e previous, audio_io_state_e current, bool by_policy, void *user_data)
-{
-       printf(">>> _audio_in_state_cb() : handle(%p), current(%d), previous(%d), by_policy(%d), user_data(%p)\n", handle, current, previous, by_policy, user_data);
-}
-
-static void _audio_out_state_cb(audio_in_h handle, audio_io_state_e previous, audio_io_state_e current, bool by_policy, void *user_data)
-{
-       printf(">>> _audio_out_state_cb() : handle(%p), current(%d), previous(%d), by_policy(%d), user_data(%p)\n", handle, current, previous, by_policy, user_data);
-}
-
 int _convert_cmd_and_run(char cmd, int mode)
 {
        int ret = 0;
@@ -508,6 +530,7 @@ int audio_io_async_test(int mode)
                        printf("fail to sound_manager_create_stream_information(), ret(0x%x)\n", ret);
                        goto EXIT;
                }
+
                ret = audio_out_set_sound_stream_info(output, g_stream_info_write_h);
                if (ret)
                        printf("fail to audio_out_set_sound_stream_info(), ret(0x%x)\n", ret);