From: Sangchul Lee <sc11.lee@samsung.com>
Date: Tue, 7 Feb 2017 04:52:15 +0000 (+0900)
Subject: Refactor codes of setting stream info. and add support for setting internal stream... 
X-Git-Tag: accepted/tizen/3.0/common/20170210.071153^0
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=009097fb79fea3db5e6b7f257e127b6d00b77627;p=platform%2Fcore%2Fapi%2Faudio-io.git

Refactor codes of setting stream info. and add support for setting internal stream info. in case of VoIP session

[Version] 0.3.65
[Profile] Common
[Issue Type] Refactorying and backward compatibility

Change-Id: I514f08eb6e39b329afb42c5fd676fea2e04a0cb3
Signed-off-by: Sangchul Lee <sc11.lee@samsung.com>
---

diff --git a/include/CAudioIO.h b/include/CAudioIO.h
index 98f2b0d..43e0e29 100644
--- a/include/CAudioIO.h
+++ b/include/CAudioIO.h
@@ -97,6 +97,10 @@ namespace tizen_media_audio {
 
         void ignoreSession() throw(CAudioError);
 
+        void setStreamInfo(sound_stream_info_h stream_info) throw(CAudioError);
+
+        void setInternalStreamInfo() throw(CAudioError); /* this is for session backward compatibility and will be removed later */
+
         CAudioInfo::EAudioIOState getState();
 
     protected:
@@ -112,6 +116,7 @@ namespace tizen_media_audio {
 
         bool isForceIgnore();
 
+        CAudioInfo::EAudioDirection mDirection;
         CAudioSessionHandler* mpAudioSessionHandler;
         CPulseAudioClient*    mpPulseAudioClient;
         CAudioInfo            mAudioInfo;
diff --git a/include/CAudioInfo.h b/include/CAudioInfo.h
index 00236a7..ff312eb 100644
--- a/include/CAudioInfo.h
+++ b/include/CAudioInfo.h
@@ -87,6 +87,12 @@ namespace tizen_media_audio {
             AUDIO_IO_STATE_MAX
         };
 
+        enum class EAudioDirection : unsigned int {
+            AUDIO_DIRECTION_IN,       /**< Audio direction input */
+            AUDIO_DIRECTION_OUT,      /**< Audio direction output */
+            AUDIO_DIRECTION_MAX
+        };
+
         const static unsigned int MIN_SYSTEM_SAMPLERATE = 8000;
         const static unsigned int MAX_SYSTEM_SAMPLERATE = 48000;
 
diff --git a/include/CAudioSessionHandler.h b/include/CAudioSessionHandler.h
index 4117360..054403d 100644
--- a/include/CAudioSessionHandler.h
+++ b/include/CAudioSessionHandler.h
@@ -25,6 +25,8 @@
 #include <mm_session_private.h>
 #include <mm_sound.h>
 #include <mm_sound_focus.h>
+#include <sound_manager.h>
+#include <sound_manager_internal.h>
 
 namespace tizen_media_audio {
 
@@ -61,6 +63,7 @@ namespace tizen_media_audio {
         int getOptions();
         EAudioSessionType  getAudioSession();
         MMSessionType      getMultimediaSession();
+        void getInternalVoipStreamInfo(sound_stream_info_h *stream_info);
         unsigned int getSubscribeId();
         CAudioInfo getAudioInfo();
 
diff --git a/packaging/capi-media-audio-io.spec b/packaging/capi-media-audio-io.spec
index f348dd6..cf2e0c5 100644
--- a/packaging/capi-media-audio-io.spec
+++ b/packaging/capi-media-audio-io.spec
@@ -1,6 +1,6 @@
 Name:           capi-media-audio-io
 Summary:        An Audio Input & Audio Output library in Tizen Native API
-Version:        0.3.64
+Version:        0.3.65
 Release:        0
 Group:          Multimedia/API
 License:        Apache-2.0
diff --git a/src/cpp/CAudioIO.cpp b/src/cpp/CAudioIO.cpp
index 8b6c1b0..71f38fe 100644
--- a/src/cpp/CAudioIO.cpp
+++ b/src/cpp/CAudioIO.cpp
@@ -466,7 +466,6 @@ CAudioIO::SInterruptCallback CAudioIO::getInterruptCallback() throw(CAudioError)
     return mInterruptCallback;
 }
 
-
 void CAudioIO::ignoreSession() throw(CAudioError) {
     if (__mIsInit == false)
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
@@ -490,3 +489,66 @@ void CAudioIO::ignoreSession() throw(CAudioError) {
         throw e;
     }
 }
+
+void CAudioIO::setStreamInfo(sound_stream_info_h stream_info) throw(CAudioError) {
+    if (stream_info == NULL)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_ARGUMENT, "stream_info is NULL");
+
+    if (__mIsInit == false)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
+
+    try {
+        if (mState != CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE)
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_STATE, "it is not permitted while started");
+
+        int errorCode = SOUND_MANAGER_ERROR_NONE;
+        CAudioInfo::EAudioType audioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA;
+        char *type = NULL;
+        int index = -1;
+        bool avail = false;
+
+        if ((errorCode = sound_manager_is_available_stream_information(stream_info, NATIVE_API_AUDIO_IO, &avail)) != SOUND_MANAGER_ERROR_NONE)
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info is invalid [ret:%d]", errorCode);
+
+        if (!avail)
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE, "Input stream is not supported");
+
+        if ((errorCode = sound_manager_get_type_from_stream_information(stream_info, &type)) != SOUND_MANAGER_ERROR_NONE)
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->stream_type is invalid [ret:%d]", errorCode);
+
+        if (mDirection == CAudioInfo::EAudioDirection::AUDIO_DIRECTION_IN)
+            getAudioInfo().convertInputStreamType2AudioType(type, &audioType);
+        else
+            getAudioInfo().convertOutputStreamType2AudioType(type, &audioType);
+        getAudioInfo().setAudioType(audioType);
+
+        if ((errorCode = sound_manager_get_index_from_stream_information(stream_info, &index)) != SOUND_MANAGER_ERROR_NONE)
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->index is invalid [ret:%d]", errorCode);
+
+        getAudioInfo().setAudioIndex(index);
+
+        AUDIO_IO_LOGD("stream info(%p) is set", stream_info);
+    } catch (CAudioError e) {
+        throw e;
+    }
+}
+
+void CAudioIO::setInternalStreamInfo() throw(CAudioError) {
+    if (__mIsInit == false)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
+
+    try {
+        if (mState != CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE)
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_STATE, "it is not permitted while started");
+
+        if (mpAudioSessionHandler &&
+            mpAudioSessionHandler->getMultimediaSession() == MM_SESSION_TYPE_VOIP) {
+            sound_stream_info_h stream_info = NULL;
+            mpAudioSessionHandler->getInternalVoipStreamInfo(&stream_info);
+            AUDIO_IO_LOGD("get internal VOIP stream info(%p)", stream_info);
+            setStreamInfo(stream_info);
+        }
+    } catch (CAudioError e) {
+        throw e;
+    }
+}
diff --git a/src/cpp/CAudioInput.cpp b/src/cpp/CAudioInput.cpp
index bb184e1..2e489d2 100644
--- a/src/cpp/CAudioInput.cpp
+++ b/src/cpp/CAudioInput.cpp
@@ -37,6 +37,7 @@ CAudioInput::CAudioInput(CAudioInfo& info) :
     CAudioIO(info),
     __mIsUsedSyncRead(true),
     __mIsInit(false) {
+    mDirection = CAudioInfo::EAudioDirection::AUDIO_DIRECTION_IN;
 }
 
 CAudioInput::CAudioInput(
@@ -46,6 +47,7 @@ CAudioInput::CAudioInput(
         CAudioInfo::EAudioType  audioType) :
     __mIsUsedSyncRead(true),
     __mIsInit(false) {
+    mDirection = CAudioInfo::EAudioDirection::AUDIO_DIRECTION_IN;
     mAudioInfo = CAudioInfo(sampleRate, channel, type, audioType, -1);
 }
 
@@ -269,6 +271,8 @@ void CAudioInput::prepare() throw(CAudioError) {
             }
         }
 
