*/
-#include "audio_io.h"
#include "cpp_audio_io.h"
-#include "CAudioIODef.h"
#include <sound_manager_internal.h>
+#include "audio_io.h"
+#include "CAudioIODef.h"
using namespace std;
/**
* Internal functions
*/
-static audio_io_error_e _convert_CAudioError(CAudioError& error) {
+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)
- {
- case CAudioError::ERROR_NONE:
+ switch (err) {
+ case CAudioError::EError::ERROR_NONE:
ret = AUDIO_IO_ERROR_NONE;
break;
-
- case CAudioError::ERROR_INVALID_ARGUMENT:
- case CAudioError::ERROR_INVALID_HANDLE:
- case CAudioError::ERROR_INVALID_SAMPLERATE:
- case CAudioError::ERROR_INVALID_CHANNEL:
- case CAudioError::ERROR_INVALID_FORMAT:
+ 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;
-
- case CAudioError::ERROR_DEVICE_NOT_OPENED:
+ case CAudioError::EError::ERROR_DEVICE_NOT_OPENED:
ret = AUDIO_IO_ERROR_DEVICE_NOT_OPENED;
break;
-
- case CAudioError::ERROR_DEVICE_NOT_CLOSED:
+ case CAudioError::EError::ERROR_DEVICE_NOT_CLOSED:
ret = AUDIO_IO_ERROR_DEVICE_NOT_CLOSED;
break;
-
- case CAudioError::ERROR_PERMISSION_DENIED:
+ case CAudioError::EError::ERROR_PERMISSION_DENIED:
ret = AUDIO_IO_ERROR_PERMISSION_DENIED;
break;
-
- case CAudioError::ERROR_NOT_SUPPORTED:
+ case CAudioError::EError::ERROR_DEVICE_POLICY_RESTRICTION:
+ ret = AUDIO_IO_ERROR_DEVICE_POLICY_RESTRICTION;
+ break;
+ case CAudioError::EError::ERROR_NOT_SUPPORTED:
ret = AUDIO_IO_ERROR_NOT_SUPPORTED;
break;
-
- case CAudioError::ERROR_MAX:
- case CAudioError::ERROR_INTERNAL_OPERATION:
- case CAudioError::ERROR_NOT_INITIALIZED:
- case CAudioError::ERROR_FAILED_OPERATION:
- case CAudioError::ERROR_INVALID_OPERATION:
+ case CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE:
+ ret = AUDIO_IO_ERROR_NOT_SUPPORTED_TYPE;
+ break;
+ 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;
-
- case CAudioError::ERROR_OUT_OF_MEMORY:
- case CAudioError::ERROR_INVALID_POINTER:
+ case CAudioError::EError::ERROR_OUT_OF_MEMORY:
+ case CAudioError::EError::ERROR_INVALID_POINTER:
ret = AUDIO_IO_ERROR_INVALID_BUFFER;
break;
-
- case CAudioError::ERROR_POLICY_BLOCKED:
- case CAudioError::ERROR_POLICY_INTERRUPTED:
- case CAudioError::ERROR_POLICY_DUPLICATED:
+ 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 ret;
+ 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::CHANNEL_MONO;
+ dst_channel = CAudioInfo::EChannel::CHANNEL_MONO;
break;
case AUDIO_CHANNEL_STEREO:
- dst_channel = CAudioInfo::CHANNEL_STEREO;
+ dst_channel = CAudioInfo::EChannel::CHANNEL_STEREO;
break;
default:
- dst_channel = CAudioInfo::CHANNEL_MONO;
+ dst_channel = CAudioInfo::EChannel::CHANNEL_MONO;
}
}
-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::CHANNEL_MONO:
+ case CAudioInfo::EChannel::CHANNEL_MONO:
dst_channel = AUDIO_CHANNEL_MONO;
break;
- case CAudioInfo::CHANNEL_STEREO:
+ case CAudioInfo::EChannel::CHANNEL_STEREO:
dst_channel = AUDIO_CHANNEL_STEREO;
break;
default:
}
}
-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::SAMPLE_TYPE_U8;
+ dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_U8;
break;
case AUDIO_SAMPLE_TYPE_S16_LE:
- dst_type = CAudioInfo::SAMPLE_TYPE_S16_LE;
+ dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_S16_LE;
break;
default:
- dst_type = CAudioInfo::SAMPLE_TYPE_U8;
+ dst_type = 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 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::SAMPLE_TYPE_U8:
+ case CAudioInfo::ESampleType::SAMPLE_TYPE_U8:
dst_type = AUDIO_SAMPLE_TYPE_U8;
break;
- case CAudioInfo::SAMPLE_TYPE_S16_LE:
+ case CAudioInfo::ESampleType::SAMPLE_TYPE_S16_LE:
dst_type = AUDIO_SAMPLE_TYPE_S16_LE;
break;
default:
}
}
-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::AUDIO_OUT_TYPE_SYSTEM;
- break;
- case SOUND_TYPE_NOTIFICATION:
- dst_type = CAudioInfo::AUDIO_OUT_TYPE_NOTIFICATION;
- break;
- case SOUND_TYPE_ALARM:
- dst_type = CAudioInfo::AUDIO_OUT_TYPE_ALARM;
- break;
- case SOUND_TYPE_RINGTONE:
- dst_type = CAudioInfo::AUDIO_OUT_TYPE_RINGTONE_VOIP;
- break;
- case SOUND_TYPE_MEDIA:
- dst_type = CAudioInfo::AUDIO_OUT_TYPE_MEDIA;
- break;
- case SOUND_TYPE_CALL:
- dst_type = CAudioInfo::AUDIO_OUT_TYPE_SYSTEM;
- break;
- case SOUND_TYPE_VOIP:
- dst_type = CAudioInfo::AUDIO_OUT_TYPE_VOIP;
- break;
- case SOUND_TYPE_VOICE:
- dst_type = CAudioInfo::AUDIO_OUT_TYPE_VOICE_INFORMATION;
- break;
- default:
- dst_type = CAudioInfo::AUDIO_OUT_TYPE_MEDIA;
- break;
- }
-}
-
-static void _convert_audio_info_audio_type_2_sound_type(const CAudioInfo::EAudioType& src_type, sound_type_e& dst_type) {
+ case SOUND_TYPE_SYSTEM:
+ dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM;
+ break;
+ case SOUND_TYPE_NOTIFICATION:
+ dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_NOTIFICATION;
+ break;
+ case SOUND_TYPE_ALARM:
+ dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_ALARM;
+ break;
+ case SOUND_TYPE_RINGTONE:
+ dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_RINGTONE_VOIP;
+ break;
+ case SOUND_TYPE_MEDIA:
+ dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
+ break;
+ case SOUND_TYPE_CALL:
+ dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM;
+ break;
+ case SOUND_TYPE_VOIP:
+ dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOIP;
+ break;
+ case SOUND_TYPE_VOICE:
+ dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOICE_INFORMATION;
+ break;
+ default:
+ dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
+ break;
+ }
+}
+
+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::AUDIO_OUT_TYPE_MEDIA:
- dst_type = SOUND_TYPE_MEDIA;
- break;
- case CAudioInfo::AUDIO_OUT_TYPE_SYSTEM:
- dst_type = SOUND_TYPE_SYSTEM;
- break;
- case CAudioInfo::AUDIO_OUT_TYPE_ALARM:
- dst_type = SOUND_TYPE_ALARM;
- break;
- case CAudioInfo::AUDIO_OUT_TYPE_NOTIFICATION:
- case CAudioInfo::AUDIO_OUT_TYPE_EMERGENCY:
- dst_type = SOUND_TYPE_NOTIFICATION;
- break;
- case CAudioInfo::AUDIO_OUT_TYPE_VOICE_INFORMATION:
- case CAudioInfo::AUDIO_OUT_TYPE_VOICE_RECOGNITION:
- dst_type = SOUND_TYPE_VOICE;
- break;
- case CAudioInfo::AUDIO_OUT_TYPE_RINGTONE_VOIP:
- dst_type = SOUND_TYPE_RINGTONE;
- break;
- case CAudioInfo::AUDIO_OUT_TYPE_VOIP:
- dst_type = SOUND_TYPE_VOIP;
- break;
- default:
- dst_type = SOUND_TYPE_MEDIA;
- break;
- }
-}
-
-static audio_io_state_e _convert_state_type(const CAudioInfo::EAudioIOState src_state) {
+ case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA:
+ dst_type = SOUND_TYPE_MEDIA;
+ break;
+ case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM:
+ dst_type = SOUND_TYPE_SYSTEM;
+ break;
+ case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_ALARM:
+ dst_type = SOUND_TYPE_ALARM;
+ break;
+ case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_NOTIFICATION:
+ case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_EMERGENCY:
+ dst_type = SOUND_TYPE_NOTIFICATION;
+ break;
+ case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOICE_INFORMATION:
+ dst_type = SOUND_TYPE_VOICE;
+ break;
+ case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_RINGTONE_VOIP:
+ dst_type = SOUND_TYPE_RINGTONE;
+ break;
+ case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOIP:
+ dst_type = SOUND_TYPE_VOIP;
+ break;
+ default:
+ dst_type = SOUND_TYPE_MEDIA;
+ break;
+ }
+}
+
+static audio_io_state_e __convert_state_type(const CAudioInfo::EAudioIOState src_state) {
audio_io_state_e dst_state;
switch (src_state) {
- case CAudioInfo::AUDIO_IO_STATE_NONE:
+ case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE:
dst_state = AUDIO_IO_STATE_IDLE;
break;
- case CAudioInfo::AUDIO_IO_STATE_IDLE:
+ case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE:
dst_state = AUDIO_IO_STATE_IDLE;
break;
- case CAudioInfo::AUDIO_IO_STATE_RUNNING:
+ case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING:
dst_state = AUDIO_IO_STATE_RUNNING;
break;
- case CAudioInfo::AUDIO_IO_STATE_PAUSED:
+ case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED:
dst_state = AUDIO_IO_STATE_PAUSED;
break;
default:
return dst_state;
}
-static CAudioInfo _generate_audio_input_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw (CAudioError) {
+static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type) throw(CAudioError) {
+ 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) {
+ 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) {
+ 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) {
+ __check_audio_param(sample_rate, channel, type);
+
+ if (sound_type < SOUND_TYPE_SYSTEM || sound_type > SOUND_TYPE_VOICE) {
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid sound type : %d", sound_type);
+ }
+}
+
+static CAudioInfo __generate_audio_input_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw(CAudioError) {
CAudioInfo::EChannel dstChannel;
CAudioInfo::ESampleType dstSampleType;
- CAudioInfo::EAudioType dstAudioType = CAudioInfo::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);
+ __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_input_loopback_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw (CAudioError) {
+static CAudioInfo __generate_audio_input_loopback_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw(CAudioError) {
CAudioInfo::EChannel dstChannel;
CAudioInfo::ESampleType dstSampleType;
- CAudioInfo::EAudioType dstAudioType = CAudioInfo::AUDIO_IN_TYPE_LOOPBACK;
+ 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);
+ __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) {
+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;
- _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);
+ __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);
}
-static audio_io_interrupted_code_e _convert_interrupted_code(IAudioSessionEventListener::EInterruptCode code) {
+static audio_io_interrupted_code_e __convert_interrupted_code(IAudioSessionEventListener::EInterruptCode code) {
switch (code) {
- case IAudioSessionEventListener::INTERRUPT_COMPLETED:
+ case IAudioSessionEventListener::EInterruptCode::INTERRUPT_COMPLETED:
return AUDIO_IO_INTERRUPTED_COMPLETED;
- case IAudioSessionEventListener::INTERRUPT_BY_CALL:
+ case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_CALL:
return AUDIO_IO_INTERRUPTED_BY_CALL;
- case IAudioSessionEventListener::INTERRUPT_BY_EARJACK_UNPLUG:
+ case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_EARJACK_UNPLUG:
return AUDIO_IO_INTERRUPTED_BY_EARJACK_UNPLUG;
- case IAudioSessionEventListener::INTERRUPT_BY_RESOURCE_CONFLICT:
+ case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_RESOURCE_CONFLICT:
return AUDIO_IO_INTERRUPTED_BY_RESOURCE_CONFLICT;
- case IAudioSessionEventListener::INTERRUPT_BY_ALARM:
+ case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_ALARM:
return AUDIO_IO_INTERRUPTED_BY_ALARM;
- case IAudioSessionEventListener::INTERRUPT_BY_EMERGENCY:
+ case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_EMERGENCY:
return AUDIO_IO_INTERRUPTED_BY_EMERGENCY;
- case IAudioSessionEventListener::INTERRUPT_BY_NOTIFICATION:
+ case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_NOTIFICATION:
return AUDIO_IO_INTERRUPTED_BY_NOTIFICATION;
- case IAudioSessionEventListener::INTERRUPT_BY_MEDIA:
- case IAudioSessionEventListener::INTERRUPT_MAX:
+ case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_MEDIA:
+ case IAudioSessionEventListener::EInterruptCode::INTERRUPT_MAX:
default:
return AUDIO_IO_INTERRUPTED_BY_MEDIA;
}
audio_io_s* handle = NULL;
try {
if (input == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::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);
+
handle = new audio_io_s;
if (handle == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
}
- CAudioInfo audioInfo = _generate_audio_input_info(sample_rate, channel, type);
+ CAudioInfo audioInfo = __generate_audio_input_info(sample_rate, channel, type);
handle->audioIoHandle = new CAudioInput(audioInfo);
if (handle == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
}
handle->audioIoHandle->initialize();
*input = NULL;
VALID_POINTER_END
- return _convert_CAudioError(e);
+ 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::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);
+
handle = new audio_io_s;
if (handle == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
}
- CAudioInfo audioInfo = _generate_audio_input_loopback_info(sample_rate, channel, type);
+ CAudioInfo audioInfo = __generate_audio_input_loopback_info(sample_rate, channel, type);
handle->audioIoHandle = new CAudioInput(audioInfo);
if (handle == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
}
handle->audioIoHandle->initialize();
*input = NULL;
VALID_POINTER_END
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
assert(handle->audioIoHandle);
SAFE_DELETE(handle);
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL || stream_info == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, stream_info:%p", input, 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);
int errorCode = SOUND_MANAGER_ERROR_NONE;
- CAudioInfo::EAudioType AudioType = CAudioInfo::AUDIO_IN_TYPE_MEDIA;
+ CAudioInfo::EAudioType audioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA;
char *type = NULL;
int index = -1;
+ bool avail = false;
- if ((errorCode = sound_manager_get_type_from_stream_information (stream_info, &type)) != SOUND_MANAGER_ERROR_NONE) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->stream_type is invalid [ret:%d]", errorCode);
+ 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);
}
- handle->audioIoHandle->getAudioInfo().convertStreamType2AudioType(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::ERROR_INVALID_ARGUMENT, "Parameter stream_info->index is invalid [ret:%d]", errorCode);
+ if (avail) {
+ if ((errorCode = sound_manager_get_type_from_stream_information(stream_info, &type)) != SOUND_MANAGER_ERROR_NONE) {
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->stream_type is invalid [ret:%d]", errorCode);
+ }
+ handle->audioIoHandle->getAudioInfo().convertInputStreamType2AudioType(type, &audioType);
+ handle->audioIoHandle->getAudioInfo().setAudioType(audioType);
+
+ if ((errorCode = sound_manager_get_index_from_stream_information(stream_info, &index)) != SOUND_MANAGER_ERROR_NONE) {
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->index is invalid [ret:%d]", errorCode);
+ }
+ handle->audioIoHandle->getAudioInfo().setAudioIndex(index);
+ } else {
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE, "Input stream is not supported");
}
- handle->audioIoHandle->getAudioInfo().setAudioIndex(index);
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
assert(handle->audioIoHandle);
handle->audioIoHandle->prepare();
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
assert(handle->audioIoHandle);
handle->audioIoHandle->unprepare();
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
assert(handle->audioIoHandle);
handle->audioIoHandle->pause();
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
assert(handle->audioIoHandle);
handle->audioIoHandle->resume();
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
assert(handle->audioIoHandle);
handle->audioIoHandle->drain();
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
assert(handle->audioIoHandle);
handle->audioIoHandle->flush();
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
int ret = 0;
try {
- if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ 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<CAudioInput*>(handle->audioIoHandle);
- ret = inputHandle->read(buffer, length);
+ if (inputHandle == NULL) {
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
+ }
+ size_t readn = inputHandle->read(buffer, static_cast<size_t>(length));
+ ret = static_cast<int>(readn);
#ifdef _AUDIO_IO_DEBUG_TIMING_
- AUDIO_IO_LOGD("ret:%d", ret);
+ AUDIO_IO_LOGD("readn:%d", readn);
#endif
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return ret;
try {
if (handle == NULL || size == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, size:%p", input, size);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, size:%p", input, size);
}
assert(handle->audioIoHandle);
CAudioIO* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
+ if (inputHandle == NULL) {
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
+ }
*size = inputHandle->getBufferSize();
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL || sample_rate == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, sample_rate:%p", input, sample_rate);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, sample_rate:%p", input, sample_rate);
}
assert(handle->audioIoHandle);
*sample_rate = handle->audioIoHandle->getAudioInfo().getSampleRate();
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL || channel == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, channel:%p", input, 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);
+ __convert_audio_info_channel_2_channel(srcChannel, dstChannel);
*channel = dstChannel;
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL || type == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, type:%p", input, 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);
+ __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 __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
}
-static void _interrupt_cb_internal(IAudioSessionEventListener::EInterruptCode _code, void* user_data) {
+static void __interrupt_cb_internal(IAudioSessionEventListener::EInterruptCode _code, void* user_data) {
audio_io_s* handle = static_cast<audio_io_s*>(user_data);
- audio_io_interrupted_code_e code = _convert_interrupted_code(_code);
+ audio_io_interrupted_code_e code = __convert_interrupted_code(_code);
assert(handle);
try {
if (handle == NULL || callback == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback);
}
assert(handle->audioIoHandle);
CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
cb.mUserData = static_cast<void*>(handle);
- cb.onInterrupt = _interrupt_cb_internal;
+ cb.onInterrupt = __interrupt_cb_internal;
handle->audioIoHandle->setInterruptCallback(cb);
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
assert(handle->audioIoHandle);
handle->audioIoHandle->setInterruptCallback(cb);
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ 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) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
}
-static void _stream_cb_internal(size_t nbytes, void *user_data) {
+static void __stream_cb_internal(size_t nbytes, void *user_data) {
audio_io_s* audioIo = static_cast<audio_io_s*>(user_data);
assert(audioIo);
}
}
-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<audio_io_s*>(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);
+ audioIo->state_changed_callback.onStateChanged(audioIo, __convert_state_type(state_prev), __convert_state_type(state), by_policy, audioIo->state_changed_callback.user_data);
}
}
try {
if (handle == NULL || callback == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback);
}
assert(handle->audioIoHandle);
CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback();
cb.mUserData = static_cast<void*>(handle);
- cb.onStream = _stream_cb_internal;
+ cb.onStream = __stream_cb_internal;
handle->audioIoHandle->setStreamCallback(cb);
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
assert(handle->audioIoHandle);
handle->audioIoHandle->setStreamCallback(cb);
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
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) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ 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<CAudioInput*>(handle->audioIoHandle);
assert(inputHandle);
- inputHandle->peek(buffer, length);
+ inputHandle->peek(buffer, &_length);
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
+ *length = (unsigned int)_length;
+
return AUDIO_IO_ERROR_NONE;
}
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
CAudioInput* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
inputHandle->drop();
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
audio_io_s* handle = static_cast<audio_io_s*>(input);
try {
- if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%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);
CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback();
cb.mUserData = static_cast<void*>(handle);
- cb.onStateChanged = _state_changed_cb_internal;
+ cb.onStateChanged = __state_changed_cb_internal;
handle->audioIoHandle->setStateChangedCallback(cb);
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", input);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", input);
}
assert(handle->audioIoHandle);
handle->audioIoHandle->setStateChangedCallback(cb);
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
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::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
}
- CAudioInfo audioInfo = _generate_audio_output_info(sample_rate, channel, type, sound_type);
+ CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, sound_type);
handle->audioIoHandle = new CAudioOutput(audioInfo);
if (handle == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
}
handle->audioIoHandle->initialize();
VALID_POINTER_END
VALID_POINTER_START(output)
- *output = NULL;
+ *output = NULL;
VALID_POINTER_END
- return _convert_CAudioError(e);
+ 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);
+ }
+
+ __check_audio_param(sample_rate, channel, type, SOUND_TYPE_SYSTEM /*default check */);
+
handle = new audio_io_s;
if (handle == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
+ 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_tyoe */);
+ CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, SOUND_TYPE_MEDIA /* default sound_type */);
handle->audioIoHandle = new CAudioOutput(audioInfo);
if (handle == NULL) {
- THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
}
handle->audioIoHandle->initialize();
VALID_POINTER_END
VALID_POINTER_START(output)
- *output = NULL;
+ *output = NULL;
VALID_POINTER_END
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
}
assert(handle->audioIoHandle);
SAFE_DELETE(handle);
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL || stream_info == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, stream_info:%p", output, 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);
int errorCode = SOUND_MANAGER_ERROR_NONE;
- CAudioInfo::EAudioType AudioType = CAudioInfo::AUDIO_OUT_TYPE_MEDIA;
+ CAudioInfo::EAudioType audioType = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
char *type = NULL;
int index = -1;
+ bool avail = false;
- if ((errorCode = sound_manager_get_type_from_stream_information (stream_info, &type)) != SOUND_MANAGER_ERROR_NONE) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->stream_type is invalid [ret:%d]", errorCode);
+ 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);
}
- handle->audioIoHandle->getAudioInfo().convertStreamType2AudioType(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::ERROR_INVALID_ARGUMENT, "Parameter stream_info->index is invalid [ret:%d]", errorCode);
+ if (avail) {
+ if ((errorCode = sound_manager_get_type_from_stream_information(stream_info, &type)) != SOUND_MANAGER_ERROR_NONE) {
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->stream_type is invalid [ret:%d]", errorCode);
+ }
+ handle->audioIoHandle->getAudioInfo().convertOutputStreamType2AudioType(type, &audioType);
+ handle->audioIoHandle->getAudioInfo().setAudioType(audioType);
+
+ if ((errorCode = sound_manager_get_index_from_stream_information(stream_info, &index)) != SOUND_MANAGER_ERROR_NONE) {
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->index is invalid [ret:%d]", errorCode);
+ }
+ handle->audioIoHandle->getAudioInfo().setAudioIndex(index);
+ } else {
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE, "Output stream is not supported");
}
- handle->audioIoHandle->getAudioInfo().setAudioIndex(index);
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
}
assert(handle->audioIoHandle);
handle->audioIoHandle->prepare();
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
}
assert(handle->audioIoHandle);
handle->audioIoHandle->unprepare();
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
}
assert(handle->audioIoHandle);
handle->audioIoHandle->pause();
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
}
assert(handle->audioIoHandle);
handle->audioIoHandle->resume();
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
}
assert(handle->audioIoHandle);
handle->audioIoHandle->drain();
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
}
assert(handle->audioIoHandle);
handle->audioIoHandle->flush();
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
int ret = 0;
try {
- if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+ 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<CAudioOutput*>(handle->audioIoHandle);
- ret = outputHandle->write(buffer, length);
+ if (outputHandle == NULL) {
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
+ }
+ size_t writen = outputHandle->write(buffer, static_cast<size_t>(length));
+ ret = static_cast<int>(writen);
#ifdef _AUDIO_IO_DEBUG_TIMING_
- AUDIO_IO_LOGD("ret:%d", ret);
+ AUDIO_IO_LOGD("writen:%d", writen);
#endif
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return ret;
try {
if (handle == NULL || size == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, size:%p", output, size);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, size:%p", output, size);
}
assert(handle->audioIoHandle);
CAudioOutput* outputHandle = dynamic_cast<CAudioOutput*>(handle->audioIoHandle);
+ if (outputHandle == NULL) {
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
+ }
*size = outputHandle->getBufferSize();
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL || sample_rate == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, sample_rate:%p", output, sample_rate);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, sample_rate:%p", output, sample_rate);
}
assert(handle->audioIoHandle);
*sample_rate = handle->audioIoHandle->getAudioInfo().getSampleRate();
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL || channel == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, channel:%p", output, 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);
+ __convert_audio_info_channel_2_channel(srcChannel, dstChannel);
*channel = dstChannel;
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL || type == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, type:%p", output, 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);
+ __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 __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL || type == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, type:%p", output, 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);
+ __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 __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL || callback == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback);
}
assert(handle->audioIoHandle);
CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
cb.mUserData = static_cast<void*>(handle);
- cb.onInterrupt = _interrupt_cb_internal;
+ cb.onInterrupt = __interrupt_cb_internal;
handle->audioIoHandle->setInterruptCallback(cb);
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
}
assert(handle->audioIoHandle);
handle->audioIoHandle->setInterruptCallback(cb);
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+ 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) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
audio_io_s* handle = static_cast<audio_io_s*>(output);
try {
- if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::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);
CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback();
cb.mUserData = static_cast<void*>(handle);
- cb.onStream = _stream_cb_internal;
+ cb.onStream = __stream_cb_internal;
handle->audioIoHandle->setStreamCallback(cb);
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
}
assert(handle->audioIoHandle);
handle->audioIoHandle->setStreamCallback(cb);
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
audio_io_s* handle = static_cast<audio_io_s*>(output);
try {
- if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::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);
CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback();
cb.mUserData = static_cast<void*>(handle);
- cb.onStateChanged = _state_changed_cb_internal;
+ cb.onStateChanged = __state_changed_cb_internal;
handle->audioIoHandle->setStateChangedCallback(cb);
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
try {
if (handle == NULL) {
- THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
}
assert(handle->audioIoHandle);
handle->audioIoHandle->setStateChangedCallback(cb);
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;