revise conversion utility functions

Change-Id: I503db61756e851be77558e147d3e4ade68f5e867

diff --git a/src/cpp/cpp_audio_io.cpp b/src/cpp/cpp_audio_io.cpp
index c184b9c..c02ced7 100644 (file)
--- a/src/cpp/cpp_audio_io.cpp
+++ b/src/cpp/cpp_audio_io.cpp
@@ -38,8 +38,7 @@ typedef struct audio_io_stream_cb_s {
     void* user_data;
     audio_in_stream_cb onStream;
 
-    audio_io_stream_cb_s() : user_data(nullptr), onStream(nullptr)
-    {/* Empty Body */}
+    audio_io_stream_cb_s() : user_data(nullptr), onStream(nullptr) { }
 
     void set(audio_in_stream_cb callback, void* userdata) {
         onStream = callback;
@@ -62,8 +61,7 @@ typedef struct audio_io_state_changed_cb_s {
     void* user_data;
     audio_in_state_changed_cb onStateChanged;
 
-    audio_io_state_changed_cb_s() : user_data(nullptr), onStateChanged(nullptr)
-    {/* Empty Body */}
+    audio_io_state_changed_cb_s() : user_data(nullptr), onStateChanged(nullptr) { }
 
     void set(audio_in_state_changed_cb callback, void* userdata) {
         onStateChanged = callback;
@@ -91,8 +89,7 @@ typedef struct audio_io_s {
     audio_io_stream_cb_s stream_callback;
     audio_io_state_changed_cb_s state_changed_callback;
 
-    audio_io_s() : audioIoHandle(nullptr)
-    {/* Empty Body */}
+    audio_io_s() : audioIoHandle(nullptr) { }
 }   audio_io_s;
 
 
@@ -100,261 +97,185 @@ 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;
-    CAudioError::EError err = error.getError();
-
-    switch (err) {
+    switch (error.getError()) {
     case CAudioError::EError::ERROR_NONE:
-        ret = AUDIO_IO_ERROR_NONE;
-        break;
+        return AUDIO_IO_ERROR_NONE;
     case CAudioError::EError::ERROR_INVALID_ARGUMENT:
     case CAudioError::EError::ERROR_INVALID_HANDLE:
     case CAudioError::EError::ERROR_INVALID_SAMPLERATE:
     case CAudioError::EError::ERROR_INVALID_CHANNEL:
     case CAudioError::EError::ERROR_INVALID_FORMAT:
-        ret = AUDIO_IO_ERROR_INVALID_PARAMETER;
-        break;
+        return AUDIO_IO_ERROR_INVALID_PARAMETER;
     case CAudioError::EError::ERROR_DEVICE_NOT_OPENED:
-        ret = AUDIO_IO_ERROR_DEVICE_NOT_OPENED;
-        break;
+        return AUDIO_IO_ERROR_DEVICE_NOT_OPENED;
     case CAudioError::EError::ERROR_DEVICE_NOT_CLOSED:
-        ret = AUDIO_IO_ERROR_DEVICE_NOT_CLOSED;
-        break;
+        return AUDIO_IO_ERROR_DEVICE_NOT_CLOSED;
     case CAudioError::EError::ERROR_PERMISSION_DENIED:
-        ret = AUDIO_IO_ERROR_PERMISSION_DENIED;
-        break;
+        return AUDIO_IO_ERROR_PERMISSION_DENIED;
     case CAudioError::EError::ERROR_DEVICE_POLICY_RESTRICTION:
-        ret = AUDIO_IO_ERROR_DEVICE_POLICY_RESTRICTION;
-        break;
+        return AUDIO_IO_ERROR_DEVICE_POLICY_RESTRICTION;
     case CAudioError::EError::ERROR_NOT_SUPPORTED:
-        ret = AUDIO_IO_ERROR_NOT_SUPPORTED;
-        break;
+        return AUDIO_IO_ERROR_NOT_SUPPORTED;
     case CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE:
-        ret = AUDIO_IO_ERROR_NOT_SUPPORTED_TYPE;
-        break;
+        return AUDIO_IO_ERROR_NOT_SUPPORTED_TYPE;
     case CAudioError::EError::ERROR_MAX:
     case CAudioError::EError::ERROR_INTERNAL_OPERATION:
     case CAudioError::EError::ERROR_NOT_INITIALIZED:
     case CAudioError::EError::ERROR_FAILED_OPERATION:
     case CAudioError::EError::ERROR_INVALID_OPERATION:
-        ret = AUDIO_IO_ERROR_INVALID_OPERATION;
-        break;
+        return AUDIO_IO_ERROR_INVALID_OPERATION;
     case CAudioError::EError::ERROR_INVALID_STATE:
-        ret = AUDIO_IO_ERROR_INVALID_STATE;
-        break;
+        return AUDIO_IO_ERROR_INVALID_STATE;
     case CAudioError::EError::ERROR_OUT_OF_MEMORY:
     case CAudioError::EError::ERROR_INVALID_POINTER:
-        ret = AUDIO_IO_ERROR_INVALID_BUFFER;
-        break;
+        return AUDIO_IO_ERROR_INVALID_BUFFER;
     case CAudioError::EError::ERROR_POLICY_BLOCKED:
     case CAudioError::EError::ERROR_POLICY_INTERRUPTED:
     case CAudioError::EError::ERROR_POLICY_DUPLICATED:
-        ret = AUDIO_IO_ERROR_SOUND_POLICY;
-        break;
+        return AUDIO_IO_ERROR_SOUND_POLICY;
+    default:
+        return AUDIO_IO_ERROR_NONE;
     }
-
-    return ret;
 }
 
-static void __convert_channel_2_audio_info_channel(const audio_channel_e& src_channel,
-                                                   CAudioInfo::EChannel& dst_channel) {
+static CAudioInfo::EChannel __convert_channel_to_audio_info_channel(const audio_channel_e &src_channel) {
     switch (src_channel) {
     case AUDIO_CHANNEL_MONO:
-        dst_channel = CAudioInfo::EChannel::CHANNEL_MONO;
-        break;
+        return CAudioInfo::EChannel::CHANNEL_MONO;
     case AUDIO_CHANNEL_STEREO:
-        dst_channel = CAudioInfo::EChannel::CHANNEL_STEREO;
-        break;
+        return CAudioInfo::EChannel::CHANNEL_STEREO;
     case AUDIO_CHANNEL_MULTI_3:
-        dst_channel = CAudioInfo::EChannel::CHANNEL_MULTI_3;
-        break;
+        return CAudioInfo::EChannel::CHANNEL_MULTI_3;
     case AUDIO_CHANNEL_MULTI_4:
-        dst_channel = CAudioInfo::EChannel::CHANNEL_MULTI_4;
-        break;
+        return CAudioInfo::EChannel::CHANNEL_MULTI_4;
     case AUDIO_CHANNEL_MULTI_5:
-        dst_channel = CAudioInfo::EChannel::CHANNEL_MULTI_5;
-        break;
+        return CAudioInfo::EChannel::CHANNEL_MULTI_5;
     case AUDIO_CHANNEL_MULTI_6:
-        dst_channel = CAudioInfo::EChannel::CHANNEL_MULTI_6;
-        break;
+        return CAudioInfo::EChannel::CHANNEL_MULTI_6;
     case AUDIO_CHANNEL_MULTI_7:
-        dst_channel = CAudioInfo::EChannel::CHANNEL_MULTI_7;
-        break;
+        return CAudioInfo::EChannel::CHANNEL_MULTI_7;
     case AUDIO_CHANNEL_MULTI_8:
-        dst_channel = CAudioInfo::EChannel::CHANNEL_MULTI_8;
-        break;
+        return CAudioInfo::EChannel::CHANNEL_MULTI_8;
     default:
-        dst_channel = CAudioInfo::EChannel::CHANNEL_MONO;
-        break;
+        return CAudioInfo::EChannel::CHANNEL_MONO;
     }
 }
 
-static void __convert_audio_info_channel_2_channel(const CAudioInfo::EChannel& src_channel,
-                                                   audio_channel_e& dst_channel) {
+static audio_channel_e __convert_audio_info_channel_to_channel(const CAudioInfo::EChannel& src_channel) {
     switch (src_channel) {
     case CAudioInfo::EChannel::CHANNEL_MONO:
-        dst_channel = AUDIO_CHANNEL_MONO;
-        break;
+        return AUDIO_CHANNEL_MONO;
     case CAudioInfo::EChannel::CHANNEL_STEREO:
-        dst_channel = AUDIO_CHANNEL_STEREO;
-        break;
+        return AUDIO_CHANNEL_STEREO;
     case CAudioInfo::EChannel::CHANNEL_MULTI_3:
-        dst_channel = AUDIO_CHANNEL_MULTI_3;
-        break;
+        return AUDIO_CHANNEL_MULTI_3;
     case CAudioInfo::EChannel::CHANNEL_MULTI_4:
-        dst_channel = AUDIO_CHANNEL_MULTI_4;
-        break;
+        return AUDIO_CHANNEL_MULTI_4;
     case CAudioInfo::EChannel::CHANNEL_MULTI_5:
-        dst_channel = AUDIO_CHANNEL_MULTI_5;
-        break;
+        return AUDIO_CHANNEL_MULTI_5;
     case CAudioInfo::EChannel::CHANNEL_MULTI_6:
-        dst_channel = AUDIO_CHANNEL_MULTI_6;
-        break;
+        return AUDIO_CHANNEL_MULTI_6;
     case CAudioInfo::EChannel::CHANNEL_MULTI_7:
-        dst_channel = AUDIO_CHANNEL_MULTI_7;
-        break;
+        return AUDIO_CHANNEL_MULTI_7;
     case CAudioInfo::EChannel::CHANNEL_MULTI_8:
-        dst_channel = AUDIO_CHANNEL_MULTI_8;
-        break;
+        return AUDIO_CHANNEL_MULTI_8;
     default:
-        dst_channel = AUDIO_CHANNEL_MONO;
-        break;
+        return AUDIO_CHANNEL_MONO;
     }
 }
 
-static void __convert_sample_type_2_audio_info_sample_type(const audio_sample_type_e& src_type,
-                                                           CAudioInfo::ESampleType& dst_type) {
+static CAudioInfo::ESampleType __convert_sample_type_to_audio_info_sample_type(const audio_sample_type_e& src_type) {
     switch (src_type) {
     case AUDIO_SAMPLE_TYPE_U8:
-        dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_U8;
-        break;
+        return CAudioInfo::ESampleType::SAMPLE_TYPE_U8;
     case AUDIO_SAMPLE_TYPE_S16_LE:
-        dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_S16_LE;
-        break;
+        return CAudioInfo::ESampleType::SAMPLE_TYPE_S16_LE;
     case AUDIO_SAMPLE_TYPE_S24_LE:
-        dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_S24_LE;
-        break;
+        return CAudioInfo::ESampleType::SAMPLE_TYPE_S24_LE;
     case AUDIO_SAMPLE_TYPE_S24_32_LE:
-        dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_S24_32_LE;
-        break;
+        return CAudioInfo::ESampleType::SAMPLE_TYPE_S24_32_LE;
     case AUDIO_SAMPLE_TYPE_S32_LE:
-        dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_S32_LE;
-        break;
+        return CAudioInfo::ESampleType::SAMPLE_TYPE_S32_LE;
     default:
-        dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_U8;
-        break;
+        return CAudioInfo::ESampleType::SAMPLE_TYPE_U8;
     }
 }
 
-static void __convert_audio_info_sample_type_2_sample_type(const CAudioInfo::ESampleType& src_type,
-                                                           audio_sample_type_e& dst_type) {
+static audio_sample_type_e __convert_audio_info_sample_type_to_sample_type(const CAudioInfo::ESampleType &src_type) {
     switch (src_type) {
     case CAudioInfo::ESampleType::SAMPLE_TYPE_U8:
-        dst_type = AUDIO_SAMPLE_TYPE_U8;
-        break;
+        return AUDIO_SAMPLE_TYPE_U8;
     case CAudioInfo::ESampleType::SAMPLE_TYPE_S16_LE:
-        dst_type = AUDIO_SAMPLE_TYPE_S16_LE;
-        break;
+        return AUDIO_SAMPLE_TYPE_S16_LE;
     case CAudioInfo::ESampleType::SAMPLE_TYPE_S24_LE:
-        dst_type = AUDIO_SAMPLE_TYPE_S24_LE;
-        break;
+        return AUDIO_SAMPLE_TYPE_S24_LE;
     case CAudioInfo::ESampleType::SAMPLE_TYPE_S24_32_LE:
-        dst_type = AUDIO_SAMPLE_TYPE_S24_32_LE;
-        break;
+        return AUDIO_SAMPLE_TYPE_S24_32_LE;
     case CAudioInfo::ESampleType::SAMPLE_TYPE_S32_LE:
-        dst_type = AUDIO_SAMPLE_TYPE_S32_LE;
-        break;
+        return AUDIO_SAMPLE_TYPE_S32_LE;
     default:
-        dst_type = AUDIO_SAMPLE_TYPE_U8;
-        break;
+        return AUDIO_SAMPLE_TYPE_U8;
     }
 }
 
-static void __convert_sound_type_2_audio_info_audio_type(const sound_type_e& src_type,
-                                                         CAudioInfo::EAudioType& dst_type) {
+static  CAudioInfo::EAudioType __convert_sound_type_to_audio_info_audio_type(const sound_type_e &src_type) {
     switch (src_type) {
     case SOUND_TYPE_SYSTEM:
-        dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM;
-        break;
+        return CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM;
     case SOUND_TYPE_NOTIFICATION:
-        dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_NOTIFICATION;
-        break;
+        return CAudioInfo::EAudioType::AUDIO_OUT_TYPE_NOTIFICATION;
     case SOUND_TYPE_ALARM:
-        dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_ALARM;
-        break;
+        return CAudioInfo::EAudioType::AUDIO_OUT_TYPE_ALARM;
     case SOUND_TYPE_RINGTONE:
-        dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_RINGTONE_VOIP;
-        break;
+        return CAudioInfo::EAudioType::AUDIO_OUT_TYPE_RINGTONE_VOIP;
     case SOUND_TYPE_MEDIA:
-        dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
-        break;
+        return CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
     case SOUND_TYPE_CALL:
-        dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM;
-        break;
+        return CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM;
     case SOUND_TYPE_VOIP:
-        dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOIP;
-        break;
+        return CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOIP;
     case SOUND_TYPE_VOICE:
-        dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOICE_INFORMATION;
-        break;
+        return CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOICE_INFORMATION;
     default:
-        dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
-        break;
+        return CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
     }
 }
 
-static void __convert_audio_info_audio_type_2_sound_type(const CAudioInfo::EAudioType& src_type,
-                                                         sound_type_e& dst_type) {
+static sound_type_e __convert_audio_info_audio_type_to_sound_type(const CAudioInfo::EAudioType &src_type) {
     switch (src_type) {
     case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA:
-        dst_type = SOUND_TYPE_MEDIA;
-        break;
+        return SOUND_TYPE_MEDIA;
     case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM:
-        dst_type = SOUND_TYPE_SYSTEM;
-        break;
+        return SOUND_TYPE_SYSTEM;
     case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_ALARM:
-        dst_type = SOUND_TYPE_ALARM;
-        break;
+        return SOUND_TYPE_ALARM;
     case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_NOTIFICATION:
     case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_EMERGENCY:
-        dst_type = SOUND_TYPE_NOTIFICATION;
-        break;
+        return SOUND_TYPE_NOTIFICATION;
     case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOICE_INFORMATION:
-        dst_type = SOUND_TYPE_VOICE;
-        break;
+        return SOUND_TYPE_VOICE;
     case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_RINGTONE_VOIP:
-        dst_type = SOUND_TYPE_RINGTONE;
-        break;
+        return SOUND_TYPE_RINGTONE;
     case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOIP:
-        dst_type = SOUND_TYPE_VOIP;
-        break;
+        return SOUND_TYPE_VOIP;
     default:
-        dst_type = SOUND_TYPE_MEDIA;
-        break;
+        return SOUND_TYPE_MEDIA;
     }
 }
 
 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;
-        break;
+        return AUDIO_IO_STATE_IDLE;
     case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE:
-        dst_state = AUDIO_IO_STATE_IDLE;
-        break;
+        return AUDIO_IO_STATE_IDLE;
     case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING:
-        dst_state = AUDIO_IO_STATE_RUNNING;
-        break;
+        return AUDIO_IO_STATE_RUNNING;
     case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED:
-        dst_state = AUDIO_IO_STATE_PAUSED;
-        break;
+        return AUDIO_IO_STATE_PAUSED;
     default:
-        dst_state = AUDIO_IO_STATE_IDLE;
-        break;
+        return AUDIO_IO_STATE_IDLE;
     }
-    return dst_state;
 }
 
 static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type, bool is_output) {
@@ -372,26 +293,19 @@ static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_
 }
 
 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;
-
-    __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);
+    return CAudioInfo(sampleRate,
+            __convert_channel_to_audio_info_channel(channel),
+            __convert_sample_type_to_audio_info_sample_type(sample_type),
+            CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA,
+            -1);
 }
 
 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;
-
-    __convert_channel_2_audio_info_channel(channel, dstChannel);
-    __convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
-    __convert_sound_type_2_audio_info_audio_type(sound_type, dstAudioType);
-
-    return CAudioInfo(sampleRate, dstChannel, dstSampleType, dstAudioType, -1);
+    return CAudioInfo(sampleRate,
+                      __convert_channel_to_audio_info_channel(channel),
+                      __convert_sample_type_to_audio_info_sample_type(sample_type),
+                      __convert_sound_type_to_audio_info_audio_type(sound_type),
+                      -1);
 }
 
 static void __handle_safe_free(audio_io_s* handle, void *obj, bool is_output) {
@@ -679,11 +593,7 @@ int cpp_audio_in_get_channel(audio_in_h input, audio_channel_e *channel) {
                                    "Parameters are NULL input:%p, channel:%p", input, channel);
         assert(handle->audioIoHandle);
 
-        auto srcChannel = handle->audioIoHandle->getAudioInfo().getChannel();
-        auto dstChannel = AUDIO_CHANNEL_MONO;
-        __convert_audio_info_channel_2_channel(srcChannel, dstChannel);
-
-        *channel = dstChannel;
+        *channel = __convert_audio_info_channel_to_channel(handle->audioIoHandle->getAudioInfo().getChannel());
     } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
@@ -700,11 +610,7 @@ int cpp_audio_in_get_sample_type(audio_in_h input, audio_sample_type_e *type) {
                                    "Parameters are NULL input:%p, type:%p", input, type);
         assert(handle->audioIoHandle);
 
-        auto srcSampleType = handle->audioIoHandle->getAudioInfo().getSampleType();
-        auto dstSampleType = AUDIO_SAMPLE_TYPE_U8;
-        __convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType);
-
-        *type = dstSampleType;
+        *type = __convert_audio_info_sample_type_to_sample_type(handle->audioIoHandle->getAudioInfo().getSampleType());
     } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
@@ -1166,11 +1072,7 @@ int cpp_audio_out_get_channel(audio_out_h output, audio_channel_e *channel) {
                                    "Parameters are NULL output:%p, channel:%p", output, channel);
         assert(handle->audioIoHandle);
 
-        auto srcChannel = handle->audioIoHandle->getAudioInfo().getChannel();
-        auto dstChannel = AUDIO_CHANNEL_MONO;
-        __convert_audio_info_channel_2_channel(srcChannel, dstChannel);
-
-        *channel = dstChannel;
+        *channel = __convert_audio_info_channel_to_channel(handle->audioIoHandle->getAudioInfo().getChannel());
     } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
@@ -1187,11 +1089,7 @@ int cpp_audio_out_get_sample_type(audio_out_h output, audio_sample_type_e *type)
                                    "Parameters are NULL output:%p, type:%p", output, type);
         assert(handle->audioIoHandle);
 
-        auto srcSampleType = handle->audioIoHandle->getAudioInfo().getSampleType();
-        auto dstSampleType = AUDIO_SAMPLE_TYPE_U8;
-        __convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType);
-
-        *type = dstSampleType;
+        *type = __convert_audio_info_sample_type_to_sample_type(handle->audioIoHandle->getAudioInfo().getSampleType());
     } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
@@ -1209,11 +1107,7 @@ int cpp_audio_out_get_sound_type(audio_out_h output, sound_type_e *type) {
                                    "Parameters are NULL output:%p, type:%p", output, type);
         assert(handle->audioIoHandle);
 
-        auto srcAudioType = handle->audioIoHandle->getAudioInfo().getAudioType();
-        auto dstSoundType = SOUND_TYPE_MEDIA;
-        __convert_audio_info_audio_type_2_sound_type(srcAudioType, dstSoundType);
-
-        *type = dstSoundType;
+        *type = __convert_audio_info_audio_type_to_sound_type(handle->audioIoHandle->getAudioInfo().getAudioType());
     } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);