*/
-#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();
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;
}
}
-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:
dst_channel = 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 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;
}
}
-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:
dst_type = 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 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;
}
}
-static void _convert_audio_info_audio_type_2_sound_type(const CAudioInfo::EAudioType& src_type, sound_type_e& dst_type) {
+static void __convert_audio_info_audio_type_2_sound_type(const CAudioInfo::EAudioType& src_type, sound_type_e& dst_type) {
switch (src_type) {
case CAudioInfo::AUDIO_OUT_TYPE_MEDIA:
dst_type = SOUND_TYPE_MEDIA;
}
}
-static audio_io_state_e _convert_state_type(const CAudioInfo::EAudioIOState src_state) {
+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:
return dst_state;
}
-static void _check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e 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::ERROR_INVALID_ARGUMENT, "Invalid sample rate :%d", sample_rate);
}
}
}
-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);
+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::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) {
+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;
- _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;
- _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:
return AUDIO_IO_INTERRUPTED_COMPLETED;
THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
- _check_audio_param(sample_rate, channel, type);
+ __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");
}
- 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) {
*input = NULL;
VALID_POINTER_END
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
}
- _check_audio_param(sample_rate, channel, type);
+ __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");
}
- 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) {
*input = NULL;
VALID_POINTER_END
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
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;
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;
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;
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;
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;
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;
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;
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;
#endif
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return ret;
*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;
*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;
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;
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);
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;
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;
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);
}
}
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;
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 || buffer == NULL) {
CAudioInput* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
assert(inputHandle);
- inputHandle->peek(buffer, (size_t*)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;
}
inputHandle->drop();
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
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;
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;
THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
}
- _check_audio_param(sample_rate, channel, type, sound_type);
+ __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");
}
- 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) {
*output = NULL;
VALID_POINTER_END
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
}
- _check_audio_param(sample_rate, channel, type, SOUND_TYPE_SYSTEM /*default check */);
+ __check_audio_param(sample_rate, channel, type, SOUND_TYPE_SYSTEM /*default check */);
handle = new audio_io_s;
if (handle == NULL) {
THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
}
- CAudioInfo audioInfo = _generate_audio_output_info(sample_rate, channel, type, SOUND_TYPE_MEDIA /* default sound_type */);
+ CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, SOUND_TYPE_MEDIA /* default sound_type */);
handle->audioIoHandle = new CAudioOutput(audioInfo);
if (handle == NULL) {
*output = NULL;
VALID_POINTER_END
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return AUDIO_IO_ERROR_NONE;
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;
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;
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;
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;
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;
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;
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;
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;
#endif
} catch (CAudioError e) {
AUDIO_IO_LOGE("%s", e.getErrorMsg());
- return _convert_CAudioError(e);
+ return __convert_CAudioError(e);
}
return ret;
*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;
*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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
#include <string.h>
#include <unistd.h>
#include <math.h>
-#include <audio_io.h>
#include <sound_manager.h>
+#include <audio_io.h>
//#define _NEW_SOUND_MANAGER_API_
#define _SESSION_SOUND_MANAGER_API_
int buffer_size = 0;
char * buf = NULL;
- if(ch < 0 || ch > 2) {
+ if (ch < 0 || ch > 2) {
ch = 0;
}
audio_in_h input;
FILE* fp = fopen ("/tmp/dump_test.raw", "wb+");
- if(fp == NULL) {
+ if (fp == NULL) {
printf("open failed \n");
return 0;
}
}
ret = audio_in_get_buffer_size(input, &size);
- if(ret != AUDIO_IO_ERROR_NONE) {
+ if (ret != AUDIO_IO_ERROR_NONE) {
printf ("audio_in_get_buffer_size failed.\n");
goto exit;
}
- while(1) {
+ while (1) {
char *buffer = alloca(size);
if ((ret = audio_in_read(input, (void*)buffer, size)) > AUDIO_IO_ERROR_NONE) {
fwrite (buffer, size, sizeof(char), fp);
char *buffer = NULL;
ret = audio_in_create(16000, AUDIO_CHANNEL_MONO , AUDIO_SAMPLE_TYPE_S16_LE, &input);
- if(ret != AUDIO_IO_ERROR_NONE) {
+ if (ret != AUDIO_IO_ERROR_NONE) {
printf ("audio_in_create_ex failed. \n");
return 0;
}
//ret = audio_out_create(16000, AUDIO_CHANNEL_MONO , AUDIO_SAMPLE_TYPE_S16_LE, SOUND_TYPE_CALL, &output);
ret = audio_out_create_new(16000, AUDIO_CHANNEL_MONO , AUDIO_SAMPLE_TYPE_S16_LE, &output);
- if(ret != AUDIO_IO_ERROR_NONE) {
+ if (ret != AUDIO_IO_ERROR_NONE) {
printf ("audio_out_create failed. \n");
return 0;
}
return 0;
} else {
ret = audio_in_get_buffer_size(input, &size);
- if(ret != AUDIO_IO_ERROR_NONE) {
+ if (ret != AUDIO_IO_ERROR_NONE) {
printf ("audio_in_get_buffer_size failed.\n");
return 0;
} else {
return 0;
}
- if(buffer == NULL) {
+ if (buffer == NULL) {
printf("buffer is null\n");
return 0;
}
- while(1) {
+ while (1) {
ret = audio_in_read(input, (void*)buffer, size);
- if(ret > AUDIO_IO_ERROR_NONE) {
+ if (ret > AUDIO_IO_ERROR_NONE) {
ret = audio_out_write(output, buffer, size);
- if(ret > AUDIO_IO_ERROR_NONE) {
+ if (ret > AUDIO_IO_ERROR_NONE) {
printf("audio read/write success. buffer(%p), size(%d)\n", buffer, size);
} else {
printf("audio read success, write failed. buffer(%p), size(%d)\n", buffer, size);
}
memset (buffer, 0, nbytes);
- for(i=0; i<nbytes/2; i+=2)
+ for (i=0; i<nbytes/2; i+=2)
{
buffer[i] = (short) 32768 * test_wav.sine[test_wav.left_channel]; /* left */
buffer[i+1] = (short) 32768 * test_wav.sine[test_wav.right_channel]; /* right */
test_wav.left_channel += 1;
- if( test_wav.left_channel >= TABLE_SIZE ) test_wav.left_channel -= TABLE_SIZE;
+ if (test_wav.left_channel >= TABLE_SIZE) test_wav.left_channel -= TABLE_SIZE;
test_wav.right_channel += 3;
- if( test_wav.right_channel >= TABLE_SIZE ) test_wav.right_channel -= TABLE_SIZE;
+ if (test_wav.right_channel >= TABLE_SIZE) test_wav.right_channel -= TABLE_SIZE;
}
ret = audio_out_write(handle, buffer, nbytes);
- if(ret > AUDIO_IO_ERROR_NONE) {
+ if (ret > AUDIO_IO_ERROR_NONE) {
//printf("audio write success. buffer(%p), nbytes(%d)\n", buffer, nbytes);
}
int ret = 0;
switch (cmd) {
case 'P':
- if(mode & 0x01) ret = audio_out_prepare(output);
- if(mode & 0x02) ret = audio_in_prepare(input);
+ if (mode & 0x01) ret = audio_out_prepare(output);
+ if (mode & 0x02) ret = audio_in_prepare(input);
break;
case 'u':
- if(mode & 0x01) ret = audio_out_unprepare(output);
- if(mode & 0x02) ret = audio_in_unprepare(input);
+ if (mode & 0x01) ret = audio_out_unprepare(output);
+ if (mode & 0x02) ret = audio_in_unprepare(input);
break;
case 'p':
- if(mode & 0x01) ret = audio_out_pause(output);
- if(mode & 0x02) ret = audio_in_pause(input);
+ if (mode & 0x01) ret = audio_out_pause(output);
+ if (mode & 0x02) ret = audio_in_pause(input);
break;
case 'r':
- if(mode & 0x01) ret = audio_out_resume(output);
- if(mode & 0x02) ret = audio_in_resume(input);
+ if (mode & 0x01) ret = audio_out_resume(output);
+ if (mode & 0x02) ret = audio_in_resume(input);
break;
case 'd':
- if(mode & 0x01) ret = audio_out_drain(output);
- //if(mode & 0x02) ret = audio_in_drain(input);
+ if (mode & 0x01) ret = audio_out_drain(output);
+ //if (mode & 0x02) ret = audio_in_drain(input);
break;
case 'f':
- if(mode & 0x01) ret = audio_out_flush(output);
- if(mode & 0x02) ret = audio_in_flush(input);
+ if (mode & 0x01) ret = audio_out_flush(output);
+ if (mode & 0x02) ret = audio_in_flush(input);
break;
case 'i':
#ifdef _NEW_SOUND_MANAGER_API_
int write_mode = (mode & 0x01);
int read_mode = (mode & 0x02);
- if((write_mode == 0) && (read_mode == 0)) {
+ if ((write_mode == 0) && (read_mode == 0)) {
printf ("not vaild mode.\n");
return 0;
}
printf ("audio_in_create\n");
ret = audio_in_create(44100, AUDIO_CHANNEL_STEREO , AUDIO_SAMPLE_TYPE_S16_LE, &input);
- if(ret != AUDIO_IO_ERROR_NONE) {
+ if (ret != AUDIO_IO_ERROR_NONE) {
printf ("audio_in_create_ex failed. \n");
return 0;
}
printf ("audio_in_create success!!! [%p]\n", input);
ret = audio_in_set_stream_cb(input, _audio_io_stream_read_cb, NULL);
- if(ret != AUDIO_IO_ERROR_NONE) {
+ if (ret != AUDIO_IO_ERROR_NONE) {
printf ("audio_in_set_stream_cb failed. \n");
return 0;
}
printf ("audio_in_set_stream_cb success!!! [%p]\n", input);
ret = audio_in_set_state_changed_cb(input, _audio_in_state_cb, NULL);
- if(ret != AUDIO_IO_ERROR_NONE) {
+ if (ret != AUDIO_IO_ERROR_NONE) {
printf ("audio_out_set_state_changed_cb failed. \n");
return 0;
}
printf ("audio_out_create\n");
//ret = audio_out_create(44100, AUDIO_CHANNEL_STEREO , AUDIO_SAMPLE_TYPE_S16_LE, SOUND_TYPE_MEDIA, &output);
ret = audio_out_create_new(44100, AUDIO_CHANNEL_STEREO , AUDIO_SAMPLE_TYPE_S16_LE, &output);
- if(ret != AUDIO_IO_ERROR_NONE) {
+ if (ret != AUDIO_IO_ERROR_NONE) {
printf ("audio_out_create failed. \n");
return 0;
}
printf ("audio_out_create success!!! [%p]\n", output);
ret = audio_out_set_stream_cb(output, _audio_io_stream_write_cb, NULL);
- if(ret != AUDIO_IO_ERROR_NONE) {
+ if (ret != AUDIO_IO_ERROR_NONE) {
printf ("audio_out_set_stream_cb failed. \n");
return 0;
}
printf ("audio_out_set_stream_cb success!!! [%p]\n", output);
ret = audio_out_set_state_changed_cb(output, _audio_out_state_cb, NULL);
- if(ret != AUDIO_IO_ERROR_NONE) {
+ if (ret != AUDIO_IO_ERROR_NONE) {
printf ("audio_out_set_state_changed_cb failed. \n");
return 0;
}
ret = audio_out_set_interrupted_cb(output, interrupted_callback_write, NULL);
//generate wave data
- for(i=0; i<TABLE_SIZE; i++) {
+ for (i=0; i<TABLE_SIZE; i++) {
test_wav.sine[i] = 0.9 * (float) sin( ((double)i/(double)TABLE_SIZE) * M_PI * 2. );
}
test_wav.left_channel = test_wav.right_channel = 0;
return 0;
} else {
ret = audio_in_get_buffer_size(input, &size);
- if(ret != AUDIO_IO_ERROR_NONE) {
+ if (ret != AUDIO_IO_ERROR_NONE) {
printf ("audio_in_get_buffer_size failed.\n");
return 0;
} else {
}
}
- if(buffer == NULL) {
+ if (buffer == NULL) {
printf("buffer is null\n");
return 0;
}
do {
printf ("command(q:quit) : ");
cmd = (char) getchar();
- if(cmd != '\n') getchar();
+ if (cmd != '\n') getchar();
cmd_ret = _convert_cmd_and_run(cmd, mode);
printf (" - result code : %d\n", cmd_ret);
} while (cmd != 'q');