+        CAudioIO::setInternalStreamInfo();
+
         // Init StreamSpec
         AUDIO_IO_LOGD("Set Stream Spec : CPulseStreamSpec::STREAM_LATENCY_INPUT_DEFAULT");
         CPulseStreamSpec::EStreamLatency streamSpec = CPulseStreamSpec::EStreamLatency::STREAM_LATENCY_INPUT_DEFAULT;
diff --git a/src/cpp/CAudioOutput.cpp b/src/cpp/CAudioOutput.cpp
index c2a517d..0fdcdc2 100644
--- a/src/cpp/CAudioOutput.cpp
+++ b/src/cpp/CAudioOutput.cpp
@@ -28,6 +28,7 @@ CAudioOutput::CAudioOutput(CAudioInfo& info) :
     CAudioIO(info),
     __mIsUsedSyncWrite(false),
     __mIsInit(false) {
+    mDirection = CAudioInfo::EAudioDirection::AUDIO_DIRECTION_OUT;
 }
 
 CAudioOutput::CAudioOutput(
@@ -37,6 +38,7 @@ CAudioOutput::CAudioOutput(
         CAudioInfo::EAudioType  audioType) :
     __mIsUsedSyncWrite(false),
     __mIsInit(false) {
+    mDirection = CAudioInfo::EAudioDirection::AUDIO_DIRECTION_OUT;
     mAudioInfo = CAudioInfo(sampleRate, channel, sampleType, audioType, -1);
 }
 
@@ -161,6 +163,8 @@ void CAudioOutput::prepare() throw(CAudioError) {
             }
         }
 
