X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fcpp%2Fcpp_audio_io.cpp;h=283cb8491c8c12b213fe09a3120cafdc13f00f06;hb=dd3afbfd568c2b0b61c6d9e13fe16c0d9d5d0f51;hp=fe5565274226b402af5b09388cef380474c20476;hpb=987d619e83678c5aee16770ea612d253c89c598f;p=platform%2Fcore%2Fapi%2Faudio-io.git diff --git a/src/cpp/cpp_audio_io.cpp b/src/cpp/cpp_audio_io.cpp index fe55652..283cb84 100644 --- a/src/cpp/cpp_audio_io.cpp +++ b/src/cpp/cpp_audio_io.cpp @@ -22,6 +22,7 @@ #include "CAudioIODef.h" #include +#include #define FEATURE_MICROPHONE "http://tizen.org/feature/microphone" @@ -38,8 +39,17 @@ typedef struct audio_io_stream_cb_s { void* user_data; audio_in_stream_cb onStream; - audio_io_stream_cb_s() : user_data(NULL), onStream(NULL) - {/* Empty Body */} + audio_io_stream_cb_s() : user_data(nullptr), onStream(nullptr) { } + + void set(audio_in_stream_cb callback, void* userdata) { + onStream = callback; + user_data = userdata; + } + + void unset() { + onStream = nullptr; + user_data = nullptr; + } } audio_io_stream_cb_s; /** @@ -52,8 +62,18 @@ 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(NULL), onStateChanged(NULL) - {/* 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; + user_data = userdata; + } + + void unset() { + onStateChanged = nullptr; + user_data = nullptr; + } + } audio_io_state_changed_cb_s; /** @@ -70,272 +90,220 @@ 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(NULL) - {/* Empty Body */} + audio_io_s() : audioIoHandle(nullptr) { } } 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) { +static audio_io_error_e __convert_audio_io_error(CAudioError::EError error) { + switch (error) { 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: + return CAudioInfo::EChannel::CHANNEL_MULTI_3; + case AUDIO_CHANNEL_MULTI_4: + return CAudioInfo::EChannel::CHANNEL_MULTI_4; + case AUDIO_CHANNEL_MULTI_5: + return CAudioInfo::EChannel::CHANNEL_MULTI_5; + case AUDIO_CHANNEL_MULTI_6: + return CAudioInfo::EChannel::CHANNEL_MULTI_6; + case AUDIO_CHANNEL_MULTI_7: + return CAudioInfo::EChannel::CHANNEL_MULTI_7; + case AUDIO_CHANNEL_MULTI_8: + 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: + return AUDIO_CHANNEL_MULTI_3; + case CAudioInfo::EChannel::CHANNEL_MULTI_4: + return AUDIO_CHANNEL_MULTI_4; + case CAudioInfo::EChannel::CHANNEL_MULTI_5: + return AUDIO_CHANNEL_MULTI_5; + case CAudioInfo::EChannel::CHANNEL_MULTI_6: + return AUDIO_CHANNEL_MULTI_6; + case CAudioInfo::EChannel::CHANNEL_MULTI_7: + return AUDIO_CHANNEL_MULTI_7; + case CAudioInfo::EChannel::CHANNEL_MULTI_8: + 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: + 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: + 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) { - if (sample_rate < 0) +static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type, bool is_output) { + if (sample_rate < CAudioInfo::MIN_SYSTEM_SAMPLERATE || + sample_rate > CAudioInfo::MAX_SYSTEM_SAMPLERATE) 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 > ((is_output) ? AUDIO_CHANNEL_STEREO : AUDIO_CHANNEL_MULTI_8)) 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 && - type != AUDIO_SAMPLE_TYPE_S24_LE && - type != AUDIO_SAMPLE_TYPE_S24_32_LE) + if (type < AUDIO_SAMPLE_TYPE_U8 || + type > AUDIO_SAMPLE_TYPE_S32_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) { - __check_audio_param(sample_rate, channel, type); - - 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) { - 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) { @@ -347,9 +315,9 @@ static void __handle_safe_free(audio_io_s* handle, void *obj, bool is_output) { VALID_POINTER_START(obj) if (is_output) - *(audio_out_h *)obj = NULL; + *(audio_out_h *)obj = nullptr; else - *(audio_in_h *)obj = NULL; + *(audio_in_h *)obj = nullptr; VALID_POINTER_END } @@ -357,25 +325,23 @@ static void __handle_safe_free(audio_io_s* handle, void *obj, bool is_output) { * Implements CAPI functions */ int cpp_audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_type_e type, audio_in_h *input) { - audio_io_s* handle = NULL; + audio_io_s* handle = nullptr; bool mic_enable = false; - int ret = 0; + try { - if (input == NULL) { + if (!input) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input); - } - __check_audio_param(sample_rate, channel, type); + __check_audio_param(sample_rate, channel, type, false); 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); + int 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); - if (ret != SYSTEM_INFO_ERROR_NONE || !mic_enable) { + if (ret != SYSTEM_INFO_ERROR_NONE || !mic_enable) THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "System doesn't support microphone!"); - } CAudioInfo audioInfo = __generate_audio_input_info(sample_rate, channel, type); @@ -385,16 +351,15 @@ int cpp_audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_t AUDIO_IO_LOGD("[%p] created", handle); *input = handle; - } catch (CAudioError& e) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); __handle_safe_free(handle, (void *)input, false); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } catch (const std::bad_alloc&) { //LCOV_EXCL_START - 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); + return __convert_audio_io_error(CAudioError::EError::ERROR_OUT_OF_MEMORY); //LCOV_EXCL_STOP } @@ -402,10 +367,10 @@ int cpp_audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_t } int cpp_audio_in_destroy(audio_in_h input) { - audio_io_s* handle = static_cast(input); + auto handle = static_cast(input); try { - if (handle == NULL) + if (!handle) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input); assert(handle->audioIoHandle); @@ -417,9 +382,9 @@ int cpp_audio_in_destroy(audio_in_h input) { SAFE_FINALIZE(handle->audioIoHandle); SAFE_DELETE(handle->audioIoHandle); SAFE_DELETE(handle); - } catch (CAudioError& e) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("destroyed"); @@ -428,19 +393,19 @@ int cpp_audio_in_destroy(audio_in_h input) { } int cpp_audio_in_set_sound_stream_info(audio_in_h input, sound_stream_info_h stream_info) { - audio_io_s* handle = static_cast(input); + auto handle = static_cast(input); try { - if (handle == NULL || stream_info == NULL) + if (!handle || !stream_info) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, stream_info:%p", input, stream_info); assert(handle->audioIoHandle); AUDIO_IO_LOGD("[%p], stream_info:[%p]", handle, stream_info); handle->audioIoHandle->setStreamInfo(stream_info); - } catch (CAudioError& e) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] done", handle); @@ -449,19 +414,19 @@ int cpp_audio_in_set_sound_stream_info(audio_in_h input, sound_stream_info_h str } int cpp_audio_in_prepare(audio_in_h input) { - audio_io_s* handle = static_cast(input); + auto handle = static_cast(input); try { - if (handle == NULL) + if (!handle) 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 (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] prepared", handle); @@ -470,19 +435,19 @@ int cpp_audio_in_prepare(audio_in_h input) { } int cpp_audio_in_unprepare(audio_in_h input) { - audio_io_s* handle = static_cast(input); + auto handle = static_cast(input); try { - if (handle == NULL) + if (!handle) 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 (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] unprepared", handle); @@ -491,19 +456,19 @@ int cpp_audio_in_unprepare(audio_in_h input) { } int cpp_audio_in_pause(audio_in_h input) { - audio_io_s* handle = static_cast(input); + auto handle = static_cast(input); try { - if (handle == NULL) + if (!handle) 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 (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] paused", handle); @@ -512,19 +477,19 @@ int cpp_audio_in_pause(audio_in_h input) { } int cpp_audio_in_resume(audio_in_h input) { - audio_io_s* handle = static_cast(input); + auto handle = static_cast(input); try { - if (handle == NULL) + if (!handle) 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 (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] resumed", handle); @@ -533,19 +498,19 @@ int cpp_audio_in_resume(audio_in_h input) { } int cpp_audio_in_flush(audio_in_h input) { - audio_io_s* handle = static_cast(input); + auto handle = static_cast(input); try { - if (handle == NULL) + if (!handle) 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 (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] flushed", handle); @@ -554,119 +519,106 @@ int cpp_audio_in_flush(audio_in_h input) { } int cpp_audio_in_read(audio_in_h input, void *buffer, unsigned int length) { - audio_io_s* handle = static_cast(input); int ret = 0; try { - if (handle == NULL || buffer == NULL) + auto handle = static_cast(input); + if (!handle || !buffer) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, buffer:%p", input, buffer); assert(handle->audioIoHandle); - CAudioInput* inputHandle = static_cast(handle->audioIoHandle); - if (inputHandle == NULL) { + auto inputHandle = static_cast(handle->audioIoHandle); + if (!inputHandle) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL"); - } - size_t readn = inputHandle->read(buffer, static_cast(length)); + auto readn = inputHandle->read(buffer, static_cast(length)); ret = static_cast(readn); #ifdef _AUDIO_IO_DEBUG_TIMING_ - AUDIO_IO_LOGD("readn:%d", readn); + AUDIO_IO_LOGD("readn:%zu", readn); #endif - } catch (CAudioError& e) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } return ret; } int cpp_audio_in_get_buffer_size(audio_in_h input, int *size) { - audio_io_s* handle = static_cast(input); - try { - if (handle == NULL || size == NULL) + auto handle = static_cast(input); + if (!handle || !size) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, size:%p", input, size); assert(handle->audioIoHandle); - CAudioIO* inputHandle = static_cast(handle->audioIoHandle); - if (inputHandle == NULL) { + auto inputHandle = static_cast(handle->audioIoHandle); + if (!inputHandle) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL"); - } + *size = inputHandle->getBufferSize(); - } catch (CAudioError& e) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } return AUDIO_IO_ERROR_NONE; } int cpp_audio_in_get_sample_rate(audio_in_h input, int *sample_rate) { - audio_io_s* handle = static_cast(input); - try { - if (handle == NULL || sample_rate == NULL) + auto handle = static_cast(input); + if (!handle || !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) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } return AUDIO_IO_ERROR_NONE; } int cpp_audio_in_get_channel(audio_in_h input, audio_channel_e *channel) { - audio_io_s* handle = static_cast(input); - try { - if (handle == NULL || channel == NULL) + auto handle = static_cast(input); + if (!handle || !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(); - audio_channel_e dstChannel = AUDIO_CHANNEL_MONO; - __convert_audio_info_channel_2_channel(srcChannel, dstChannel); - - *channel = dstChannel; - } catch (CAudioError& e) { + *channel = __convert_audio_info_channel_to_channel(handle->audioIoHandle->getAudioInfo().getChannel()); + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } return AUDIO_IO_ERROR_NONE; } int cpp_audio_in_get_sample_type(audio_in_h input, audio_sample_type_e *type) { - audio_io_s* handle = static_cast(input); - try { - if (handle == NULL || type == NULL) + auto handle = static_cast(input); + if (!handle || !type) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, type:%p", input, type); assert(handle->audioIoHandle); - const CAudioInfo::ESampleType srcSampleType = handle->audioIoHandle->getAudioInfo().getSampleType(); - audio_sample_type_e dstSampleType = AUDIO_SAMPLE_TYPE_U8; - __convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType); - - *type = dstSampleType; - } catch (CAudioError& e) { + *type = __convert_audio_info_sample_type_to_sample_type(handle->audioIoHandle->getAudioInfo().getSampleType()); + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } return AUDIO_IO_ERROR_NONE; } static void __stream_cb_internal(size_t nbytes, void *user_data) { - audio_io_s* audioIo = static_cast(user_data); + auto audioIo = static_cast(user_data); assert(audioIo); if (audioIo->stream_callback.onStream) @@ -678,7 +630,7 @@ static void __state_changed_cb_internal(CAudioInfo::EAudioIOState state, CAudioInfo::EAudioIOState state_prev, bool by_policy, void *user_data) { - audio_io_s* audioIo = static_cast(user_data); + auto audioIo = static_cast(user_data); assert(audioIo); if (audioIo->state_changed_callback.onStateChanged) @@ -689,26 +641,24 @@ static void __state_changed_cb_internal(CAudioInfo::EAudioIOState state, //LCOV_EXCL_STOP 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(input); + auto handle = static_cast(input); try { - if (handle == NULL || callback == NULL) + if (!handle || !callback) 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; + handle->stream_callback.set(callback, user_data); - CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback(); - cb.mUserData = static_cast(handle); - cb.onStream = __stream_cb_internal; + auto cb = handle->audioIoHandle->getStreamCallback(); + cb.set(__stream_cb_internal, static_cast(handle)); handle->audioIoHandle->setStreamCallback(cb); - } catch (CAudioError& e) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] done", handle); @@ -717,26 +667,23 @@ int cpp_audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, vo } int cpp_audio_in_unset_stream_cb(audio_in_h input) { - audio_io_s* handle = static_cast(input); - + auto handle = static_cast(input); try { - if (handle == NULL) + if (!handle) 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; + handle->stream_callback.unset(); - CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback(); - cb.mUserData = NULL; - cb.onStream = NULL; + auto cb = handle->audioIoHandle->getStreamCallback(); + cb.unset(); handle->audioIoHandle->setStreamCallback(cb); - } catch (CAudioError& e) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] done", handle); @@ -745,22 +692,22 @@ int cpp_audio_in_unset_stream_cb(audio_in_h input) { } int cpp_audio_in_peek(audio_in_h input, const void **buffer, unsigned int *length) { - audio_io_s* handle = static_cast(input); size_t _length = 0; try { - if (handle == NULL || buffer == NULL) + auto handle = static_cast(input); + if (!handle || !buffer) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, buffer:%p", input, buffer); - CAudioInput* inputHandle = static_cast(handle->audioIoHandle); - if (inputHandle == NULL) - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL"); + auto inputHandle = static_cast(handle->audioIoHandle); + if (!inputHandle) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL"); // LCOV_EXCL_LINE inputHandle->peek(buffer, &_length); - } catch (CAudioError& e) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } *length = (unsigned int)_length; @@ -769,47 +716,44 @@ int cpp_audio_in_peek(audio_in_h input, const void **buffer, unsigned int *lengt } int cpp_audio_in_drop(audio_in_h input) { - audio_io_s* handle = static_cast(input); - try { - if (handle == NULL) + auto handle = static_cast(input); + if (!handle) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input); - CAudioInput* inputHandle = static_cast(handle->audioIoHandle); - if (inputHandle == NULL) - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL"); + auto inputHandle = static_cast(handle->audioIoHandle); + if (!inputHandle) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL"); // LCOV_EXCL_LINE inputHandle->drop(); - } catch (CAudioError& e) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } return AUDIO_IO_ERROR_NONE; } int cpp_audio_in_set_state_changed_cb(audio_in_h input, audio_in_state_changed_cb callback, void* user_data) { - audio_io_s* handle = static_cast(input); + auto handle = static_cast(input); try { - if (handle == NULL || callback == NULL) + if (!handle || !callback) 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; + handle->state_changed_callback.set(callback, user_data); - CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback(); - cb.mUserData = static_cast(handle); - cb.onStateChanged = __state_changed_cb_internal; + auto cb = handle->audioIoHandle->getStateChangedCallback(); + cb.set(__state_changed_cb_internal, static_cast(handle)); handle->audioIoHandle->setStateChangedCallback(cb); - } catch (CAudioError& e) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] done", handle); @@ -818,26 +762,49 @@ int cpp_audio_in_set_state_changed_cb(audio_in_h input, audio_in_state_changed_c } int cpp_audio_in_unset_state_changed_cb(audio_in_h input) { - audio_io_s* handle = static_cast(input); + auto handle = static_cast(input); try { - if (handle == NULL) + if (!handle) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, - "Parameters are NULL output:%p", input); + "Parameters are NULL input:%p", input); assert(handle->audioIoHandle); AUDIO_IO_LOGD("[%p]", handle); - handle->state_changed_callback.onStateChanged = NULL; - handle->state_changed_callback.user_data = NULL; + handle->state_changed_callback.unset(); - CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback(); - cb.mUserData = NULL; - cb.onStateChanged = NULL; + auto cb = handle->audioIoHandle->getStateChangedCallback(); + cb.unset(); handle->audioIoHandle->setStateChangedCallback(cb); - } catch (CAudioError& e) { + } catch (const CAudioError& e) { + AUDIO_IO_LOGE("%s", e.getErrorMsg()); + return __convert_audio_io_error(e.getError()); + } + + AUDIO_IO_LOGD("[%p] done", handle); + + return AUDIO_IO_ERROR_NONE; +} + +int cpp_audio_in_get_volume(audio_in_h input, double *volume) { + auto handle = static_cast(input); + + try { + if (!handle || !volume) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p, volume:%p", input, volume); + assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); + + auto input_handle = dynamic_cast(handle->audioIoHandle); + if (input_handle == nullptr) + return __convert_audio_io_error(CAudioError::EError::ERROR_INVALID_HANDLE); + + *volume = input_handle->getVolume(); + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] done", handle); @@ -845,18 +812,46 @@ int cpp_audio_in_unset_state_changed_cb(audio_in_h input) { return AUDIO_IO_ERROR_NONE; } +int cpp_audio_in_set_volume(audio_in_h input, double volume) { + auto handle = static_cast(input); + + try { + if (!handle) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p", input); + + if (volume < CAudioInfo::MIN_RECORD_VOLUME || volume > CAudioInfo::MAX_RECORD_VOLUME) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid volume: %f", volume); + + assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); + + auto input_handle = dynamic_cast(handle->audioIoHandle); + if (input_handle == nullptr) + return __convert_audio_io_error(CAudioError::EError::ERROR_INVALID_HANDLE); + + input_handle->setVolume(volume); + } catch (const CAudioError& e) { + AUDIO_IO_LOGE("%s", e.getErrorMsg()); + return __convert_audio_io_error(e.getError()); + } + + AUDIO_IO_LOGD("[%p] done", handle); + + return AUDIO_IO_ERROR_NONE; +} /** * Audio Out */ 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; + audio_io_s* handle = nullptr; try { - if (output == NULL) + if (!output) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output); - __check_audio_param(sample_rate, channel, type, SOUND_TYPE_SYSTEM /*default check */); + __check_audio_param(sample_rate, channel, type, true); 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); @@ -867,16 +862,15 @@ int cpp_audio_out_create_new(int sample_rate, audio_channel_e channel, audio_sam AUDIO_IO_LOGD("[%p] created", handle); *output = handle; - } catch (CAudioError& e) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); __handle_safe_free(handle, (void *)output, true); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } catch (const std::bad_alloc&) { //LCOV_EXCL_START - 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); + return __convert_audio_io_error(CAudioError::EError::ERROR_OUT_OF_MEMORY); //LCOV_EXCL_STOP } @@ -884,10 +878,10 @@ int cpp_audio_out_create_new(int sample_rate, audio_channel_e channel, audio_sam } int cpp_audio_out_destroy(audio_out_h output) { - audio_io_s* handle = static_cast(output); + auto handle = static_cast(output); try { - if (handle == NULL) + if (!handle) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output); assert(handle->audioIoHandle); @@ -899,30 +893,30 @@ int cpp_audio_out_destroy(audio_out_h output) { SAFE_FINALIZE(handle->audioIoHandle); SAFE_DELETE(handle->audioIoHandle); SAFE_DELETE(handle); - } catch (CAudioError& e) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } - AUDIO_IO_LOGD("destroyed"); + AUDIO_IO_LOGD("[%p] destroyed", handle); return AUDIO_IO_ERROR_NONE; } int cpp_audio_out_set_sound_stream_info(audio_out_h output, sound_stream_info_h stream_info) { - audio_io_s* handle = static_cast(output); + auto handle = static_cast(output); try { - if (handle == NULL || stream_info == NULL) + if (!handle || !stream_info) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, stream_info:%p", output, stream_info); assert(handle->audioIoHandle); AUDIO_IO_LOGD("[%p], stream_info:[%p]", handle, stream_info); handle->audioIoHandle->setStreamInfo(stream_info); - } catch (CAudioError& e) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] done", handle); @@ -931,19 +925,19 @@ int cpp_audio_out_set_sound_stream_info(audio_out_h output, sound_stream_info_h } int cpp_audio_out_prepare(audio_out_h output) { - audio_io_s* handle = static_cast(output); + auto handle = static_cast(output); try { - if (handle == NULL) + if (!handle) 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 (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] prepared", handle); @@ -952,19 +946,19 @@ int cpp_audio_out_prepare(audio_out_h output) { } int cpp_audio_out_unprepare(audio_out_h output) { - audio_io_s* handle = static_cast(output); + auto handle = static_cast(output); try { - if (handle == NULL) + if (!handle) 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 (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] unprepared", handle); @@ -973,19 +967,19 @@ int cpp_audio_out_unprepare(audio_out_h output) { } int cpp_audio_out_pause(audio_out_h output) { - audio_io_s* handle = static_cast(output); + auto handle = static_cast(output); try { - if (handle == NULL) + if (!handle) 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 (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] paused", handle); @@ -994,19 +988,19 @@ int cpp_audio_out_pause(audio_out_h output) { } int cpp_audio_out_resume(audio_out_h output) { - audio_io_s* handle = static_cast(output); + auto handle = static_cast(output); try { - if (handle == NULL) + if (!handle) 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 (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] resumed", handle); @@ -1015,19 +1009,23 @@ int cpp_audio_out_resume(audio_out_h output) { } int cpp_audio_out_drain(audio_out_h output) { - audio_io_s* handle = static_cast(output); + auto handle = static_cast(output); try { - if (handle == NULL) + if (!handle) 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) { + auto output_handle = dynamic_cast(handle->audioIoHandle); + if (output_handle == nullptr) + return __convert_audio_io_error(CAudioError::EError::ERROR_INVALID_HANDLE); + + output_handle->drain(); + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] drained", handle); @@ -1036,19 +1034,19 @@ int cpp_audio_out_drain(audio_out_h output) { } int cpp_audio_out_flush(audio_out_h output) { - audio_io_s* handle = static_cast(output); + auto handle = static_cast(output); try { - if (handle == NULL) + if (!handle) 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 (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] flushed", handle); @@ -1057,159 +1055,141 @@ int cpp_audio_out_flush(audio_out_h output) { } int cpp_audio_out_write(audio_out_h output, void *buffer, unsigned int length) { - audio_io_s* handle = static_cast(output); int ret = 0; try { - if (handle == NULL || buffer == NULL) + auto handle = static_cast(output); + if (!handle || !buffer) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p, buffer:%p", output, buffer); assert(handle->audioIoHandle); - CAudioOutput* outputHandle = static_cast(handle->audioIoHandle); - if (outputHandle == NULL) + auto outputHandle = static_cast(handle->audioIoHandle); + if (!outputHandle) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL"); - size_t written = outputHandle->write(buffer, static_cast(length)); + auto written = outputHandle->write(buffer, static_cast(length)); ret = static_cast(written); #ifdef _AUDIO_IO_DEBUG_TIMING_ - AUDIO_IO_LOGD("written:%d", written); + AUDIO_IO_LOGD("written:%zu", written); #endif - } catch (CAudioError& e) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } return ret; } int cpp_audio_out_get_buffer_size(audio_out_h output, int *size) { - audio_io_s* handle = static_cast(output); - try { - if (handle == NULL || size == NULL) + auto handle = static_cast(output); + if (!handle || !size) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, size:%p", output, size); assert(handle->audioIoHandle); - CAudioOutput* outputHandle = static_cast(handle->audioIoHandle); - if (outputHandle == NULL) + auto outputHandle = static_cast(handle->audioIoHandle); + if (!outputHandle) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL"); *size = outputHandle->getBufferSize(); - } catch (CAudioError& e) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } return AUDIO_IO_ERROR_NONE; } int cpp_audio_out_get_sample_rate(audio_out_h output, int *sample_rate) { - audio_io_s* handle = static_cast(output); - try { - if (handle == NULL || sample_rate == NULL) + auto handle = static_cast(output); + if (!handle || !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) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } return AUDIO_IO_ERROR_NONE; } int cpp_audio_out_get_channel(audio_out_h output, audio_channel_e *channel) { - audio_io_s* handle = static_cast(output); - try { - if (handle == NULL || channel == NULL) + auto handle = static_cast(output); + if (!handle || !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(); - audio_channel_e dstChannel = AUDIO_CHANNEL_MONO; - __convert_audio_info_channel_2_channel(srcChannel, dstChannel); - - *channel = dstChannel; - } catch (CAudioError& e) { + *channel = __convert_audio_info_channel_to_channel(handle->audioIoHandle->getAudioInfo().getChannel()); + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } return AUDIO_IO_ERROR_NONE; } int cpp_audio_out_get_sample_type(audio_out_h output, audio_sample_type_e *type) { - audio_io_s* handle = static_cast(output); - try { - if (handle == NULL || type == NULL) + auto handle = static_cast(output); + if (!handle || !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(); - audio_sample_type_e dstSampleType = AUDIO_SAMPLE_TYPE_U8; - __convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType); - - *type = dstSampleType; - } catch (CAudioError& e) { + *type = __convert_audio_info_sample_type_to_sample_type(handle->audioIoHandle->getAudioInfo().getSampleType()); + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } return AUDIO_IO_ERROR_NONE; } int cpp_audio_out_get_sound_type(audio_out_h output, sound_type_e *type) { - audio_io_s* handle = static_cast(output); + auto handle = static_cast(output); try { - if (handle == NULL || type == NULL) + if (!handle || !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(); - sound_type_e dstSoundType = SOUND_TYPE_MEDIA; - __convert_audio_info_audio_type_2_sound_type(srcAudioType, dstSoundType); - - *type = dstSoundType; - } catch (CAudioError& e) { + *type = __convert_audio_info_audio_type_to_sound_type(handle->audioIoHandle->getAudioInfo().getAudioType()); + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } return AUDIO_IO_ERROR_NONE; } int cpp_audio_out_set_stream_cb(audio_out_h output, audio_out_stream_cb callback, void* user_data) { - audio_io_s* handle = static_cast(output); + auto handle = static_cast(output); try { - if (handle == NULL || callback == NULL) + if (!handle || !callback) 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; + handle->stream_callback.set(callback, user_data); - CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback(); - cb.mUserData = static_cast(handle); - cb.onStream = __stream_cb_internal; + auto cb = handle->audioIoHandle->getStreamCallback(); + cb.set(__stream_cb_internal, static_cast(handle)); handle->audioIoHandle->setStreamCallback(cb); - } catch (CAudioError& e) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] done", handle); @@ -1218,26 +1198,24 @@ int cpp_audio_out_set_stream_cb(audio_out_h output, audio_out_stream_cb callback } int cpp_audio_out_unset_stream_cb(audio_out_h output) { - audio_io_s* handle = static_cast(output); + auto handle = static_cast(output); try { - if (handle == NULL) + if (!handle) 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; + handle->stream_callback.unset(); - CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback(); - cb.mUserData = NULL; - cb.onStream = NULL; + auto cb = handle->audioIoHandle->getStreamCallback(); + cb.unset(); handle->audioIoHandle->setStreamCallback(cb); - } catch (CAudioError& e) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] done", handle); @@ -1246,26 +1224,24 @@ int cpp_audio_out_unset_stream_cb(audio_out_h output) { } int cpp_audio_out_set_state_changed_cb(audio_out_h output, audio_in_state_changed_cb callback, void* user_data) { - audio_io_s* handle = static_cast(output); + auto handle = static_cast(output); try { - if (handle == NULL || callback == NULL) + if (!handle || !callback) 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; + handle->state_changed_callback.set(callback, user_data); - CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback(); - cb.mUserData = static_cast(handle); - cb.onStateChanged = __state_changed_cb_internal; + auto cb = handle->audioIoHandle->getStateChangedCallback(); + cb.set(__state_changed_cb_internal, static_cast(handle)); handle->audioIoHandle->setStateChangedCallback(cb); - } catch (CAudioError& e) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] done", handle); @@ -1274,26 +1250,24 @@ int cpp_audio_out_set_state_changed_cb(audio_out_h output, audio_in_state_change } int cpp_audio_out_unset_state_changed_cb(audio_out_h output) { - audio_io_s* handle = static_cast(output); + auto handle = static_cast(output); try { - if (handle == NULL) + if (!handle) 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; + handle->state_changed_callback.unset(); - CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback(); - cb.mUserData = NULL; - cb.onStateChanged = NULL; + auto cb = handle->audioIoHandle->getStateChangedCallback(); + cb.unset(); handle->audioIoHandle->setStateChangedCallback(cb); - } catch (CAudioError& e) { + } catch (const CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); + return __convert_audio_io_error(e.getError()); } AUDIO_IO_LOGD("[%p] done", handle);