projects / platform / core / api / audio-io.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Support 24bit sample format and up-to 192kHz sample rate
[platform/core/api/audio-io.git] / src / cpp / cpp_audio_io.cpp
diff --git a/src/cpp/cpp_audio_io.cpp b/src/cpp/cpp_audio_io.cpp
index c2300cd..8df8dde 100644 (file)
--- a/src/cpp/cpp_audio_io.cpp
+++ b/src/cpp/cpp_audio_io.cpp
@@ -15,8 +15,9 @@
  */
 
 
+#include <new>
+
 #include "cpp_audio_io.h"
-#include <sound_manager_internal.h>
 #include "audio_io.h"
 #include "CAudioIODef.h"
 
@@ -27,21 +28,6 @@
 using namespace std;
 using namespace tizen_media_audio;
 
-
-/**
- * Defines Structures
- * type : struct
- * Name : audio_io_interrupted_cb_s
- * Declaration : Keeps user callback pointer and user data for delivering an interrupt event
- */
-typedef struct audio_io_interrupted_cb_s {
-    void* user_data;
-    audio_io_interrupted_cb onInterrupt;
-
-    audio_io_interrupted_cb_s() : user_data(NULL), onInterrupt(NULL)
-    {/* Empty Body */}
-}   audio_io_interrupted_cb_s;
-
 /**
  * Defines Structures
  * type : struct
@@ -80,10 +66,9 @@ typedef struct audio_io_state_changed_cb_s {
  * The CAudioIO is a abstract class object about Input and Output
  */
 typedef struct audio_io_s {
-    CAudioIO*                    audioIoHandle;
-    audio_io_interrupted_cb_s    interrupt_callback;
-    audio_io_stream_cb_s         stream_callback;
-    audio_io_state_changed_cb_s  state_changed_callback;
+    CAudioIO* audioIoHandle;
+    audio_io_stream_cb_s stream_callback;
+    audio_io_state_changed_cb_s state_changed_callback;
 
     audio_io_s() : audioIoHandle(NULL)
     {/* Empty Body */}
@@ -94,7 +79,7 @@ typedef struct audio_io_s {
  * Internal functions
  */
 static audio_io_error_e __convert_CAudioError(CAudioError& error) {
-    audio_io_error_e    ret = AUDIO_IO_ERROR_NONE;
+    audio_io_error_e ret = AUDIO_IO_ERROR_NONE;
     CAudioError::EError err = error.getError();
 
     switch (err) {
@@ -189,6 +174,12 @@ static void __convert_sample_type_2_audio_info_sample_type(const audio_sample_ty
     case AUDIO_SAMPLE_TYPE_S16_LE:
         dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_S16_LE;
         break;
+    case AUDIO_SAMPLE_TYPE_S24_LE:
+        dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_S24_LE;
+        break;
+    case AUDIO_SAMPLE_TYPE_S24_32_LE:
+        dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_S24_32_LE;
+        break;
     default:
         dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_U8;
         break;
@@ -204,6 +195,12 @@ static void __convert_audio_info_sample_type_2_sample_type(const CAudioInfo::ESa
     case CAudioInfo::ESampleType::SAMPLE_TYPE_S16_LE:
         dst_type = AUDIO_SAMPLE_TYPE_S16_LE;
         break;
+    case CAudioInfo::ESampleType::SAMPLE_TYPE_S24_LE:
+        dst_type = AUDIO_SAMPLE_TYPE_S24_LE;
+        break;
+    case CAudioInfo::ESampleType::SAMPLE_TYPE_S24_32_LE:
+        dst_type = AUDIO_SAMPLE_TYPE_S24_32_LE;
+        break;
     default:
         dst_type = AUDIO_SAMPLE_TYPE_U8;
         break;
@@ -297,32 +294,31 @@ 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) {
-    if (sample_rate < 0) {
+static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type) {
+    if (sample_rate < 0)
         THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid sample rate :%d", sample_rate);
-    }
 
-    if (channel != AUDIO_CHANNEL_MONO && channel != AUDIO_CHANNEL_STEREO) {
+    if (channel != AUDIO_CHANNEL_MONO && channel != AUDIO_CHANNEL_STEREO)
         THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid channel :%d", channel);
-    }
 
-    if (type != AUDIO_SAMPLE_TYPE_U8 && type != AUDIO_SAMPLE_TYPE_S16_LE) {
+    if (type != AUDIO_SAMPLE_TYPE_U8 &&
+        type != AUDIO_SAMPLE_TYPE_S16_LE &&
+        type != AUDIO_SAMPLE_TYPE_S24_LE &&
+        type != AUDIO_SAMPLE_TYPE_S24_32_LE)
         THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid sample type :%d", 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) {
+static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type, sound_type_e sound_type) {
     __check_audio_param(sample_rate, channel, type);
 
-    if (sound_type < SOUND_TYPE_SYSTEM || sound_type > SOUND_TYPE_VOICE) {
+    if (sound_type < SOUND_TYPE_SYSTEM || sound_type > SOUND_TYPE_VOICE)
         THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid sound type : %d", sound_type);
-    }
 }
 
-static CAudioInfo __generate_audio_input_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw(CAudioError) {
-    CAudioInfo::EChannel     dstChannel;
+static CAudioInfo __generate_audio_input_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) {
+    CAudioInfo::EChannel dstChannel;
     CAudioInfo::ESampleType dstSampleType;
-    CAudioInfo::EAudioType  dstAudioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA;
+    CAudioInfo::EAudioType dstAudioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA;
 
     __convert_channel_2_audio_info_channel(channel, dstChannel);
     __convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
@@ -330,21 +326,10 @@ static CAudioInfo __generate_audio_input_info(int sampleRate, audio_channel_e ch
     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) {
-    CAudioInfo::EChannel     dstChannel;
+static CAudioInfo __generate_audio_output_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type, sound_type_e sound_type) {
+    CAudioInfo::EChannel dstChannel;
     CAudioInfo::ESampleType dstSampleType;
-    CAudioInfo::EAudioType  dstAudioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_LOOPBACK;
-
-    __convert_channel_2_audio_info_channel(channel, dstChannel);
-    __convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
-
-    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) {
-    CAudioInfo::EChannel     dstChannel;
-    CAudioInfo::ESampleType dstSampleType;
-    CAudioInfo::EAudioType  dstAudioType;
+    CAudioInfo::EAudioType dstAudioType;
 
     __convert_channel_2_audio_info_channel(channel, dstChannel);
     __convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
@@ -353,27 +338,19 @@ static CAudioInfo __generate_audio_output_info(int sampleRate, audio_channel_e c
     return CAudioInfo(sampleRate, dstChannel, dstSampleType, dstAudioType, -1);
 }
 
-static audio_io_interrupted_code_e __convert_interrupted_code(IAudioSessionEventListener::EInterruptCode code) {
-    switch (code) {
-    case IAudioSessionEventListener::EInterruptCode::INTERRUPT_COMPLETED:
-        return AUDIO_IO_INTERRUPTED_COMPLETED;
-    case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_CALL:
-        return AUDIO_IO_INTERRUPTED_BY_CALL;
-    case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_EARJACK_UNPLUG:
-        return AUDIO_IO_INTERRUPTED_BY_EARJACK_UNPLUG;
-    case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_RESOURCE_CONFLICT:
-        return AUDIO_IO_INTERRUPTED_BY_RESOURCE_CONFLICT;
-    case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_ALARM:
-        return AUDIO_IO_INTERRUPTED_BY_ALARM;
-    case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_EMERGENCY:
-        return AUDIO_IO_INTERRUPTED_BY_EMERGENCY;
-    case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_NOTIFICATION:
-        return AUDIO_IO_INTERRUPTED_BY_NOTIFICATION;
-    case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_MEDIA:
-    case IAudioSessionEventListener::EInterruptCode::INTERRUPT_MAX:
-    default:
-        return AUDIO_IO_INTERRUPTED_BY_MEDIA;
-    }
+static void __handle_safe_free(audio_io_s* handle, void *obj, bool is_output) {
+    VALID_POINTER_START(handle)
+        SAFE_FINALIZE(handle->audioIoHandle);
+        SAFE_DELETE(handle->audioIoHandle);
+        SAFE_DELETE(handle);
+    VALID_POINTER_END
+
+    VALID_POINTER_START(obj)
+        if (is_output)
+            *(audio_out_h *)obj = NULL;
+        else
+            *(audio_in_h *)obj = NULL;
+    VALID_POINTER_END
 }
 
 /**
@@ -391,6 +368,8 @@ int cpp_audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_t
 
         __check_audio_param(sample_rate, channel, type);
 
+        AUDIO_IO_LOGD("samplerate:[%d] channel:[0x%x] sample_type:[0x%x]", sample_rate, channel, type);
+
         /* If MIC is not supported, return NOT_SUPPORTED error */
         ret = system_info_get_platform_bool(FEATURE_MICROPHONE, &mic_enable);
         AUDIO_IO_LOGD("system_info_platform [%s]=[%d], ret[%d]", FEATURE_MICROPHONE, mic_enable, ret);
@@ -398,78 +377,22 @@ int cpp_audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_t
             THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "System doesn't support microphone!");
         }
 
-        handle = new audio_io_s;
-        if (handle == NULL) {
-            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
-        }
-
         CAudioInfo audioInfo = __generate_audio_input_info(sample_rate, channel, type);
 
-        handle->audioIoHandle = new CAudioInput(audioInfo);
-        if (handle->audioIoHandle == NULL) {
-            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
-        }
-
-        handle->audioIoHandle->initialize();
-
-        *input = handle;
-    } catch (CAudioError e) {
-        AUDIO_IO_LOGE("%s", e.getErrorMsg());
-
-        VALID_POINTER_START(handle)
-            SAFE_FINALIZE(handle->audioIoHandle);
-            SAFE_DELETE(handle->audioIoHandle);
-            SAFE_DELETE(handle);
-        VALID_POINTER_END
-
-        VALID_POINTER_START(input)
-            *input = NULL;
-        VALID_POINTER_END
-
-        return __convert_CAudioError(e);
-    }
-
-    return AUDIO_IO_ERROR_NONE;
-}
-
-int cpp_audio_in_create_loopback(int sample_rate, audio_channel_e channel, audio_sample_type_e type , audio_in_h* input) {
-    audio_io_s* handle = NULL;
-    try {
-        if (input == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
-                                  "Parameters are NULL input:%p", input);
-        }
-
-        __check_audio_param(sample_rate, channel, type);
-
         handle = new audio_io_s;
-        if (handle == NULL) {
-            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
-        }
-
-        CAudioInfo audioInfo = __generate_audio_input_loopback_info(sample_rate, channel, type);
-
         handle->audioIoHandle = new CAudioInput(audioInfo);
-        if (handle->audioIoHandle == NULL) {
-            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
-        }
-
         handle->audioIoHandle->initialize();
 
+        AUDIO_IO_LOGD("[%p] created", handle);
         *input = handle;
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-
-        VALID_POINTER_START(handle)
-            SAFE_FINALIZE(handle->audioIoHandle);
-            SAFE_DELETE(handle->audioIoHandle);
-            SAFE_DELETE(handle);
-        VALID_POINTER_END
-
-        VALID_POINTER_START(input)
-            *input = NULL;
-        VALID_POINTER_END
-
+        __handle_safe_free(handle, (void *)input, false);
+        return __convert_CAudioError(e);
+    } catch (const std::bad_alloc&) {
+        CAudioError e = CAudioError::EError::ERROR_OUT_OF_MEMORY;
+        AUDIO_IO_LOGE("Failed to allocate handle");
+        __handle_safe_free(handle, (void *)input, false);
         return __convert_CAudioError(e);
     }
 
@@ -480,11 +403,11 @@ int cpp_audio_in_destroy(audio_in_h input) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
 
     try {
-        if (handle == NULL) {
+        if (handle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                   "Parameters are NULL input:%p", input);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p]", handle);
 
         /* Internal unprepare for backward compatibility */
         handle->audioIoHandle->unprepare();
@@ -492,11 +415,13 @@ int cpp_audio_in_destroy(audio_in_h input) {
         SAFE_FINALIZE(handle->audioIoHandle);
         SAFE_DELETE(handle->audioIoHandle);
         SAFE_DELETE(handle);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("destroyed");
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -504,18 +429,20 @@ int cpp_audio_in_set_sound_stream_info(audio_in_h input, sound_stream_info_h str
     audio_io_s* handle = static_cast<audio_io_s*>(input);
 
     try {
-        if (handle == NULL || stream_info == NULL) {
+        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);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p], stream_info:[%p]", handle, stream_info);
 
         handle->audioIoHandle->setStreamInfo(stream_info);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] done", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -523,18 +450,20 @@ int cpp_audio_in_prepare(audio_in_h input) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
 
     try {
-        if (handle == NULL) {
+        if (handle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL input:%p", input);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p]", handle);
 
         handle->audioIoHandle->prepare();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] prepared", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -542,18 +471,20 @@ int cpp_audio_in_unprepare(audio_in_h input) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
 
     try {
-        if (handle == NULL) {
+        if (handle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL input:%p", input);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p]", handle);
 
         handle->audioIoHandle->unprepare();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] unprepared", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -561,18 +492,20 @@ int cpp_audio_in_pause(audio_in_h input) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
 
     try {
-        if (handle == NULL) {
+        if (handle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL input:%p", input);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p]", handle);
 
         handle->audioIoHandle->pause();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] paused", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -580,18 +513,20 @@ int cpp_audio_in_resume(audio_in_h input) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
 
     try {
-        if (handle == NULL) {
+        if (handle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL input:%p", input);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p]", handle);
 
         handle->audioIoHandle->resume();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] resumed", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -599,18 +534,20 @@ int cpp_audio_in_drain(audio_in_h input) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
 
     try {
-        if (handle == NULL) {
+        if (handle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL input:%p", input);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p]", handle);
 
         handle->audioIoHandle->drain();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] drained", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -618,18 +555,20 @@ int cpp_audio_in_flush(audio_in_h input) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
 
     try {
-        if (handle == NULL) {
+        if (handle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL input:%p", input);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p]", handle);
 
         handle->audioIoHandle->flush();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] flushed", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -638,13 +577,12 @@ int cpp_audio_in_read(audio_in_h input, void *buffer, unsigned int length) {
     int ret = 0;
 
     try {
-        if (handle == NULL || buffer == NULL) {
+        if (handle == NULL || buffer == NULL)
             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);
+        CAudioInput* inputHandle = static_cast<CAudioInput*>(handle->audioIoHandle);
         if (inputHandle == NULL) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
         }
@@ -654,7 +592,7 @@ int cpp_audio_in_read(audio_in_h input, void *buffer, unsigned int length) {
 #ifdef _AUDIO_IO_DEBUG_TIMING_
         AUDIO_IO_LOGD("readn:%d", readn);
 #endif
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -666,18 +604,17 @@ int cpp_audio_in_get_buffer_size(audio_in_h input, int *size) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
 
     try {
-        if (handle == NULL || size == NULL) {
+        if (handle == NULL || size == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL input:%p, size:%p", input, size);
-        }
         assert(handle->audioIoHandle);
 
-        CAudioIO* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
+        CAudioIO* inputHandle = static_cast<CAudioInput*>(handle->audioIoHandle);
         if (inputHandle == NULL) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
         }
         *size = inputHandle->getBufferSize();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -689,14 +626,13 @@ int cpp_audio_in_get_sample_rate(audio_in_h input, int *sample_rate) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
 
     try {
-        if (handle == NULL || sample_rate == NULL) {
+        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);
-        }
         assert(handle->audioIoHandle);
 
         *sample_rate = handle->audioIoHandle->getAudioInfo().getSampleRate();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -708,10 +644,9 @@ int cpp_audio_in_get_channel(audio_in_h input, audio_channel_e *channel) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
 
     try {
-        if (handle == NULL || channel == NULL) {
+        if (handle == NULL || channel == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL input:%p, channel:%p", input, channel);
-        }
         assert(handle->audioIoHandle);
 
         const CAudioInfo::EChannel srcChannel = handle->audioIoHandle->getAudioInfo().getChannel();
@@ -719,7 +654,7 @@ int cpp_audio_in_get_channel(audio_in_h input, audio_channel_e *channel) {
         __convert_audio_info_channel_2_channel(srcChannel, dstChannel);
 
         *channel = dstChannel;
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -731,10 +666,9 @@ int cpp_audio_in_get_sample_type(audio_in_h input, audio_sample_type_e *type) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
 
     try {
-        if (handle == NULL || type == NULL) {
+        if (handle == NULL || type == NULL)
             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();
@@ -742,94 +676,7 @@ int cpp_audio_in_get_sample_type(audio_in_h input, audio_sample_type_e *type) {
         __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 AUDIO_IO_ERROR_NONE;
-}
-
-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);
-
-    assert(handle);
-
-    if (handle->interrupt_callback.onInterrupt) {
-        handle->interrupt_callback.onInterrupt(code, handle->interrupt_callback.user_data);
-    }
-}
-
-int cpp_audio_in_set_interrupted_cb(audio_in_h input, audio_io_interrupted_cb callback, void *user_data) {
-    audio_io_s* handle = static_cast<audio_io_s*>(input);
-
-    try {
-        if (handle == NULL || callback == NULL) {
-            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;
-
-        CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
-        cb.mUserData = static_cast<void*>(handle);
-        cb.onInterrupt = __interrupt_cb_internal;
-
-        handle->audioIoHandle->setInterruptCallback(cb);
-    } catch (CAudioError e) {
-        AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return __convert_CAudioError(e);
-    }
-
-    return AUDIO_IO_ERROR_NONE;
-}
-
-int cpp_audio_in_unset_interrupted_cb(audio_in_h input) {
-    audio_io_s* handle = static_cast<audio_io_s*>(input);
-
-    try {
-        if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
-                                   "Parameters are NULL input:%p", input);
-        }
-        assert(handle->audioIoHandle);
-
-        handle->interrupt_callback.onInterrupt = NULL;
-        handle->interrupt_callback.user_data    = NULL;
-
-        CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
-        cb.mUserData = NULL;
-        cb.onInterrupt = NULL;
-
-        handle->audioIoHandle->setInterruptCallback(cb);
-    } catch (CAudioError e) {
-        AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return __convert_CAudioError(e);
-    }
-
-    return AUDIO_IO_ERROR_NONE;
-}
-
-int cpp_audio_in_ignore_session(audio_in_h input) {
-    audio_io_s* handle = static_cast<audio_io_s*>(input);
-
-    try {
-        if (handle == NULL) {
-            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");
-        }
-        assert(handle->audioIoHandle);
-
-        handle->audioIoHandle->ignoreSession();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -841,9 +688,8 @@ 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) {
+    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,
@@ -853,22 +699,21 @@ static void __state_changed_cb_internal(CAudioInfo::EAudioIOState state,
     audio_io_s* audioIo = static_cast<audio_io_s*>(user_data);
     assert(audioIo);
 
-    if (audioIo->state_changed_callback.onStateChanged) {
+    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);
-    }
 }
 
 int cpp_audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, void* user_data) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
 
     try {
-        if (handle == NULL || callback == NULL) {
+        if (handle == NULL || callback == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL input:%p, callback:%p", input, callback);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p], callback:[%p], user_data:[%p]", handle, callback, user_data);
 
         handle->stream_callback.onStream = callback;
         handle->stream_callback.user_data = user_data;
@@ -878,11 +723,13 @@ int cpp_audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, vo
         cb.onStream  = __stream_cb_internal;
 
         handle->audioIoHandle->setStreamCallback(cb);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] done", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -890,11 +737,11 @@ int cpp_audio_in_unset_stream_cb(audio_in_h input) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
 
     try {
-        if (handle == NULL) {
+        if (handle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL input:%p", input);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p]", handle);
 
         handle->stream_callback.onStream = NULL;
         handle->stream_callback.user_data = NULL;
@@ -904,11 +751,13 @@ int cpp_audio_in_unset_stream_cb(audio_in_h input) {
         cb.onStream  = NULL;
 
         handle->audioIoHandle->setStreamCallback(cb);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] done", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -917,16 +766,16 @@ int cpp_audio_in_peek(audio_in_h input, const void **buffer, unsigned int *lengt
     size_t _length = 0;
 
     try {
-        if (handle == NULL || buffer == NULL) {
+        if (handle == NULL || buffer == NULL)
             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);
-        assert(inputHandle);
+        CAudioInput* inputHandle = static_cast<CAudioInput*>(handle->audioIoHandle);
+        if (inputHandle == NULL)
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
 
         inputHandle->peek(buffer, &_length);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -940,16 +789,16 @@ int cpp_audio_in_drop(audio_in_h input) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
 
     try {
-        if (handle == NULL) {
+        if (handle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL input:%p", input);
-        }
 
-        CAudioInput* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
-        assert(inputHandle);
+        CAudioInput* inputHandle = static_cast<CAudioInput*>(handle->audioIoHandle);
+        if (inputHandle == NULL)
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
 
         inputHandle->drop();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -961,11 +810,11 @@ int cpp_audio_in_set_state_changed_cb(audio_in_h input, audio_in_state_changed_c
     audio_io_s* handle = static_cast<audio_io_s*>(input);
 
     try {
-        if (handle == NULL || callback == NULL) {
+        if (handle == NULL || callback == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL input:%p, callback:%p", input, callback);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p], callback:[%p], user_data:[%p]", handle, callback, user_data);
 
         handle->state_changed_callback.onStateChanged = callback;
         handle->state_changed_callback.user_data = user_data;
@@ -975,11 +824,13 @@ int cpp_audio_in_set_state_changed_cb(audio_in_h input, audio_in_state_changed_c
         cb.onStateChanged = __state_changed_cb_internal;
 
         handle->audioIoHandle->setStateChangedCallback(cb);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] done", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -987,11 +838,11 @@ int cpp_audio_in_unset_state_changed_cb(audio_in_h input) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
 
     try {
-        if (handle == NULL) {
+        if (handle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL output:%p", input);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p]", handle);
 
         handle->state_changed_callback.onStateChanged = NULL;
         handle->state_changed_callback.user_data = NULL;
@@ -1001,11 +852,13 @@ int cpp_audio_in_unset_state_changed_cb(audio_in_h input) {
         cb.onStateChanged  = NULL;
 
         handle->audioIoHandle->setStateChangedCallback(cb);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] done", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -1013,88 +866,32 @@ int cpp_audio_in_unset_state_changed_cb(audio_in_h input) {
 /**
  * Audio Out
  */
-int cpp_audio_out_create(int sample_rate, audio_channel_e channel, audio_sample_type_e type, sound_type_e sound_type, audio_out_h *output) {
-    audio_io_s* handle = NULL;
-    try {
-        if (output == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
-                                   "Parameters are NULL output:%p", output);
-        }
-
-        __check_audio_param(sample_rate, channel, type, sound_type);
-
-        handle = new audio_io_s;
-        if (handle == NULL) {
-            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
-        }
-
-        CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, sound_type);
-
-        handle->audioIoHandle = new CAudioOutput(audioInfo);
-        if (handle->audioIoHandle == NULL) {
-            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
-        }
-
-        handle->audioIoHandle->initialize();
-
-        *output = handle;
-    } catch (CAudioError e) {
-        AUDIO_IO_LOGE("%s", e.getErrorMsg());
-
-        VALID_POINTER_START(handle)
-            SAFE_FINALIZE(handle->audioIoHandle);
-            SAFE_DELETE(handle->audioIoHandle);
-            SAFE_DELETE(handle);
-        VALID_POINTER_END
-
-        VALID_POINTER_START(output)
-            *output = NULL;
-        VALID_POINTER_END
-
-        return __convert_CAudioError(e);
-    }
-
-    return AUDIO_IO_ERROR_NONE;
-}
-
 int cpp_audio_out_create_new(int sample_rate, audio_channel_e channel, audio_sample_type_e type, audio_out_h *output) {
     audio_io_s* handle = NULL;
     try {
-        if (output == NULL) {
+        if (output == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL output:%p", output);
-        }
 
         __check_audio_param(sample_rate, channel, type, SOUND_TYPE_SYSTEM /*default check */);
 
-        handle = new audio_io_s;
-        if (handle == NULL) {
-            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
-        }
-
+        AUDIO_IO_LOGD("samplerate:[%d] channel:[0x%x] sample_type:[0x%x]", sample_rate, channel, type);
         CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, SOUND_TYPE_MEDIA);
 
+        handle = new audio_io_s;
         handle->audioIoHandle = new CAudioOutput(audioInfo);
-        if (handle->audioIoHandle == NULL) {
-            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
-        }
-
         handle->audioIoHandle->initialize();
 
+        AUDIO_IO_LOGD("[%p] created", handle);
         *output = handle;
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-
-        VALID_POINTER_START(handle)
-            SAFE_FINALIZE(handle->audioIoHandle);
-            SAFE_DELETE(handle->audioIoHandle);
-            SAFE_DELETE(handle);
-        VALID_POINTER_END
-
-        VALID_POINTER_START(output)
-            *output = NULL;
-        VALID_POINTER_END
-
+        __handle_safe_free(handle, (void *)output, true);
+        return __convert_CAudioError(e);
+    } catch (const std::bad_alloc&) {
+        CAudioError e = CAudioError::EError::ERROR_OUT_OF_MEMORY;
+        AUDIO_IO_LOGE("Failed to allocate handle");
+        __handle_safe_free(handle, (void *)output, true);
         return __convert_CAudioError(e);
     }
 
@@ -1105,11 +902,11 @@ int cpp_audio_out_destroy(audio_out_h output) {
     audio_io_s* handle = static_cast<audio_io_s*>(output);
 
     try {
-        if (handle == NULL) {
+        if (handle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameter is NULL output:%p", output);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p]", handle);
 
         /* Internal unprepare for backward compatibility */
         handle->audioIoHandle->unprepare();
@@ -1117,11 +914,13 @@ int cpp_audio_out_destroy(audio_out_h output) {
         SAFE_FINALIZE(handle->audioIoHandle);
         SAFE_DELETE(handle->audioIoHandle);
         SAFE_DELETE(handle);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("destroyed");
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -1129,18 +928,20 @@ int cpp_audio_out_set_sound_stream_info(audio_out_h output, sound_stream_info_h
     audio_io_s* handle = static_cast<audio_io_s*>(output);
 
     try {
-        if (handle == NULL || stream_info == NULL) {
+        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);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p], stream_info:[%p]", handle, stream_info);
 
         handle->audioIoHandle->setStreamInfo(stream_info);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] done", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -1148,18 +949,20 @@ int cpp_audio_out_prepare(audio_out_h output) {
     audio_io_s* handle = static_cast<audio_io_s*>(output);
 
     try {
-        if (handle == NULL) {
+        if (handle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameter is NULL output:%p", output);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p]", handle);
 
         handle->audioIoHandle->prepare();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] prepared", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -1167,18 +970,20 @@ int cpp_audio_out_unprepare(audio_out_h output) {
     audio_io_s* handle = static_cast<audio_io_s*>(output);
 
     try {
-        if (handle == NULL) {
+        if (handle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameter is NULL output:%p", output);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p]", handle);
 
         handle->audioIoHandle->unprepare();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] unprepared", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -1186,18 +991,20 @@ int cpp_audio_out_pause(audio_out_h output) {
     audio_io_s* handle = static_cast<audio_io_s*>(output);
 
     try {
-        if (handle == NULL) {
+        if (handle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameter is NULL output:%p", output);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p]", handle);
 
         handle->audioIoHandle->pause();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] paused", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -1205,18 +1012,20 @@ int cpp_audio_out_resume(audio_out_h output) {
     audio_io_s* handle = static_cast<audio_io_s*>(output);
 
     try {
-        if (handle == NULL) {
+        if (handle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameter is NULL output:%p", output);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p]", handle);
 
         handle->audioIoHandle->resume();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] resumed", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -1224,18 +1033,20 @@ int cpp_audio_out_drain(audio_out_h output) {
     audio_io_s* handle = static_cast<audio_io_s*>(output);
 
     try {
-        if (handle == NULL) {
+        if (handle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameter is NULL output:%p", output);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p]", handle);
 
         handle->audioIoHandle->drain();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] drained", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -1243,18 +1054,20 @@ int cpp_audio_out_flush(audio_out_h output) {
     audio_io_s* handle = static_cast<audio_io_s*>(output);
 
     try {
-        if (handle == NULL) {
+        if (handle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameter is NULL output:%p", output);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p]", handle);
 
         handle->audioIoHandle->flush();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] flushed", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -1263,23 +1076,21 @@ int cpp_audio_out_write(audio_out_h output, void *buffer, unsigned int length) {
     int ret = 0;
 
     try {
-        if (handle == NULL || buffer == NULL) {
+        if (handle == NULL || buffer == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameter is NULL output:%p, buffer:%p", output, buffer);
-        }
         assert(handle->audioIoHandle);
 
-        CAudioOutput* outputHandle = dynamic_cast<CAudioOutput*>(handle->audioIoHandle);
-        if (outputHandle == NULL) {
+        CAudioOutput* outputHandle = static_cast<CAudioOutput*>(handle->audioIoHandle);
+        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_
         AUDIO_IO_LOGD("written:%d", written);
 #endif
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1291,18 +1102,17 @@ int cpp_audio_out_get_buffer_size(audio_out_h output, int *size) {
     audio_io_s* handle = static_cast<audio_io_s*>(output);
 
     try {
-        if (handle == NULL || size == NULL) {
+        if (handle == NULL || size == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL output:%p, size:%p", output, size);
-        }
         assert(handle->audioIoHandle);
 
-        CAudioOutput* outputHandle = dynamic_cast<CAudioOutput*>(handle->audioIoHandle);
-        if (outputHandle == NULL) {
+        CAudioOutput* outputHandle = static_cast<CAudioOutput*>(handle->audioIoHandle);
+        if (outputHandle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
-        }
+
         *size = outputHandle->getBufferSize();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1314,14 +1124,13 @@ int cpp_audio_out_get_sample_rate(audio_out_h output, int *sample_rate) {
     audio_io_s* handle = static_cast<audio_io_s*>(output);
 
     try {
-        if (handle == NULL || sample_rate == NULL) {
+        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);
-        }
         assert(handle->audioIoHandle);
 
         *sample_rate = handle->audioIoHandle->getAudioInfo().getSampleRate();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1333,10 +1142,9 @@ int cpp_audio_out_get_channel(audio_out_h output, audio_channel_e *channel) {
     audio_io_s* handle = static_cast<audio_io_s*>(output);
 
     try {
-        if (handle == NULL || channel == NULL) {
+        if (handle == NULL || channel == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL output:%p, channel:%p", output, channel);
-        }
         assert(handle->audioIoHandle);
 
         const CAudioInfo::EChannel srcChannel = handle->audioIoHandle->getAudioInfo().getChannel();
@@ -1344,7 +1152,7 @@ int cpp_audio_out_get_channel(audio_out_h output, audio_channel_e *channel) {
         __convert_audio_info_channel_2_channel(srcChannel, dstChannel);
 
         *channel = dstChannel;
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1356,18 +1164,17 @@ int cpp_audio_out_get_sample_type(audio_out_h output, audio_sample_type_e *type)
     audio_io_s* handle = static_cast<audio_io_s*>(output);
 
     try {
-        if (handle == NULL || type == NULL) {
+        if (handle == NULL || type == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL output:%p, type:%p", output, 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;
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1379,94 +1186,17 @@ int cpp_audio_out_get_sound_type(audio_out_h output, sound_type_e *type) {
     audio_io_s* handle = static_cast<audio_io_s*>(output);
 
     try {
-        if (handle == NULL || type == NULL) {
+        if (handle == NULL || type == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL output:%p, type:%p", output, type);
-        }
         assert(handle->audioIoHandle);
 
         const CAudioInfo::EAudioType srcAudioType = handle->audioIoHandle->getAudioInfo().getAudioType();
-        sound_type_e                 dstSoundType = SOUND_TYPE_MEDIA;
+        sound_type_e dstSoundType = SOUND_TYPE_MEDIA;
         __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 AUDIO_IO_ERROR_NONE;
-}
-
-int cpp_audio_out_set_interrupted_cb(audio_out_h output, audio_io_interrupted_cb callback, void *user_data) {
-    audio_io_s* handle = static_cast<audio_io_s*>(output);
-
-    try {
-        if (handle == NULL || callback == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
-                                   "Parameters are NULL output:%p, callback:%p", output, callback);
-        }
-        assert(handle->audioIoHandle);
-
-        handle->interrupt_callback.onInterrupt = callback;
-        handle->interrupt_callback.user_data    = user_data;
-
-        CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
-        cb.mUserData   = static_cast<void*>(handle);
-        cb.onInterrupt = __interrupt_cb_internal;
-
-        handle->audioIoHandle->setInterruptCallback(cb);
-    } catch (CAudioError e) {
-        AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return __convert_CAudioError(e);
-    }
-
-    return AUDIO_IO_ERROR_NONE;
-}
-
-int cpp_audio_out_unset_interrupted_cb(audio_out_h output) {
-    audio_io_s* handle = static_cast<audio_io_s*>(output);
-
-    try {
-        if (handle == NULL) {
-            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;
-
-        CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
-        cb.mUserData = NULL;
-        cb.onInterrupt = NULL;
-
-        handle->audioIoHandle->setInterruptCallback(cb);
-    } catch (CAudioError e) {
-        AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return __convert_CAudioError(e);
-    }
-
-    return AUDIO_IO_ERROR_NONE;
-}
-
-int cpp_audio_out_ignore_session(audio_out_h output) {
-    audio_io_s* handle = static_cast<audio_io_s*>(output);
-
-    try {
-        if (handle == NULL) {
-            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");
-        }
-        assert(handle->audioIoHandle);
-
-        handle->audioIoHandle->ignoreSession();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1478,25 +1208,27 @@ int cpp_audio_out_set_stream_cb(audio_out_h output, audio_out_stream_cb callback
     audio_io_s* handle = static_cast<audio_io_s*>(output);
 
     try {
-        if (handle == NULL || callback == NULL) {
+        if (handle == NULL || callback == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL output:%p, callback:%p", output, callback);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p], callback:[%p], user_data:[%p]", handle, callback, user_data);
 
         handle->stream_callback.onStream = callback;
         handle->stream_callback.user_data = user_data;
 
         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) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] done", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -1504,11 +1236,11 @@ int cpp_audio_out_unset_stream_cb(audio_out_h output) {
     audio_io_s* handle = static_cast<audio_io_s*>(output);
 
     try {
-        if (handle == NULL) {
+        if (handle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL output:%p", output);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p]", handle);
 
         handle->stream_callback.onStream = NULL;
         handle->stream_callback.user_data = NULL;
@@ -1518,11 +1250,13 @@ int cpp_audio_out_unset_stream_cb(audio_out_h output) {
         cb.onStream = NULL;
 
         handle->audioIoHandle->setStreamCallback(cb);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] done", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -1530,11 +1264,11 @@ int cpp_audio_out_set_state_changed_cb(audio_out_h output, audio_in_state_change
     audio_io_s* handle = static_cast<audio_io_s*>(output);
 
     try {
-        if (handle == NULL || callback == NULL) {
+        if (handle == NULL || callback == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL output:%p, callback:%p", output, callback);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p], callback:[%p], user_data:[%p]", handle, callback, user_data);
 
         handle->state_changed_callback.onStateChanged = callback;
         handle->state_changed_callback.user_data = user_data;
@@ -1544,11 +1278,13 @@ int cpp_audio_out_set_state_changed_cb(audio_out_h output, audio_in_state_change
         cb.onStateChanged = __state_changed_cb_internal;
 
         handle->audioIoHandle->setStateChangedCallback(cb);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] done", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -1556,11 +1292,11 @@ int cpp_audio_out_unset_state_changed_cb(audio_out_h output) {
     audio_io_s* handle = static_cast<audio_io_s*>(output);
 
     try {
-        if (handle == NULL) {
+        if (handle == NULL)
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL output:%p", output);
-        }
         assert(handle->audioIoHandle);
+        AUDIO_IO_LOGD("[%p]", handle);
 
         handle->state_changed_callback.onStateChanged = NULL;
         handle->state_changed_callback.user_data = NULL;
@@ -1570,10 +1306,12 @@ int cpp_audio_out_unset_state_changed_cb(audio_out_h output) {
         cb.onStateChanged = NULL;
 
         handle->audioIoHandle->setStateChangedCallback(cb);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
 
+    AUDIO_IO_LOGD("[%p] done", handle);
+
     return AUDIO_IO_ERROR_NONE;
 }
Domain: Multimedia / Audio FW;