+        CAudioIO::setInternalStreamInfo();
+
         // Init StreamSpec
         AUDIO_IO_LOGD("Set Stream Spec : CPulseStreamSpec::STREAM_LATENCY_OUTPUT_DEFAULT");
         CPulseStreamSpec::EStreamLatency streamSpec = CPulseStreamSpec::EStreamLatency::STREAM_LATENCY_OUTPUT_DEFAULT;
diff --git a/src/cpp/CAudioSessionHandler.cpp b/src/cpp/CAudioSessionHandler.cpp
index 904bf93..dd1cd8d 100644
--- a/src/cpp/CAudioSessionHandler.cpp
+++ b/src/cpp/CAudioSessionHandler.cpp
@@ -176,6 +176,19 @@ MMSessionType CAudioSessionHandler::getMultimediaSession() {
     return __mMultimediaSession;
 }
 
+void CAudioSessionHandler::getInternalVoipStreamInfo(sound_stream_info_h *stream_info) {
+    int ret;
+
+    if ((ret = sound_manager_get_internal_voip_stream_information(stream_info))) {
+        if (ret == SOUND_MANAGER_ERROR_NO_DATA) {
+            AUDIO_IO_LOGW("there's no internal voip stream info.");
+        } else {
+            AUDIO_IO_LOGE("failed to sound_manager_get_internal_voip_stream_information(), ret(0x%x)", ret);
+        }
+    }
+    return;
+}
+
 unsigned int CAudioSessionHandler::getSubscribeId() {
     return __mSubscribeId;
 }
diff --git a/src/cpp/cpp_audio_io.cpp b/src/cpp/cpp_audio_io.cpp
index 4096a88..c2300cd 100644
--- a/src/cpp/cpp_audio_io.cpp
+++ b/src/cpp/cpp_audio_io.cpp
@@ -484,7 +484,6 @@ int cpp_audio_in_destroy(audio_in_h input) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                   "Parameters are NULL input:%p", input);
         }
-
         assert(handle->audioIoHandle);
 
         /* Internal unprepare for backward compatibility */
@@ -509,33 +508,9 @@ int cpp_audio_in_set_sound_stream_info(audio_in_h input, sound_stream_info_h str
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL input:%p, stream_info:%p", input, stream_info);
         }
-
         assert(handle->audioIoHandle);
 
