X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fcpp%2Fcpp_audio_io.cpp;h=461291b892245bf0fc3ccdb1d71668a1a0d20717;hb=2284d1d4a0df0ad04a52045eeb5dcfc9c18d835a;hp=36babbc1a12f511668920d0799874a320f8318b1;hpb=13cfc707ef968f3a3da54d6287d208e8421b19f2;p=platform%2Fcore%2Fapi%2Faudio-io.git diff --git a/src/cpp/cpp_audio_io.cpp b/src/cpp/cpp_audio_io.cpp index 36babbc..461291b 100644 --- a/src/cpp/cpp_audio_io.cpp +++ b/src/cpp/cpp_audio_io.cpp @@ -15,8 +15,9 @@ */ +#include + #include "cpp_audio_io.h" -#include #include "audio_io.h" #include "CAudioIODef.h" @@ -27,21 +28,6 @@ using namespace std; using namespace tizen_media_audio; - -/** - * Defines Structures - * type : struct - * Name : audio_io_interrupted_cb_s - * Declaration : Keeps user callback pointer and user data for delivering an interrupt event - */ -typedef struct audio_io_interrupted_cb_s { - void* user_data; - audio_io_interrupted_cb onInterrupt; - - audio_io_interrupted_cb_s() : user_data(NULL), onInterrupt(NULL) - {/* Empty Body */} -} audio_io_interrupted_cb_s; - /** * Defines Structures * type : struct @@ -80,10 +66,9 @@ typedef struct audio_io_state_changed_cb_s { * The CAudioIO is a abstract class object about Input and Output */ typedef struct audio_io_s { - CAudioIO* audioIoHandle; - audio_io_interrupted_cb_s interrupt_callback; - audio_io_stream_cb_s stream_callback; - audio_io_state_changed_cb_s state_changed_callback; + CAudioIO* audioIoHandle; + audio_io_stream_cb_s stream_callback; + audio_io_state_changed_cb_s state_changed_callback; audio_io_s() : audioIoHandle(NULL) {/* Empty Body */} @@ -94,7 +79,7 @@ typedef struct audio_io_s { * Internal functions */ static audio_io_error_e __convert_CAudioError(CAudioError& error) { - audio_io_error_e ret = AUDIO_IO_ERROR_NONE; + audio_io_error_e ret = AUDIO_IO_ERROR_NONE; CAudioError::EError err = error.getError(); switch (err) { @@ -133,6 +118,9 @@ static audio_io_error_e __convert_CAudioError(CAudioError& error) { case CAudioError::EError::ERROR_INVALID_OPERATION: ret = AUDIO_IO_ERROR_INVALID_OPERATION; break; + case CAudioError::EError::ERROR_INVALID_STATE: + ret = AUDIO_IO_ERROR_INVALID_STATE; + break; case CAudioError::EError::ERROR_OUT_OF_MEMORY: case CAudioError::EError::ERROR_INVALID_POINTER: ret = AUDIO_IO_ERROR_INVALID_BUFFER; @@ -147,7 +135,8 @@ static audio_io_error_e __convert_CAudioError(CAudioError& error) { return ret; } -static void __convert_channel_2_audio_info_channel(const audio_channel_e& src_channel, CAudioInfo::EChannel& dst_channel) { +static void __convert_channel_2_audio_info_channel(const audio_channel_e& src_channel, + CAudioInfo::EChannel& dst_channel) { switch (src_channel) { case AUDIO_CHANNEL_MONO: dst_channel = CAudioInfo::EChannel::CHANNEL_MONO; @@ -157,10 +146,12 @@ static void __convert_channel_2_audio_info_channel(const audio_channel_e& src_ch break; default: dst_channel = CAudioInfo::EChannel::CHANNEL_MONO; + break; } } -static void __convert_audio_info_channel_2_channel(const CAudioInfo::EChannel& src_channel, audio_channel_e& dst_channel) { +static void __convert_audio_info_channel_2_channel(const CAudioInfo::EChannel& src_channel, + audio_channel_e& dst_channel) { switch (src_channel) { case CAudioInfo::EChannel::CHANNEL_MONO: dst_channel = AUDIO_CHANNEL_MONO; @@ -170,10 +161,12 @@ static void __convert_audio_info_channel_2_channel(const CAudioInfo::EChannel& s break; default: dst_channel = AUDIO_CHANNEL_MONO; + break; } } -static void __convert_sample_type_2_audio_info_sample_type(const audio_sample_type_e& src_type, CAudioInfo::ESampleType& dst_type) { +static void __convert_sample_type_2_audio_info_sample_type(const audio_sample_type_e& src_type, + CAudioInfo::ESampleType& dst_type) { switch (src_type) { case AUDIO_SAMPLE_TYPE_U8: dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_U8; @@ -183,10 +176,12 @@ static void __convert_sample_type_2_audio_info_sample_type(const audio_sample_ty break; default: dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_U8; + break; } } -static void __convert_audio_info_sample_type_2_sample_type(const CAudioInfo::ESampleType& src_type, audio_sample_type_e& dst_type) { +static void __convert_audio_info_sample_type_2_sample_type(const CAudioInfo::ESampleType& src_type, + audio_sample_type_e& dst_type) { switch (src_type) { case CAudioInfo::ESampleType::SAMPLE_TYPE_U8: dst_type = AUDIO_SAMPLE_TYPE_U8; @@ -196,10 +191,12 @@ static void __convert_audio_info_sample_type_2_sample_type(const CAudioInfo::ESa break; default: dst_type = AUDIO_SAMPLE_TYPE_U8; + break; } } -static void __convert_sound_type_2_audio_info_audio_type(const sound_type_e& src_type, CAudioInfo::EAudioType& dst_type) { +static void __convert_sound_type_2_audio_info_audio_type(const sound_type_e& src_type, + CAudioInfo::EAudioType& dst_type) { switch (src_type) { case SOUND_TYPE_SYSTEM: dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM; @@ -231,7 +228,8 @@ static void __convert_sound_type_2_audio_info_audio_type(const sound_type_e& src } } -static void __convert_audio_info_audio_type_2_sound_type(const CAudioInfo::EAudioType& src_type, sound_type_e& dst_type) { +static void __convert_audio_info_audio_type_2_sound_type(const CAudioInfo::EAudioType& src_type, + sound_type_e& dst_type) { switch (src_type) { case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA: dst_type = SOUND_TYPE_MEDIA; @@ -263,6 +261,7 @@ static void __convert_audio_info_audio_type_2_sound_type(const CAudioInfo::EAudi static audio_io_state_e __convert_state_type(const CAudioInfo::EAudioIOState src_state) { audio_io_state_e dst_state; + switch (src_state) { case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE: dst_state = AUDIO_IO_STATE_IDLE; @@ -278,36 +277,33 @@ static audio_io_state_e __convert_state_type(const CAudioInfo::EAudioIOState src break; default: dst_state = AUDIO_IO_STATE_IDLE; + break; } return dst_state; } -static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type) throw(CAudioError) { - if (sample_rate < 0) { +static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type) { + if (sample_rate < 0) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid sample rate :%d", sample_rate); - } - if (channel != AUDIO_CHANNEL_MONO && channel != AUDIO_CHANNEL_STEREO) { + if (channel != AUDIO_CHANNEL_MONO && channel != AUDIO_CHANNEL_STEREO) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid channel :%d", channel); - } - if (type != AUDIO_SAMPLE_TYPE_U8 && type != AUDIO_SAMPLE_TYPE_S16_LE) { + if (type != AUDIO_SAMPLE_TYPE_U8 && type != AUDIO_SAMPLE_TYPE_S16_LE) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid sample type :%d", type); - } } -static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type, sound_type_e sound_type) throw(CAudioError) { +static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type, sound_type_e sound_type) { __check_audio_param(sample_rate, channel, type); - if (sound_type < SOUND_TYPE_SYSTEM || sound_type > SOUND_TYPE_VOICE) { + if (sound_type < SOUND_TYPE_SYSTEM || sound_type > SOUND_TYPE_VOICE) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid sound type : %d", sound_type); - } } -static CAudioInfo __generate_audio_input_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw(CAudioError) { - CAudioInfo::EChannel dstChannel; +static CAudioInfo __generate_audio_input_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) { + CAudioInfo::EChannel dstChannel; CAudioInfo::ESampleType dstSampleType; - CAudioInfo::EAudioType dstAudioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA; + CAudioInfo::EAudioType dstAudioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA; __convert_channel_2_audio_info_channel(channel, dstChannel); __convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType); @@ -315,21 +311,10 @@ static CAudioInfo __generate_audio_input_info(int sampleRate, audio_channel_e ch return CAudioInfo(sampleRate, dstChannel, dstSampleType, dstAudioType, -1); } -static CAudioInfo __generate_audio_input_loopback_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw(CAudioError) { - CAudioInfo::EChannel dstChannel; +static CAudioInfo __generate_audio_output_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type, sound_type_e sound_type) { + CAudioInfo::EChannel dstChannel; CAudioInfo::ESampleType dstSampleType; - CAudioInfo::EAudioType dstAudioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_LOOPBACK; - - __convert_channel_2_audio_info_channel(channel, dstChannel); - __convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType); - - return CAudioInfo(sampleRate, dstChannel, dstSampleType, dstAudioType, -1); -} - -static CAudioInfo __generate_audio_output_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type, sound_type_e sound_type) throw(CAudioError) { - CAudioInfo::EChannel dstChannel; - CAudioInfo::ESampleType dstSampleType; - CAudioInfo::EAudioType dstAudioType; + CAudioInfo::EAudioType dstAudioType; __convert_channel_2_audio_info_channel(channel, dstChannel); __convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType); @@ -338,27 +323,19 @@ static CAudioInfo __generate_audio_output_info(int sampleRate, audio_channel_e c return CAudioInfo(sampleRate, dstChannel, dstSampleType, dstAudioType, -1); } -static audio_io_interrupted_code_e __convert_interrupted_code(IAudioSessionEventListener::EInterruptCode code) { - switch (code) { - case IAudioSessionEventListener::EInterruptCode::INTERRUPT_COMPLETED: - return AUDIO_IO_INTERRUPTED_COMPLETED; - case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_CALL: - return AUDIO_IO_INTERRUPTED_BY_CALL; - case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_EARJACK_UNPLUG: - return AUDIO_IO_INTERRUPTED_BY_EARJACK_UNPLUG; - case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_RESOURCE_CONFLICT: - return AUDIO_IO_INTERRUPTED_BY_RESOURCE_CONFLICT; - case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_ALARM: - return AUDIO_IO_INTERRUPTED_BY_ALARM; - case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_EMERGENCY: - return AUDIO_IO_INTERRUPTED_BY_EMERGENCY; - case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_NOTIFICATION: - return AUDIO_IO_INTERRUPTED_BY_NOTIFICATION; - case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_MEDIA: - case IAudioSessionEventListener::EInterruptCode::INTERRUPT_MAX: - default: - return AUDIO_IO_INTERRUPTED_BY_MEDIA; - } +static void __handle_safe_free(audio_io_s* handle, void *obj, bool is_output) { + VALID_POINTER_START(handle) + SAFE_FINALIZE(handle->audioIoHandle); + SAFE_DELETE(handle->audioIoHandle); + SAFE_DELETE(handle); + VALID_POINTER_END + + VALID_POINTER_START(obj) + if (is_output) + *(audio_out_h *)obj = NULL; + else + *(audio_in_h *)obj = NULL; + VALID_POINTER_END } /** @@ -370,11 +347,14 @@ int cpp_audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_t int ret = 0; try { if (input == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input); + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p", input); } __check_audio_param(sample_rate, channel, type); + AUDIO_IO_LOGD("samplerate:[%d] channel:[0x%x] sample_type:[0x%x]", sample_rate, channel, type); + /* If MIC is not supported, return NOT_SUPPORTED error */ ret = system_info_get_platform_bool(FEATURE_MICROPHONE, &mic_enable); AUDIO_IO_LOGD("system_info_platform [%s]=[%d], ret[%d]", FEATURE_MICROPHONE, mic_enable, ret); @@ -382,77 +362,22 @@ int cpp_audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_t THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "System doesn't support microphone!"); } - handle = new audio_io_s; - if (handle == NULL) { - THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle"); - } - CAudioInfo audioInfo = __generate_audio_input_info(sample_rate, channel, type); - handle->audioIoHandle = new CAudioInput(audioInfo); - if (handle->audioIoHandle == NULL) { - THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle"); - } - - handle->audioIoHandle->initialize(); - - *input = handle; - } catch (CAudioError e) { - AUDIO_IO_LOGE("%s", e.getErrorMsg()); - - VALID_POINTER_START(handle) - SAFE_FINALIZE(handle->audioIoHandle); - SAFE_DELETE(handle->audioIoHandle); - SAFE_DELETE(handle); - VALID_POINTER_END - - VALID_POINTER_START(input) - *input = NULL; - VALID_POINTER_END - - return __convert_CAudioError(e); - } - - return AUDIO_IO_ERROR_NONE; -} - -int cpp_audio_in_create_loopback(int sample_rate, audio_channel_e channel, audio_sample_type_e type , audio_in_h* input) { - audio_io_s* handle = NULL; - try { - if (input == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input); - } - - __check_audio_param(sample_rate, channel, type); - handle = new audio_io_s; - if (handle == NULL) { - THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle"); - } - - CAudioInfo audioInfo = __generate_audio_input_loopback_info(sample_rate, channel, type); - handle->audioIoHandle = new CAudioInput(audioInfo); - if (handle->audioIoHandle == NULL) { - THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle"); - } - handle->audioIoHandle->initialize(); + AUDIO_IO_LOGD("[%p] created", handle); *input = handle; - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - - VALID_POINTER_START(handle) - SAFE_FINALIZE(handle->audioIoHandle); - SAFE_DELETE(handle->audioIoHandle); - SAFE_DELETE(handle); - VALID_POINTER_END - - VALID_POINTER_START(input) - *input = NULL; - VALID_POINTER_END - + __handle_safe_free(handle, (void *)input, false); + return __convert_CAudioError(e); + } catch (const std::bad_alloc&) { + CAudioError e = CAudioError::EError::ERROR_OUT_OF_MEMORY; + AUDIO_IO_LOGE("Failed to allocate handle"); + __handle_safe_free(handle, (void *)input, false); return __convert_CAudioError(e); } @@ -463,11 +388,11 @@ int cpp_audio_in_destroy(audio_in_h input) { audio_io_s* handle = static_cast(input); try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input); - } - + if (handle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p", input); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); /* Internal unprepare for backward compatibility */ handle->audioIoHandle->unprepare(); @@ -475,11 +400,13 @@ int cpp_audio_in_destroy(audio_in_h input) { SAFE_FINALIZE(handle->audioIoHandle); SAFE_DELETE(handle->audioIoHandle); SAFE_DELETE(handle); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("destroyed"); + return AUDIO_IO_ERROR_NONE; } @@ -487,41 +414,20 @@ int cpp_audio_in_set_sound_stream_info(audio_in_h input, sound_stream_info_h str audio_io_s* handle = static_cast(input); try { - if (handle == NULL || stream_info == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, stream_info:%p", input, stream_info); - } - + if (handle == NULL || stream_info == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p, stream_info:%p", input, stream_info); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p], stream_info:[%p]", handle, stream_info); - 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"); - } - } catch (CAudioError e) { + handle->audioIoHandle->setStreamInfo(stream_info); + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] done", handle); + return AUDIO_IO_ERROR_NONE; } @@ -529,18 +435,20 @@ int cpp_audio_in_prepare(audio_in_h input) { audio_io_s* handle = static_cast(input); try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input); - } - + if (handle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p", input); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); handle->audioIoHandle->prepare(); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] prepared", handle); + return AUDIO_IO_ERROR_NONE; } @@ -548,18 +456,20 @@ int cpp_audio_in_unprepare(audio_in_h input) { audio_io_s* handle = static_cast(input); try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input); - } - + if (handle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p", input); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); handle->audioIoHandle->unprepare(); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] unprepared", handle); + return AUDIO_IO_ERROR_NONE; } @@ -567,18 +477,20 @@ int cpp_audio_in_pause(audio_in_h input) { audio_io_s* handle = static_cast(input); try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input); - } - + if (handle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p", input); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); handle->audioIoHandle->pause(); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] paused", handle); + return AUDIO_IO_ERROR_NONE; } @@ -586,18 +498,20 @@ int cpp_audio_in_resume(audio_in_h input) { audio_io_s* handle = static_cast(input); try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input); - } - + if (handle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p", input); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); handle->audioIoHandle->resume(); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] resumed", handle); + return AUDIO_IO_ERROR_NONE; } @@ -605,18 +519,20 @@ int cpp_audio_in_drain(audio_in_h input) { audio_io_s* handle = static_cast(input); try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input); - } - + if (handle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p", input); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); handle->audioIoHandle->drain(); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] drained", handle); + return AUDIO_IO_ERROR_NONE; } @@ -624,18 +540,20 @@ int cpp_audio_in_flush(audio_in_h input) { audio_io_s* handle = static_cast(input); try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input); - } - + if (handle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p", input); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); handle->audioIoHandle->flush(); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] flushed", handle); + return AUDIO_IO_ERROR_NONE; } @@ -644,22 +562,22 @@ int cpp_audio_in_read(audio_in_h input, void *buffer, unsigned int length) { int ret = 0; try { - if (handle == NULL || buffer == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, buffer:%p", input, buffer); - } - + if (handle == NULL || buffer == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p, buffer:%p", input, buffer); assert(handle->audioIoHandle); - CAudioInput* inputHandle = dynamic_cast(handle->audioIoHandle); + CAudioInput* inputHandle = static_cast(handle->audioIoHandle); if (inputHandle == NULL) { THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL"); } + size_t readn = inputHandle->read(buffer, static_cast(length)); ret = static_cast(readn); #ifdef _AUDIO_IO_DEBUG_TIMING_ AUDIO_IO_LOGD("readn:%d", readn); #endif - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } @@ -671,18 +589,17 @@ 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) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, size:%p", input, size); - } - + if (handle == NULL || size == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p, size:%p", input, size); assert(handle->audioIoHandle); - CAudioIO* inputHandle = dynamic_cast(handle->audioIoHandle); + CAudioIO* inputHandle = static_cast(handle->audioIoHandle); if (inputHandle == NULL) { THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL"); } *size = inputHandle->getBufferSize(); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } @@ -694,13 +611,13 @@ 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) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, sample_rate:%p", input, sample_rate); - } - + if (handle == NULL || sample_rate == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p, sample_rate:%p", input, sample_rate); assert(handle->audioIoHandle); + *sample_rate = handle->audioIoHandle->getAudioInfo().getSampleRate(); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } @@ -712,10 +629,9 @@ 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) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, channel:%p", input, channel); - } - + if (handle == NULL || channel == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p, channel:%p", input, channel); assert(handle->audioIoHandle); const CAudioInfo::EChannel srcChannel = handle->audioIoHandle->getAudioInfo().getChannel(); @@ -723,7 +639,7 @@ int cpp_audio_in_get_channel(audio_in_h input, audio_channel_e *channel) { __convert_audio_info_channel_2_channel(srcChannel, dstChannel); *channel = dstChannel; - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } @@ -735,104 +651,17 @@ 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) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, type:%p", input, type); - } - + if (handle == NULL || type == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p, type:%p", input, type); assert(handle->audioIoHandle); const CAudioInfo::ESampleType srcSampleType = handle->audioIoHandle->getAudioInfo().getSampleType(); - audio_sample_type_e dstSampleType = AUDIO_SAMPLE_TYPE_U8; + audio_sample_type_e dstSampleType = AUDIO_SAMPLE_TYPE_U8; __convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType); *type = dstSampleType; - } catch (CAudioError e) { - AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); - } - - return AUDIO_IO_ERROR_NONE; -} - -static void __interrupt_cb_internal(IAudioSessionEventListener::EInterruptCode _code, void* user_data) { - audio_io_s* handle = static_cast(user_data); - audio_io_interrupted_code_e code = __convert_interrupted_code(_code); - - assert(handle); - - if (handle->interrupt_callback.onInterrupt != NULL) { - handle->interrupt_callback.onInterrupt(code, handle->interrupt_callback.user_data); - } -} - -int cpp_audio_in_set_interrupted_cb(audio_in_h input, audio_io_interrupted_cb callback, void *user_data) { - audio_io_s* handle = static_cast(input); - - try { - if (handle == NULL || callback == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback); - } - - assert(handle->audioIoHandle); - - handle->interrupt_callback.onInterrupt = callback; - handle->interrupt_callback.user_data = user_data; - - CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback(); - cb.mUserData = static_cast(handle); - cb.onInterrupt = __interrupt_cb_internal; - - handle->audioIoHandle->setInterruptCallback(cb); - } catch (CAudioError e) { - AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); - } - - return AUDIO_IO_ERROR_NONE; -} - -int cpp_audio_in_unset_interrupted_cb(audio_in_h input) { - audio_io_s* handle = static_cast(input); - - try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input); - } - - assert(handle->audioIoHandle); - - handle->interrupt_callback.onInterrupt = NULL; - handle->interrupt_callback.user_data = NULL; - - CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback(); - cb.mUserData = NULL; - cb.onInterrupt = NULL; - - handle->audioIoHandle->setInterruptCallback(cb); - } catch (CAudioError e) { - AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); - } - - return AUDIO_IO_ERROR_NONE; -} - -int cpp_audio_in_ignore_session(audio_in_h input) { - audio_io_s* handle = static_cast(input); - - try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input); - } - - if (handle->stream_callback.onStream) { - THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION, "Not support ignore session in async mode"); - } - - assert(handle->audioIoHandle); - - handle->audioIoHandle->ignoreSession(); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } @@ -844,29 +673,32 @@ static void __stream_cb_internal(size_t nbytes, void *user_data) { audio_io_s* audioIo = static_cast(user_data); assert(audioIo); - if (audioIo->stream_callback.onStream != NULL) { + if (audioIo->stream_callback.onStream) audioIo->stream_callback.onStream(audioIo, nbytes, audioIo->stream_callback.user_data); - } } -static void __state_changed_cb_internal(CAudioInfo::EAudioIOState state, CAudioInfo::EAudioIOState state_prev, bool by_policy, void *user_data) { +static void __state_changed_cb_internal(CAudioInfo::EAudioIOState state, + CAudioInfo::EAudioIOState state_prev, + bool by_policy, + void *user_data) { audio_io_s* audioIo = static_cast(user_data); assert(audioIo); - if (audioIo->state_changed_callback.onStateChanged != NULL) { - audioIo->state_changed_callback.onStateChanged(audioIo, __convert_state_type(state_prev), __convert_state_type(state), by_policy, audioIo->state_changed_callback.user_data); - } + if (audioIo->state_changed_callback.onStateChanged) + audioIo->state_changed_callback.onStateChanged(audioIo, __convert_state_type(state_prev), + __convert_state_type(state), by_policy, + audioIo->state_changed_callback.user_data); } 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); try { - if (handle == NULL || callback == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback); - } - + if (handle == NULL || callback == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p, callback:%p", input, callback); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p], callback:[%p], user_data:[%p]", handle, callback, user_data); handle->stream_callback.onStream = callback; handle->stream_callback.user_data = user_data; @@ -876,11 +708,13 @@ int cpp_audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, vo cb.onStream = __stream_cb_internal; handle->audioIoHandle->setStreamCallback(cb); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] done", handle); + return AUDIO_IO_ERROR_NONE; } @@ -888,11 +722,11 @@ int cpp_audio_in_unset_stream_cb(audio_in_h input) { audio_io_s* handle = static_cast(input); try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input); - } - + if (handle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p", input); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); handle->stream_callback.onStream = NULL; handle->stream_callback.user_data = NULL; @@ -902,11 +736,13 @@ int cpp_audio_in_unset_stream_cb(audio_in_h input) { cb.onStream = NULL; handle->audioIoHandle->setStreamCallback(cb); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] done", handle); + return AUDIO_IO_ERROR_NONE; } @@ -915,15 +751,16 @@ int cpp_audio_in_peek(audio_in_h input, const void **buffer, unsigned int *lengt size_t _length = 0; try { - if (handle == NULL || buffer == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, buffer:%p", input, buffer); - } + if (handle == NULL || buffer == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p, buffer:%p", input, buffer); - CAudioInput* inputHandle = dynamic_cast(handle->audioIoHandle); - assert(inputHandle); + CAudioInput* inputHandle = static_cast(handle->audioIoHandle); + if (inputHandle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL"); inputHandle->peek(buffer, &_length); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } @@ -937,15 +774,16 @@ int cpp_audio_in_drop(audio_in_h input) { audio_io_s* handle = static_cast(input); try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input); - } + if (handle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p", input); - CAudioInput* inputHandle = dynamic_cast(handle->audioIoHandle); - assert(inputHandle); + CAudioInput* inputHandle = static_cast(handle->audioIoHandle); + if (inputHandle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL"); inputHandle->drop(); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } @@ -957,11 +795,11 @@ int cpp_audio_in_set_state_changed_cb(audio_in_h input, audio_in_state_changed_c audio_io_s* handle = static_cast(input); try { - if (handle == NULL || callback == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback); - } - + if (handle == NULL || callback == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL input:%p, callback:%p", input, callback); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p], callback:[%p], user_data:[%p]", handle, callback, user_data); handle->state_changed_callback.onStateChanged = callback; handle->state_changed_callback.user_data = user_data; @@ -971,11 +809,13 @@ int cpp_audio_in_set_state_changed_cb(audio_in_h input, audio_in_state_changed_c cb.onStateChanged = __state_changed_cb_internal; handle->audioIoHandle->setStateChangedCallback(cb); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] done", handle); + return AUDIO_IO_ERROR_NONE; } @@ -983,11 +823,11 @@ int cpp_audio_in_unset_state_changed_cb(audio_in_h input) { audio_io_s* handle = static_cast(input); try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", input); - } - + if (handle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL output:%p", input); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); handle->state_changed_callback.onStateChanged = NULL; handle->state_changed_callback.user_data = NULL; @@ -997,11 +837,13 @@ int cpp_audio_in_unset_state_changed_cb(audio_in_h input) { cb.onStateChanged = NULL; handle->audioIoHandle->setStateChangedCallback(cb); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] done", handle); + return AUDIO_IO_ERROR_NONE; } @@ -1009,86 +851,32 @@ int cpp_audio_in_unset_state_changed_cb(audio_in_h input) { /** * Audio Out */ -int cpp_audio_out_create(int sample_rate, audio_channel_e channel, audio_sample_type_e type, sound_type_e sound_type, audio_out_h *output) { - audio_io_s* handle = NULL; - try { - if (output == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output); - } - - __check_audio_param(sample_rate, channel, type, sound_type); - - handle = new audio_io_s; - if (handle == NULL) { - THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle"); - } - - CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, sound_type); - - handle->audioIoHandle = new CAudioOutput(audioInfo); - if (handle == NULL) { - THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle"); - } - - handle->audioIoHandle->initialize(); - - *output = handle; - } catch (CAudioError e) { - AUDIO_IO_LOGE("%s", e.getErrorMsg()); - - VALID_POINTER_START(handle) - SAFE_FINALIZE(handle->audioIoHandle); - SAFE_DELETE(handle->audioIoHandle); - SAFE_DELETE(handle); - VALID_POINTER_END - - VALID_POINTER_START(output) - *output = NULL; - VALID_POINTER_END - - return __convert_CAudioError(e); - } - - return AUDIO_IO_ERROR_NONE; -} - int cpp_audio_out_create_new(int sample_rate, audio_channel_e channel, audio_sample_type_e type, audio_out_h *output) { audio_io_s* handle = NULL; try { - if (output == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output); - } + if (output == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL output:%p", output); __check_audio_param(sample_rate, channel, type, SOUND_TYPE_SYSTEM /*default check */); - handle = new audio_io_s; - if (handle == NULL) { - THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle"); - } - - CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, SOUND_TYPE_MEDIA /* default sound_type */); + AUDIO_IO_LOGD("samplerate:[%d] channel:[0x%x] sample_type:[0x%x]", sample_rate, channel, type); + CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, SOUND_TYPE_MEDIA); + handle = new audio_io_s; handle->audioIoHandle = new CAudioOutput(audioInfo); - if (handle->audioIoHandle == NULL) { - THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle"); - } - handle->audioIoHandle->initialize(); + AUDIO_IO_LOGD("[%p] created", handle); *output = handle; - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); - - VALID_POINTER_START(handle) - SAFE_FINALIZE(handle->audioIoHandle); - SAFE_DELETE(handle->audioIoHandle); - SAFE_DELETE(handle); - VALID_POINTER_END - - VALID_POINTER_START(output) - *output = NULL; - VALID_POINTER_END - + __handle_safe_free(handle, (void *)output, true); + return __convert_CAudioError(e); + } catch (const std::bad_alloc&) { + CAudioError e = CAudioError::EError::ERROR_OUT_OF_MEMORY; + AUDIO_IO_LOGE("Failed to allocate handle"); + __handle_safe_free(handle, (void *)output, true); return __convert_CAudioError(e); } @@ -1099,11 +887,11 @@ int cpp_audio_out_destroy(audio_out_h output) { audio_io_s* handle = static_cast(output); try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output); - } - + if (handle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameter is NULL output:%p", output); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); /* Internal unprepare for backward compatibility */ handle->audioIoHandle->unprepare(); @@ -1111,11 +899,13 @@ int cpp_audio_out_destroy(audio_out_h output) { SAFE_FINALIZE(handle->audioIoHandle); SAFE_DELETE(handle->audioIoHandle); SAFE_DELETE(handle); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("destroyed"); + return AUDIO_IO_ERROR_NONE; } @@ -1123,41 +913,20 @@ int cpp_audio_out_set_sound_stream_info(audio_out_h output, sound_stream_info_h audio_io_s* handle = static_cast(output); try { - if (handle == NULL || stream_info == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, stream_info:%p", output, stream_info); - } - + if (handle == NULL || stream_info == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL output:%p, stream_info:%p", output, stream_info); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p], stream_info:[%p]", handle, stream_info); - 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"); - } - } catch (CAudioError e) { + handle->audioIoHandle->setStreamInfo(stream_info); + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] done", handle); + return AUDIO_IO_ERROR_NONE; } @@ -1165,18 +934,20 @@ int cpp_audio_out_prepare(audio_out_h output) { audio_io_s* handle = static_cast(output); try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output); - } - + if (handle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameter is NULL output:%p", output); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); handle->audioIoHandle->prepare(); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] prepared", handle); + return AUDIO_IO_ERROR_NONE; } @@ -1184,18 +955,20 @@ int cpp_audio_out_unprepare(audio_out_h output) { audio_io_s* handle = static_cast(output); try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output); - } - + if (handle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameter is NULL output:%p", output); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); handle->audioIoHandle->unprepare(); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] unprepared", handle); + return AUDIO_IO_ERROR_NONE; } @@ -1203,18 +976,20 @@ int cpp_audio_out_pause(audio_out_h output) { audio_io_s* handle = static_cast(output); try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output); - } - + if (handle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameter is NULL output:%p", output); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); handle->audioIoHandle->pause(); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] paused", handle); + return AUDIO_IO_ERROR_NONE; } @@ -1222,18 +997,20 @@ int cpp_audio_out_resume(audio_out_h output) { audio_io_s* handle = static_cast(output); try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output); - } - + if (handle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameter is NULL output:%p", output); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); handle->audioIoHandle->resume(); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] resumed", handle); + return AUDIO_IO_ERROR_NONE; } @@ -1241,18 +1018,20 @@ int cpp_audio_out_drain(audio_out_h output) { audio_io_s* handle = static_cast(output); try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output); - } - + if (handle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameter is NULL output:%p", output); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); handle->audioIoHandle->drain(); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] drained", handle); + return AUDIO_IO_ERROR_NONE; } @@ -1260,18 +1039,20 @@ int cpp_audio_out_flush(audio_out_h output) { audio_io_s* handle = static_cast(output); try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output); - } - + if (handle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameter is NULL output:%p", output); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); handle->audioIoHandle->flush(); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] flushed", handle); + return AUDIO_IO_ERROR_NONE; } @@ -1280,22 +1061,21 @@ int cpp_audio_out_write(audio_out_h output, void *buffer, unsigned int length) { int ret = 0; try { - if (handle == NULL || buffer == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p, buffer:%p", output, buffer); - } - + if (handle == NULL || buffer == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameter is NULL output:%p, buffer:%p", output, buffer); assert(handle->audioIoHandle); - CAudioOutput* outputHandle = dynamic_cast(handle->audioIoHandle); - if (outputHandle == NULL) { + CAudioOutput* outputHandle = static_cast(handle->audioIoHandle); + if (outputHandle == NULL) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL"); - } + size_t written = outputHandle->write(buffer, static_cast(length)); ret = static_cast(written); #ifdef _AUDIO_IO_DEBUG_TIMING_ AUDIO_IO_LOGD("written:%d", written); #endif - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } @@ -1307,18 +1087,17 @@ 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) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, size:%p", output, size); - } - + if (handle == NULL || size == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL output:%p, size:%p", output, size); assert(handle->audioIoHandle); - CAudioOutput* outputHandle = dynamic_cast(handle->audioIoHandle); - if (outputHandle == NULL) { + CAudioOutput* outputHandle = static_cast(handle->audioIoHandle); + if (outputHandle == NULL) THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL"); - } + *size = outputHandle->getBufferSize(); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } @@ -1330,13 +1109,13 @@ 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) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, sample_rate:%p", output, sample_rate); - } - + if (handle == NULL || sample_rate == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL output:%p, sample_rate:%p", output, sample_rate); assert(handle->audioIoHandle); + *sample_rate = handle->audioIoHandle->getAudioInfo().getSampleRate(); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } @@ -1348,10 +1127,9 @@ 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) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, channel:%p", output, channel); - } - + if (handle == NULL || channel == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL output:%p, channel:%p", output, channel); assert(handle->audioIoHandle); const CAudioInfo::EChannel srcChannel = handle->audioIoHandle->getAudioInfo().getChannel(); @@ -1359,7 +1137,7 @@ int cpp_audio_out_get_channel(audio_out_h output, audio_channel_e *channel) { __convert_audio_info_channel_2_channel(srcChannel, dstChannel); *channel = dstChannel; - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } @@ -1371,18 +1149,17 @@ 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) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, type:%p", output, type); - } - + if (handle == NULL || type == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL output:%p, type:%p", output, type); assert(handle->audioIoHandle); const CAudioInfo::ESampleType srcSampleType = handle->audioIoHandle->getAudioInfo().getSampleType(); - audio_sample_type_e dstSampleType = AUDIO_SAMPLE_TYPE_U8; + audio_sample_type_e dstSampleType = AUDIO_SAMPLE_TYPE_U8; __convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType); *type = dstSampleType; - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } @@ -1394,93 +1171,17 @@ int cpp_audio_out_get_sound_type(audio_out_h output, sound_type_e *type) { audio_io_s* handle = static_cast(output); try { - if (handle == NULL || type == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, type:%p", output, type); - } - + if (handle == NULL || type == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL output:%p, type:%p", output, type); assert(handle->audioIoHandle); const CAudioInfo::EAudioType srcAudioType = handle->audioIoHandle->getAudioInfo().getAudioType(); - sound_type_e dstSoundType = SOUND_TYPE_MEDIA; + sound_type_e dstSoundType = SOUND_TYPE_MEDIA; __convert_audio_info_audio_type_2_sound_type(srcAudioType, dstSoundType); *type = dstSoundType; - } catch (CAudioError e) { - AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); - } - - return AUDIO_IO_ERROR_NONE; -} - -int cpp_audio_out_set_interrupted_cb(audio_out_h output, audio_io_interrupted_cb callback, void *user_data) { - audio_io_s* handle = static_cast(output); - - try { - if (handle == NULL || callback == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback); - } - - assert(handle->audioIoHandle); - - handle->interrupt_callback.onInterrupt = callback; - handle->interrupt_callback.user_data = user_data; - - CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback(); - cb.mUserData = static_cast(handle); - cb.onInterrupt = __interrupt_cb_internal; - - handle->audioIoHandle->setInterruptCallback(cb); - } catch (CAudioError e) { - AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); - } - - return AUDIO_IO_ERROR_NONE; -} - -int cpp_audio_out_unset_interrupted_cb(audio_out_h output) { - audio_io_s* handle = static_cast(output); - - try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output); - } - - assert(handle->audioIoHandle); - - handle->interrupt_callback.onInterrupt = NULL; - handle->interrupt_callback.user_data = NULL; - - CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback(); - cb.mUserData = NULL; - cb.onInterrupt = NULL; - - handle->audioIoHandle->setInterruptCallback(cb); - } catch (CAudioError e) { - AUDIO_IO_LOGE("%s", e.getErrorMsg()); - return __convert_CAudioError(e); - } - - return AUDIO_IO_ERROR_NONE; -} - -int cpp_audio_out_ignore_session(audio_out_h output) { - audio_io_s* handle = static_cast(output); - - try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output); - } - - if (handle->stream_callback.onStream) { - THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION, "Not support ignore session in async mode"); - } - - assert(handle->audioIoHandle); - - handle->audioIoHandle->ignoreSession(); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } @@ -1492,25 +1193,27 @@ int cpp_audio_out_set_stream_cb(audio_out_h output, audio_out_stream_cb callback audio_io_s* handle = static_cast(output); try { - if (handle == NULL || callback == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback); - } - + if (handle == NULL || callback == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL output:%p, callback:%p", output, callback); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p], callback:[%p], user_data:[%p]", handle, callback, user_data); handle->stream_callback.onStream = callback; handle->stream_callback.user_data = user_data; CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback(); cb.mUserData = static_cast(handle); - cb.onStream = __stream_cb_internal; + cb.onStream = __stream_cb_internal; handle->audioIoHandle->setStreamCallback(cb); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] done", handle); + return AUDIO_IO_ERROR_NONE; } @@ -1518,25 +1221,27 @@ int cpp_audio_out_unset_stream_cb(audio_out_h output) { audio_io_s* handle = static_cast(output); try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output); - } - + if (handle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL output:%p", output); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); handle->stream_callback.onStream = NULL; handle->stream_callback.user_data = NULL; CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback(); cb.mUserData = NULL; - cb.onStream = NULL; + cb.onStream = NULL; handle->audioIoHandle->setStreamCallback(cb); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] done", handle); + return AUDIO_IO_ERROR_NONE; } @@ -1544,11 +1249,11 @@ int cpp_audio_out_set_state_changed_cb(audio_out_h output, audio_in_state_change audio_io_s* handle = static_cast(output); try { - if (handle == NULL || callback == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback); - } - + if (handle == NULL || callback == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL output:%p, callback:%p", output, callback); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p], callback:[%p], user_data:[%p]", handle, callback, user_data); handle->state_changed_callback.onStateChanged = callback; handle->state_changed_callback.user_data = user_data; @@ -1558,11 +1263,13 @@ int cpp_audio_out_set_state_changed_cb(audio_out_h output, audio_in_state_change cb.onStateChanged = __state_changed_cb_internal; handle->audioIoHandle->setStateChangedCallback(cb); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] done", handle); + return AUDIO_IO_ERROR_NONE; } @@ -1570,24 +1277,26 @@ int cpp_audio_out_unset_state_changed_cb(audio_out_h output) { audio_io_s* handle = static_cast(output); try { - if (handle == NULL) { - THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output); - } - + if (handle == NULL) + THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, + "Parameters are NULL output:%p", output); assert(handle->audioIoHandle); + AUDIO_IO_LOGD("[%p]", handle); handle->state_changed_callback.onStateChanged = NULL; handle->state_changed_callback.user_data = NULL; CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback(); cb.mUserData = NULL; - cb.onStateChanged = NULL; + cb.onStateChanged = NULL; handle->audioIoHandle->setStateChangedCallback(cb); - } catch (CAudioError e) { + } catch (CAudioError& e) { AUDIO_IO_LOGE("%s", e.getErrorMsg()); return __convert_CAudioError(e); } + AUDIO_IO_LOGD("[%p] done", handle); + return AUDIO_IO_ERROR_NONE; }