#include "CAudioIODef.h"
#include <system_info.h>
+#include <cassert>
#define FEATURE_MICROPHONE "http://tizen.org/feature/microphone"
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;
/**
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;
/**
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:
- dst_channel = CAudioInfo::EChannel::CHANNEL_MULTI_3;
- break;
+ return CAudioInfo::EChannel::CHANNEL_MULTI_3;
case AUDIO_CHANNEL_MULTI_4:
- dst_channel = CAudioInfo::EChannel::CHANNEL_MULTI_4;
- break;
+ return CAudioInfo::EChannel::CHANNEL_MULTI_4;
case AUDIO_CHANNEL_MULTI_5:
- dst_channel = CAudioInfo::EChannel::CHANNEL_MULTI_5;
- break;
+ return CAudioInfo::EChannel::CHANNEL_MULTI_5;
case AUDIO_CHANNEL_MULTI_6:
- dst_channel = CAudioInfo::EChannel::CHANNEL_MULTI_6;
- break;
+ return CAudioInfo::EChannel::CHANNEL_MULTI_6;
case AUDIO_CHANNEL_MULTI_7:
- dst_channel = CAudioInfo::EChannel::CHANNEL_MULTI_7;
- break;
+ return CAudioInfo::EChannel::CHANNEL_MULTI_7;
case AUDIO_CHANNEL_MULTI_8:
- dst_channel = CAudioInfo::EChannel::CHANNEL_MULTI_8;
- break;
+ return CAudioInfo::EChannel::CHANNEL_MULTI_8;
default:
- dst_channel = CAudioInfo::EChannel::CHANNEL_MONO;
- break;
+ return CAudioInfo::EChannel::CHANNEL_MONO;
}
}
-static void __convert_audio_info_channel_2_channel(const CAudioInfo::EChannel& src_channel,
- audio_channel_e& dst_channel) {
+static audio_channel_e __convert_audio_info_channel_to_channel(const CAudioInfo::EChannel& src_channel) {
switch (src_channel) {
case CAudioInfo::EChannel::CHANNEL_MONO:
- dst_channel = AUDIO_CHANNEL_MONO;
- break;
+ return AUDIO_CHANNEL_MONO;
case CAudioInfo::EChannel::CHANNEL_STEREO:
- dst_channel = AUDIO_CHANNEL_STEREO;
- break;
+ return AUDIO_CHANNEL_STEREO;
case CAudioInfo::EChannel::CHANNEL_MULTI_3:
- dst_channel = AUDIO_CHANNEL_MULTI_3;
- break;
+ return AUDIO_CHANNEL_MULTI_3;
case CAudioInfo::EChannel::CHANNEL_MULTI_4:
- dst_channel = AUDIO_CHANNEL_MULTI_4;
- break;
+ return AUDIO_CHANNEL_MULTI_4;
case CAudioInfo::EChannel::CHANNEL_MULTI_5:
- dst_channel = AUDIO_CHANNEL_MULTI_5;
- break;
+ return AUDIO_CHANNEL_MULTI_5;
case CAudioInfo::EChannel::CHANNEL_MULTI_6:
- dst_channel = AUDIO_CHANNEL_MULTI_6;
- break;
+ return AUDIO_CHANNEL_MULTI_6;
case CAudioInfo::EChannel::CHANNEL_MULTI_7:
- dst_channel = AUDIO_CHANNEL_MULTI_7;
- break;
+ return AUDIO_CHANNEL_MULTI_7;
case CAudioInfo::EChannel::CHANNEL_MULTI_8:
- dst_channel = AUDIO_CHANNEL_MULTI_8;
- break;
+ return AUDIO_CHANNEL_MULTI_8;
default:
- dst_channel = AUDIO_CHANNEL_MONO;
- break;
+ return AUDIO_CHANNEL_MONO;
}
}
-static void __convert_sample_type_2_audio_info_sample_type(const audio_sample_type_e& src_type,
- CAudioInfo::ESampleType& dst_type) {
+static CAudioInfo::ESampleType __convert_sample_type_to_audio_info_sample_type(const audio_sample_type_e& src_type) {
switch (src_type) {
case AUDIO_SAMPLE_TYPE_U8:
- dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_U8;
- break;
+ return CAudioInfo::ESampleType::SAMPLE_TYPE_U8;
case AUDIO_SAMPLE_TYPE_S16_LE:
- dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_S16_LE;
- break;
+ return CAudioInfo::ESampleType::SAMPLE_TYPE_S16_LE;
case AUDIO_SAMPLE_TYPE_S24_LE:
- dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_S24_LE;
- break;
+ return CAudioInfo::ESampleType::SAMPLE_TYPE_S24_LE;
case AUDIO_SAMPLE_TYPE_S24_32_LE:
- dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_S24_32_LE;
- break;
+ return CAudioInfo::ESampleType::SAMPLE_TYPE_S24_32_LE;
case AUDIO_SAMPLE_TYPE_S32_LE:
- dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_S32_LE;
- break;
+ return CAudioInfo::ESampleType::SAMPLE_TYPE_S32_LE;
default:
- dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_U8;
- break;
+ return CAudioInfo::ESampleType::SAMPLE_TYPE_U8;
}
}
-static void __convert_audio_info_sample_type_2_sample_type(const CAudioInfo::ESampleType& src_type,
- audio_sample_type_e& dst_type) {
+static audio_sample_type_e __convert_audio_info_sample_type_to_sample_type(const CAudioInfo::ESampleType &src_type) {
switch (src_type) {
case CAudioInfo::ESampleType::SAMPLE_TYPE_U8:
- dst_type = AUDIO_SAMPLE_TYPE_U8;
- break;
+ return AUDIO_SAMPLE_TYPE_U8;
case CAudioInfo::ESampleType::SAMPLE_TYPE_S16_LE:
- dst_type = AUDIO_SAMPLE_TYPE_S16_LE;
- break;
+ return AUDIO_SAMPLE_TYPE_S16_LE;
case CAudioInfo::ESampleType::SAMPLE_TYPE_S24_LE:
- dst_type = AUDIO_SAMPLE_TYPE_S24_LE;
- break;
+ return AUDIO_SAMPLE_TYPE_S24_LE;
case CAudioInfo::ESampleType::SAMPLE_TYPE_S24_32_LE:
- dst_type = AUDIO_SAMPLE_TYPE_S24_32_LE;
- break;
+ return AUDIO_SAMPLE_TYPE_S24_32_LE;
case CAudioInfo::ESampleType::SAMPLE_TYPE_S32_LE:
- dst_type = AUDIO_SAMPLE_TYPE_S32_LE;
- break;
+ return AUDIO_SAMPLE_TYPE_S32_LE;
default:
- dst_type = AUDIO_SAMPLE_TYPE_U8;
- break;
+ return AUDIO_SAMPLE_TYPE_U8;
}
}
-static void __convert_sound_type_2_audio_info_audio_type(const sound_type_e& src_type,
- CAudioInfo::EAudioType& dst_type) {
+static CAudioInfo::EAudioType __convert_sound_type_to_audio_info_audio_type(const sound_type_e &src_type) {
switch (src_type) {
case SOUND_TYPE_SYSTEM:
- dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM;
- break;
+ return CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM;
case SOUND_TYPE_NOTIFICATION:
- dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_NOTIFICATION;
- break;
+ return CAudioInfo::EAudioType::AUDIO_OUT_TYPE_NOTIFICATION;
case SOUND_TYPE_ALARM:
- dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_ALARM;
- break;
+ return CAudioInfo::EAudioType::AUDIO_OUT_TYPE_ALARM;
case SOUND_TYPE_RINGTONE:
- dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_RINGTONE_VOIP;
- break;
+ return CAudioInfo::EAudioType::AUDIO_OUT_TYPE_RINGTONE_VOIP;
case SOUND_TYPE_MEDIA:
- dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
- break;
+ return CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
case SOUND_TYPE_CALL:
- dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM;
- break;
+ return CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM;
case SOUND_TYPE_VOIP:
- dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOIP;
- break;
+ return CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOIP;
case SOUND_TYPE_VOICE:
- dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOICE_INFORMATION;
- break;
+ return CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOICE_INFORMATION;
default:
- dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
- break;
+ return CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
}
}
-static void __convert_audio_info_audio_type_2_sound_type(const CAudioInfo::EAudioType& src_type,
- sound_type_e& dst_type) {
+static sound_type_e __convert_audio_info_audio_type_to_sound_type(const CAudioInfo::EAudioType &src_type) {
switch (src_type) {
case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA:
- dst_type = SOUND_TYPE_MEDIA;
- break;
+ return SOUND_TYPE_MEDIA;
case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM:
- dst_type = SOUND_TYPE_SYSTEM;
- break;
+ return SOUND_TYPE_SYSTEM;
case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_ALARM:
- dst_type = SOUND_TYPE_ALARM;
- break;
+ return SOUND_TYPE_ALARM;
case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_NOTIFICATION:
case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_EMERGENCY:
- dst_type = SOUND_TYPE_NOTIFICATION;
- break;
+ return SOUND_TYPE_NOTIFICATION;
case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOICE_INFORMATION:
- dst_type = SOUND_TYPE_VOICE;
- break;
+ return SOUND_TYPE_VOICE;
case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_RINGTONE_VOIP:
- dst_type = SOUND_TYPE_RINGTONE;
- break;
+ return SOUND_TYPE_RINGTONE;
case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOIP:
- dst_type = SOUND_TYPE_VOIP;
- break;
+ return SOUND_TYPE_VOIP;
default:
- dst_type = SOUND_TYPE_MEDIA;
- break;
+ return SOUND_TYPE_MEDIA;
}
}
static audio_io_state_e __convert_state_type(const CAudioInfo::EAudioIOState src_state) {
- audio_io_state_e dst_state;
-
switch (src_state) {
case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE:
- dst_state = AUDIO_IO_STATE_IDLE;
- break;
+ return AUDIO_IO_STATE_IDLE;
case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE:
- dst_state = AUDIO_IO_STATE_IDLE;
- break;
+ return AUDIO_IO_STATE_IDLE;
case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING:
- dst_state = AUDIO_IO_STATE_RUNNING;
- break;
+ return AUDIO_IO_STATE_RUNNING;
case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED:
- dst_state = AUDIO_IO_STATE_PAUSED;
- break;
+ return AUDIO_IO_STATE_PAUSED;
default:
- dst_state = AUDIO_IO_STATE_IDLE;
- break;
+ return AUDIO_IO_STATE_IDLE;
}
- return dst_state;
}
static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type, bool is_output) {
}
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) {
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
}
* 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, 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);
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
}
}
int cpp_audio_in_destroy(audio_in_h input) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(input);
+ au
to handle = static_cast<audio_io_s*>(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);
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");
}
int cpp_audio_in_set_sound_stream_info(audio_in_h input, sound_stream_info_h stream_info) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(input);
+ au
to handle = static_cast<audio_io_s*>(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);
}
int cpp_audio_in_prepare(audio_in_h input) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(input);
+ au
to handle = static_cast<audio_io_s*>(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);
}
int cpp_audio_in_unprepare(audio_in_h input) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(input);
+ au
to handle = static_cast<audio_io_s*>(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);
}
int cpp_audio_in_pause(audio_in_h input) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(input);
+ au
to handle = static_cast<audio_io_s*>(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);
}
int cpp_audio_in_resume(audio_in_h input) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(input);
+ au
to handle = static_cast<audio_io_s*>(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);
}
int cpp_audio_in_flush(audio_in_h input) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(input);
+ au
to handle = static_cast<audio_io_s*>(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);
}
int cpp_audio_in_read(audio_in_h input, void *buffer, unsigned int length) {
- audio_io_s* handle = static_cast<audio_io_s*>(input);
int ret = 0;
try {
- if (handle == NULL || buffer == NULL)
+ auto handle = static_cast<audio_io_s*>(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<CAudioInput*>(handle->audioIoHandle);
- if (inputHandle == NULL) {
+ auto inputHandle = static_cast<CAudioInput*>(handle->audioIoHandle);
+ if (!inputHandle)
THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
- }
- size_t readn = inputHandle->read(buffer, static_cast<size_t>(length));
+ auto readn = inputHandle->read(buffer, static_cast<size_t>(length));
ret = static_cast<int>(readn);
#ifdef _AUDIO_IO_DEBUG_TIMING_
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<audio_io_s*>(input);
-
try {
- if (handle == NULL || size == NULL)
+ auto handle = static_cast<audio_io_s*>(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<CAudioInput*>(handle->audioIoHandle);
- if (inputHandle == NULL) {
+ auto inputHandle = static_cast<CAudioInput*>(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<audio_io_s*>(input);
-
try {
- if (handle == NULL || sample_rate == NULL)
+ auto handle = static_cast<audio_io_s*>(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<audio_io_s*>(input);
-
try {
- if (handle == NULL || channel == NULL)
+ auto handle = static_cast<audio_io_s*>(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<audio_io_s*>(input);
-
try {
- if (handle == NULL || type == NULL)
+ auto handle = static_cast<audio_io_s*>(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) {
- au
dio_io_s* audioIo = static_cast<audio_io_s*>(user_data);
+ au
to audioIo = static_cast<audio_io_s*>(user_data);
assert(audioIo);
if (audioIo->stream_callback.onStream)
CAudioInfo::EAudioIOState state_prev,
bool by_policy,
void *user_data) {
- au
dio_io_s* audioIo = static_cast<audio_io_s*>(user_data);
+ au
to audioIo = static_cast<audio_io_s*>(user_data);
assert(audioIo);
if (audioIo->state_changed_callback.onStateChanged)
//LCOV_EXCL_STOP
int cpp_audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, void* user_data) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(input);
+ au
to handle = static_cast<audio_io_s*>(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<void*>(handle);
- cb.onStream = __stream_cb_internal;
+ auto cb = handle->audioIoHandle->getStreamCallback();
+ cb.set(__stream_cb_internal, static_cast<void*>(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);
}
int cpp_audio_in_unset_stream_cb(audio_in_h input) {
- audio_io_s* handle = static_cast<audio_io_s*>(input);
-
+ auto handle = static_cast<audio_io_s*>(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);
}
int cpp_audio_in_peek(audio_in_h input, const void **buffer, unsigned int *length) {
- audio_io_s* handle = static_cast<audio_io_s*>(input);
size_t _length = 0;
try {
- if (handle == NULL || buffer == NULL)
+ auto handle = static_cast<audio_io_s*>(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<CAudioInput*>(handle->audioIoHandle);
- if (inputHandle == NULL)
- THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
+ auto inputHandle = static_cast<CAudioInput*>(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;
}
int cpp_audio_in_drop(audio_in_h input) {
- audio_io_s* handle = static_cast<audio_io_s*>(input);
-
try {
- if (handle == NULL)
+ auto handle = static_cast<audio_io_s*>(input);
+ if (!handle)
THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,
"Parameters are NULL input:%p", input);
- CAudioInput* inputHandle = static_cast<CAudioInput*>(handle->audioIoHandle);
- if (inputHandle == NULL)
- THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
+ auto inputHandle = static_cast<CAudioInput*>(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) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(input);
+ au
to handle = static_cast<audio_io_s*>(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<void*>(handle);
- cb.onStateChanged = __state_changed_cb_internal;
+ auto cb = handle->audioIoHandle->getStateChangedCallback();
+ cb.set(__state_changed_cb_internal, static_cast<void*>(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);
}
int cpp_audio_in_unset_state_changed_cb(audio_in_h input) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(input);
+ au
to handle = static_cast<audio_io_s*>(input);
try {
- if (handle == NULL)
+ if (!handle)
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;
+ 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);
* 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);
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
}
}
int cpp_audio_out_destroy(audio_out_h output) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(output);
+ au
to handle = static_cast<audio_io_s*>(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);
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) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(output);
+ au
to handle = static_cast<audio_io_s*>(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);
}
int cpp_audio_out_prepare(audio_out_h output) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(output);
+ au
to handle = static_cast<audio_io_s*>(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);
}
int cpp_audio_out_unprepare(audio_out_h output) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(output);
+ au
to handle = static_cast<audio_io_s*>(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);
}
int cpp_audio_out_pause(audio_out_h output) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(output);
+ au
to handle = static_cast<audio_io_s*>(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);
}
int cpp_audio_out_resume(audio_out_h output) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(output);
+ au
to handle = static_cast<audio_io_s*>(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);
}
int cpp_audio_out_drain(audio_out_h output) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(output);
+ au
to handle = static_cast<audio_io_s*>(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<CAudioOutput*>(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);
}
int cpp_audio_out_flush(audio_out_h output) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(output);
+ au
to handle = static_cast<audio_io_s*>(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);
}
int cpp_audio_out_write(audio_out_h output, void *buffer, unsigned int length) {
- audio_io_s* handle = static_cast<audio_io_s*>(output);
int ret = 0;
try {
- if (handle == NULL || buffer == NULL)
+ auto handle = static_cast<audio_io_s*>(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<CAudioOutput*>(handle->audioIoHandle);
- if (outputHandle == NULL)
+ auto outputHandle = static_cast<CAudioOutput*>(handle->audioIoHandle);
+ if (!outputHandle)
THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
- size_t written = outputHandle->write(buffer, static_cast<size_t>(length));
+ auto written = outputHandle->write(buffer, static_cast<size_t>(length));
ret = static_cast<int>(written);
#ifdef _AUDIO_IO_DEBUG_TIMING_
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<audio_io_s*>(output);
-
try {
- if (handle == NULL || size == NULL)
+ auto handle = static_cast<audio_io_s*>(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<CAudioOutput*>(handle->audioIoHandle);
- if (outputHandle == NULL)
+ auto outputHandle = static_cast<CAudioOutput*>(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<audio_io_s*>(output);
-
try {
- if (handle == NULL || sample_rate == NULL)
+ auto handle = static_cast<audio_io_s*>(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<audio_io_s*>(output);
-
try {
- if (handle == NULL || channel == NULL)
+ auto handle = static_cast<audio_io_s*>(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<audio_io_s*>(output);
-
try {
- if (handle == NULL || type == NULL)
+ auto handle = static_cast<audio_io_s*>(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) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(output);
+ au
to handle = static_cast<audio_io_s*>(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) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(output);
+ au
to handle = static_cast<audio_io_s*>(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<void*>(handle);
- cb.onStream = __stream_cb_internal;
+ auto cb = handle->audioIoHandle->getStreamCallback();
+ cb.set(__stream_cb_internal, static_cast<void*>(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);
}
int cpp_audio_out_unset_stream_cb(audio_out_h output) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(output);
+ au
to handle = static_cast<audio_io_s*>(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);
}
int cpp_audio_out_set_state_changed_cb(audio_out_h output, audio_in_state_changed_cb callback, void* user_data) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(output);
+ au
to handle = static_cast<audio_io_s*>(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<void*>(handle);
- cb.onStateChanged = __state_changed_cb_internal;
+ auto cb = handle->audioIoHandle->getStateChangedCallback();
+ cb.set(__state_changed_cb_internal, static_cast<void*>(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);
}
int cpp_audio_out_unset_state_changed_cb(audio_out_h output) {
- au
dio_io_s* handle = static_cast<audio_io_s*>(output);
+ au
to handle = static_cast<audio_io_s*>(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);
projects / platform / core / api / audio-io.git / blobdiff