-        int errorCode = SOUND_MANAGER_ERROR_NONE;
-        CAudioInfo::EAudioType audioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA;
-        char *type = NULL;
-        int index = -1;
-        bool avail = false;
-
-        if ((errorCode = sound_manager_is_available_stream_information(stream_info, NATIVE_API_AUDIO_IO, &avail)) != SOUND_MANAGER_ERROR_NONE) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info is invalid [ret:%d]", errorCode);
-        }
-
-        if (avail) {
-            if ((errorCode = sound_manager_get_type_from_stream_information(stream_info, &type)) != SOUND_MANAGER_ERROR_NONE) {
-                THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->stream_type is invalid [ret:%d]", errorCode);
-            }
-            handle->audioIoHandle->getAudioInfo().convertInputStreamType2AudioType(type, &audioType);
-            handle->audioIoHandle->getAudioInfo().setAudioType(audioType);
-
-            if ((errorCode = sound_manager_get_index_from_stream_information(stream_info, &index)) != SOUND_MANAGER_ERROR_NONE) {
-                THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->index is invalid [ret:%d]", errorCode);
-            }
-            handle->audioIoHandle->getAudioInfo().setAudioIndex(index);
-        } else {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE, "Input stream is not supported");
-        }
+        handle->audioIoHandle->setStreamInfo(stream_info);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
@@ -552,7 +527,6 @@ int cpp_audio_in_prepare(audio_in_h input) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL input:%p", input);
         }
-
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->prepare();
@@ -648,7 +622,6 @@ int cpp_audio_in_flush(audio_in_h input) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL input:%p", input);
         }
-
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->flush();
@@ -697,7 +670,6 @@ int cpp_audio_in_get_buffer_size(audio_in_h input, int *size) {
             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);
@@ -721,8 +693,8 @@ int cpp_audio_in_get_sample_rate(audio_in_h input, int *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);
+
         *sample_rate = handle->audioIoHandle->getAudioInfo().getSampleRate();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
@@ -740,7 +712,6 @@ int cpp_audio_in_get_channel(audio_in_h input, audio_channel_e *channel) {
             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();
@@ -798,7 +769,6 @@ int cpp_audio_in_set_interrupted_cb(audio_in_h input, audio_io_interrupted_cb ca
             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;
@@ -825,7 +795,6 @@ int cpp_audio_in_unset_interrupted_cb(audio_in_h input) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL input:%p", input);
         }
-
         assert(handle->audioIoHandle);
 
         handle->interrupt_callback.onInterrupt = NULL;
@@ -857,7 +826,6 @@ int cpp_audio_in_ignore_session(audio_in_h input) {
             THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
                             "Not support ignore session in async mode");
         }
-
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->ignoreSession();
@@ -900,7 +868,6 @@ int cpp_audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, vo
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL input:%p, callback:%p", input, callback);
         }
-
         assert(handle->audioIoHandle);
 
         handle->stream_callback.onStream = callback;
@@ -927,7 +894,6 @@ int cpp_audio_in_unset_stream_cb(audio_in_h input) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL input:%p", input);
         }
-
         assert(handle->audioIoHandle);
 
         handle->stream_callback.onStream = NULL;
@@ -999,7 +965,6 @@ int cpp_audio_in_set_state_changed_cb(audio_in_h input, audio_in_state_changed_c
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL input:%p, callback:%p", input, callback);
         }
-
         assert(handle->audioIoHandle);
 
         handle->state_changed_callback.onStateChanged = callback;
@@ -1026,7 +991,6 @@ int cpp_audio_in_unset_state_changed_cb(audio_in_h input) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL output:%p", input);
         }
-
         assert(handle->audioIoHandle);
 
         handle->state_changed_callback.onStateChanged = NULL;
@@ -1145,7 +1109,6 @@ int cpp_audio_out_destroy(audio_out_h output) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameter is NULL output:%p", output);
         }
-
         assert(handle->audioIoHandle);
 
         /* Internal unprepare for backward compatibility */
@@ -1170,34 +1133,9 @@ int cpp_audio_out_set_sound_stream_info(audio_out_h output, sound_stream_info_h
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL output:%p, stream_info:%p", output, stream_info);
         }
-
         assert(handle->audioIoHandle);
 
-        int errorCode = SOUND_MANAGER_ERROR_NONE;
-        CAudioInfo::EAudioType audioType = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
-        char *type = NULL;
-        int index = -1;
-        bool avail = false;
-
-        if ((errorCode = sound_manager_is_available_stream_information(stream_info, NATIVE_API_AUDIO_IO, &avail)) != SOUND_MANAGER_ERROR_NONE) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info is invalid [ret:%d]", errorCode);
-        }
-
-        if (avail) {
-            if ((errorCode = sound_manager_get_type_from_stream_information(stream_info, &type)) != SOUND_MANAGER_ERROR_NONE) {
-                THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->stream_type is invalid [ret:%d]", errorCode);
-            }
-            handle->audioIoHandle->getAudioInfo().convertOutputStreamType2AudioType(type, &audioType);
-            handle->audioIoHandle->getAudioInfo().setAudioType(audioType);
-
-            if ((errorCode = sound_manager_get_index_from_stream_information(stream_info, &index)) != SOUND_MANAGER_ERROR_NONE) {
-                THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->index is invalid [ret:%d]", errorCode);
-            }
-            handle->audioIoHandle->getAudioInfo().setAudioIndex(index);
-        } else {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE,
-                                   "Output stream is not supported");
-        }
+        handle->audioIoHandle->setStreamInfo(stream_info);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
@@ -1214,7 +1152,6 @@ int cpp_audio_out_prepare(audio_out_h output) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameter is NULL output:%p", output);
         }
-
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->prepare();
@@ -1234,7 +1171,6 @@ int cpp_audio_out_unprepare(audio_out_h output) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameter is NULL output:%p", output);
         }
-
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->unprepare();
@@ -1254,7 +1190,6 @@ int cpp_audio_out_pause(audio_out_h output) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameter is NULL output:%p", output);
         }
-
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->pause();
@@ -1274,7 +1209,6 @@ int cpp_audio_out_resume(audio_out_h output) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameter is NULL output:%p", output);
         }
-
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->resume();
@@ -1294,7 +1228,6 @@ int cpp_audio_out_drain(audio_out_h output) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameter is NULL output:%p", output);
         }
-
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->drain();
@@ -1314,7 +1247,6 @@ int cpp_audio_out_flush(audio_out_h output) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameter is NULL output:%p", output);
         }
-
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->flush();
@@ -1335,7 +1267,6 @@ int cpp_audio_out_write(audio_out_h output, void *buffer, unsigned int length) {
             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);
@@ -1364,7 +1295,6 @@ int cpp_audio_out_get_buffer_size(audio_out_h output, int *size) {
             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);
@@ -1388,8 +1318,8 @@ int cpp_audio_out_get_sample_rate(audio_out_h output, int *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);
+
         *sample_rate = handle->audioIoHandle->getAudioInfo().getSampleRate();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
@@ -1407,7 +1337,6 @@ int cpp_audio_out_get_channel(audio_out_h output, audio_channel_e *channel) {
             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();
@@ -1431,7 +1360,6 @@ int cpp_audio_out_get_sample_type(audio_out_h output, audio_sample_type_e *type)
             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();
@@ -1455,7 +1383,6 @@ int cpp_audio_out_get_sound_type(audio_out_h output, sound_type_e *type) {
             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();
@@ -1479,7 +1406,6 @@ int cpp_audio_out_set_interrupted_cb(audio_out_h output, audio_io_interrupted_cb
             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;
@@ -1506,7 +1432,6 @@ int cpp_audio_out_unset_interrupted_cb(audio_out_h output) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL output:%p", output);
         }
-
         assert(handle->audioIoHandle);
 
         handle->interrupt_callback.onInterrupt = NULL;
@@ -1538,7 +1463,6 @@ int cpp_audio_out_ignore_session(audio_out_h output) {
             THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION,
                             "Not support ignore session in async mode");
         }
-
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->ignoreSession();
@@ -1558,7 +1482,6 @@ int cpp_audio_out_set_stream_cb(audio_out_h output, audio_out_stream_cb callback
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL output:%p, callback:%p", output, callback);
         }
-
         assert(handle->audioIoHandle);
 
         handle->stream_callback.onStream = callback;
@@ -1585,7 +1508,6 @@ int cpp_audio_out_unset_stream_cb(audio_out_h output) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL output:%p", output);
         }
-
         assert(handle->audioIoHandle);
 
         handle->stream_callback.onStream = NULL;
@@ -1612,7 +1534,6 @@ int cpp_audio_out_set_state_changed_cb(audio_out_h output, audio_in_state_change
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL output:%p, callback:%p", output, callback);
         }
-
         assert(handle->audioIoHandle);
 
         handle->state_changed_callback.onStateChanged = callback;
@@ -1639,7 +1560,6 @@ int cpp_audio_out_unset_state_changed_cb(audio_out_h output) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
                                    "Parameters are NULL output:%p", output);
         }
-
         assert(handle->audioIoHandle);
 
         handle->state_changed_callback.onStateChanged = NULL;