-lib_LTLIBRARIES = libtizen-audio.la
+lib_LTLIBRARIES = libhal-backend-audio.la
-libtizen_audio_la_SOURCES = tizen-audio.c \
+libhal_backend_audio_la_SOURCES = tizen-audio.c \
tizen-audio-volume.c \
tizen-audio-routing.c \
tizen-audio-stream.c \
tizen-audio-ctrl.c \
tizen-audio-impl-pcm.c \
tizen-audio-impl-ucm.c \
- tizen-audio-impl-ctrl.c
-libtizen_audio_la_LDFLAGS = $(AM_LDFLAGS) -disable-static -avoid-version
-libtizen_audio_la_LIBADD = $(AM_LDADD) $(ASOUNDLIB_LIBS) $(VCONF_LIBS) $(DLOG_LIBS) $(INIPARSER_LIBS) $(EXPAT_LIBS)
-libtizen_audio_la_CFLAGS = $(AM_CFLAGS) $(ASOUNDLIB_CFLAGS) $(VCONF_CFLAGS) $(DLOG_CFLAGS) $(INIPARSER_CFLAGS) $(EXPAT_CFLAGS) -DUSE_DLOG
+ tizen-audio-impl-ctrl.c \
+ hal-backend-audio.c
+libhal_backend_audio_la_LDFLAGS = $(AM_LDFLAGS) -disable-static -avoid-version
+libhal_backend_audio_la_LIBADD = $(AM_LDADD) $(ASOUNDLIB_LIBS) $(VCONF_LIBS) $(DLOG_LIBS) $(INIPARSER_LIBS) $(EXPAT_LIBS)
+libhal_backend_audio_la_CFLAGS = $(AM_CFLAGS) $(ASOUNDLIB_CFLAGS) $(VCONF_CFLAGS) $(DLOG_CFLAGS) $(INIPARSER_CFLAGS) $(EXPAT_CFLAGS) $(HALAPICOMMON) -DUSE_DLOG
if USE_TINYALSA
-libtizen_audio_la_LIBADD += $(TINYALSA_LIBS)
-libtizen_audio_la_CFLAGS += $(TINYALSA_CFLAGS) -D__USE_TINYALSA__
+libhal_backend_audio_la_LIBADD += $(TINYALSA_LIBS)
+libhal_backend_audio_la_CFLAGS += $(TINYALSA_CFLAGS) -D__USE_TINYALSA__
endif
AC_SUBST(EXPAT_CFLAGS)
AC_SUBST(EXPAT_LIBS)
+PKG_CHECK_MODULES(HALAPICOMMON, hal-api-common)
+AC_SUBST(HALAPICOMMON_CFLAGS)
+AC_SUBST(HALAPICOMMON_LIBS)
+
# Checks for header files.
# Checks for typedefs, structures, and compiler characteristics.
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <errno.h>
+#include <tizen-audio.h>
+#include <hal/hal-common-interface.h>
+
+static int audio_sc7727_init(void **data)
+{
+ hal_backend_audio_funcs *funcs;
+
+ funcs = calloc(1, sizeof(hal_backend_audio_funcs));
+ if (!funcs)
+ return -ENOMEM;
+
+ funcs->init = audio_init;
+ funcs->deinit = audio_deinit;
+ funcs->get_volume_level_max = audio_get_volume_level_max;
+ funcs->set_volume_level = audio_set_volume_level;
+ funcs->get_volume_value = audio_get_volume_value;
+ funcs->get_volume_mute = audio_get_volume_mute;
+ funcs->set_volume_mute = audio_set_volume_mute;
+ funcs->set_volume_ratio = audio_set_volume_ratio;
+ funcs->update_route = audio_update_route;
+ funcs->update_route_option = audio_update_route_option;
+ funcs->notify_stream_connection_changed = audio_notify_stream_connection_changed;
+ funcs->pcm_open = audio_pcm_open;
+ funcs->pcm_start = audio_pcm_start;
+ funcs->pcm_stop = audio_pcm_stop;
+ funcs->pcm_close = audio_pcm_close;
+ funcs->pcm_avail = audio_pcm_avail;
+ funcs->pcm_write = audio_pcm_write;
+ funcs->pcm_read = audio_pcm_read;
+ funcs->pcm_get_fd = audio_pcm_get_fd;
+ funcs->pcm_recover = audio_pcm_recover;
+ funcs->pcm_get_params = audio_pcm_get_params;
+ funcs->pcm_set_params = audio_pcm_set_params;
+
+ *data = (void *)funcs;
+
+ return 0;
+}
+
+static void audio_sc7727_exit(void *data)
+{
+ if (!data)
+ return;
+
+ free(data);
+}
+
+hal_backend hal_backend_audio_data = {
+ .name = "audio-sc7727",
+ .vendor = "sprd",
+ .abi_version = HAL_ABI_VERSION_TIZEN_6_5,
+ .init = audio_sc7727_init,
+ .exit = audio_sc7727_exit,
+};
Name: audio-hal-sc7727
Summary: TIZEN Audio HAL for SC7727
-Version: 0.1.34
+Version: 0.1.35
Release: 0
Group: System/Libraries
License: Apache-2.0
BuildRequires: pkgconfig(alsa)
#BuildRequires: pkgconfig(tinyalsa)
BuildRequires: pkgconfig(expat)
-Provides: libtizen-audio.so
+BuildRequires: pkgconfig(hal-api-common)
+BuildRequires: pkgconfig(hal-api-audio)
+Provides: libhal-backend-audio.so
%description
TIZEN Audio HAL for SC7727
export USE_TINYALSA="0"
%autogen
-%configure
+./configure --libdir=%{_hal_libdir}
make %{?jobs:-j%jobs}
%files
%manifest audio-hal-sc7727.manifest
%defattr(-,root,root,-)
-%{_libdir}/libtizen-audio.so
+%{_hal_libdir}/libhal-backend-audio.so
%license LICENSE.APLv2
#include "tizen-audio-internal.h"
-static audio_return_t __set_message_callback(audio_hal_t *ah, message_cb callback, void *user_data)
+static audio_return_e __set_message_callback(audio_hal_t *ah, message_cb callback, void *user_data)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(callback, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-static audio_return_t __unset_message_callback(audio_hal_t *ah)
+static audio_return_e __unset_message_callback(audio_hal_t *ah)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t _audio_comm_init(audio_hal_t *ah)
+audio_return_e _audio_comm_init(audio_hal_t *ah)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t _audio_comm_deinit(audio_hal_t *ah)
+audio_return_e _audio_comm_deinit(audio_hal_t *ah)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t _audio_comm_send_message(audio_hal_t *ah, const char *name, int value)
+audio_return_e _audio_comm_send_message(audio_hal_t *ah, const char *name, int value)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(name, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t audio_add_message_cb(void *audio_handle, message_cb callback, void *user_data)
+audio_return_e audio_add_message_cb(void *audio_handle, message_cb callback, void *user_data)
{
- audio_return_t ret = AUDIO_RET_OK;
+ audio_return_e ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(callback, AUDIO_ERR_PARAMETER);
return ret;
}
-audio_return_t audio_remove_message_cb(void *audio_handle, message_cb callback)
+audio_return_e audio_remove_message_cb(void *audio_handle, message_cb callback)
{
- audio_return_t ret = AUDIO_RET_OK;
+ audio_return_e ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(callback, AUDIO_ERR_PARAMETER);
#include "tizen-audio-internal.h"
#include "tizen-audio-impl.h"
-audio_return_t _audio_ctrl_init(audio_hal_t *ah)
+audio_return_e _audio_ctrl_init(audio_hal_t *ah)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t _audio_ctrl_deinit(audio_hal_t *ah)
+audio_return_e _audio_ctrl_deinit(audio_hal_t *ah)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
}
#endif
-audio_return_t _mixer_control_init(audio_hal_t *ah)
+audio_return_e _mixer_control_init(audio_hal_t *ah)
{
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return AUDIO_RET_OK;
}
-audio_return_t _mixer_control_deinit(audio_hal_t *ah)
+audio_return_e _mixer_control_deinit(audio_hal_t *ah)
{
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return AUDIO_RET_OK;
}
-audio_return_t _mixer_control_set_param(audio_hal_t *ah, const char* ctl_name, snd_ctl_elem_value_t* param, int size)
+audio_return_e _mixer_control_set_param(audio_hal_t *ah, const char* ctl_name, snd_ctl_elem_value_t* param, int size)
{
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return AUDIO_RET_OK;
}
-audio_return_t _mixer_control_get_value(audio_hal_t *ah, const char *ctl_name, int *val)
+audio_return_e _mixer_control_get_value(audio_hal_t *ah, const char *ctl_name, int *val)
{
snd_ctl_t *handle;
snd_ctl_elem_value_t *control;
return AUDIO_ERR_UNDEFINED;
}
-audio_return_t _mixer_control_set_value(audio_hal_t *ah, const char *ctl_name, int val)
+audio_return_e _mixer_control_set_value(audio_hal_t *ah, const char *ctl_name, int val)
{
snd_ctl_t *handle;
snd_ctl_elem_value_t *control;
return AUDIO_ERR_UNDEFINED;
}
-audio_return_t _mixer_control_set_value_string(audio_hal_t *ah, const char* ctl_name, const char* value)
+audio_return_e _mixer_control_set_value_string(audio_hal_t *ah, const char* ctl_name, const char* value)
{
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(ctl_name, AUDIO_ERR_PARAMETER);
}
-audio_return_t _mixer_control_get_element(audio_hal_t *ah, const char *ctl_name, snd_hctl_elem_t **elem)
+audio_return_e _mixer_control_get_element(audio_hal_t *ah, const char *ctl_name, snd_hctl_elem_t **elem)
{
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(ctl_name, AUDIO_ERR_PARAMETER);
}
#endif
-audio_return_t _fmradio_pcm_open(audio_hal_t *ah)
+audio_return_e _fmradio_pcm_open(audio_hal_t *ah)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
int ret = 0;
const char *device_name = NULL;
audio_pcm_sample_spec_t sample_spec;
return audio_ret;
}
-audio_return_t _fmradio_pcm_close(audio_hal_t *ah)
+audio_return_e _fmradio_pcm_close(audio_hal_t *ah)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t _voice_pcm_open(audio_hal_t *ah)
+audio_return_e _voice_pcm_open(audio_hal_t *ah)
{
int err, ret = 0;
return (ret == 0 ? AUDIO_RET_OK : AUDIO_ERR_INTERNAL);
}
-audio_return_t _voice_pcm_close(audio_hal_t *ah, uint32_t direction)
+audio_return_e _voice_pcm_close(audio_hal_t *ah, uint32_t direction)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t _reset_pcm_devices(audio_hal_t *ah)
+audio_return_e _reset_pcm_devices(audio_hal_t *ah)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
}
#endif
-audio_return_t _pcm_open(const char *card, const char *device, uint32_t direction, void *sample_spec,
+audio_return_e _pcm_open(const char *card, const char *device, uint32_t direction, void *sample_spec,
uint32_t period_size, uint32_t periods, void **pcm_handle)
{
int err;
#else /* alsa-lib */
int mode;
- audio_return_t ret;
+ audio_return_e ret;
char device_name[DEVICE_NAME_MAX];
__make_alsa_device_name(card, device, device_name);
return AUDIO_RET_OK;
}
-audio_return_t _pcm_start(void *pcm_handle)
+audio_return_e _pcm_start(void *pcm_handle)
{
int err;
return AUDIO_RET_OK;
}
-audio_return_t _pcm_stop(void *pcm_handle)
+audio_return_e _pcm_stop(void *pcm_handle)
{
int err;
return AUDIO_RET_OK;
}
-audio_return_t _pcm_close(void *pcm_handle)
+audio_return_e _pcm_close(void *pcm_handle)
{
int err;
return AUDIO_RET_OK;
}
-audio_return_t _pcm_avail(void *pcm_handle, uint32_t *avail)
+audio_return_e _pcm_avail(void *pcm_handle, uint32_t *avail)
{
#ifdef __USE_TINYALSA__
struct timespec tspec;
return AUDIO_RET_OK;
}
-audio_return_t _pcm_write(void *pcm_handle, const void *buffer, uint32_t frames)
+audio_return_e _pcm_write(void *pcm_handle, const void *buffer, uint32_t frames)
{
#ifdef __USE_TINYALSA__
int err;
return AUDIO_RET_OK;
}
-audio_return_t _pcm_read(void *pcm_handle, void *buffer, uint32_t frames)
+audio_return_e _pcm_read(void *pcm_handle, void *buffer, uint32_t frames)
{
#ifdef __USE_TINYALSA__
int err;
return AUDIO_RET_OK;
}
-audio_return_t _pcm_get_fd(void *pcm_handle, int *fd)
+audio_return_e _pcm_get_fd(void *pcm_handle, int *fd)
{
/* we use an internal API of the (tiny)alsa library, so it causes warning message during compile */
#ifdef __USE_TINYALSA__
return AUDIO_RET_OK;
}
-audio_return_t _pcm_recover(void *pcm_handle, int revents)
+audio_return_e _pcm_recover(void *pcm_handle, int revents)
{
int state, err;
return AUDIO_RET_OK;
}
-audio_return_t _pcm_get_params(void *pcm_handle, uint32_t direction, void **sample_spec, uint32_t *period_size, uint32_t *periods)
+audio_return_e _pcm_get_params(void *pcm_handle, uint32_t direction, void **sample_spec, uint32_t *period_size, uint32_t *periods)
{
#ifdef __USE_TINYALSA__
audio_pcm_sample_spec_t *ss;
return AUDIO_RET_OK;
}
-audio_return_t _pcm_set_params(void *pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods)
+audio_return_e _pcm_set_params(void *pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods)
{
#ifdef __USE_TINYALSA__
/* Parameters are only acceptable in pcm_open() function */
}
/* Generic snd pcm interface APIs */
-audio_return_t _pcm_set_hw_params(snd_pcm_t *pcm, audio_pcm_sample_spec_t *sample_spec, uint8_t *use_mmap, snd_pcm_uframes_t *period_size, snd_pcm_uframes_t *buffer_size)
+audio_return_e _pcm_set_hw_params(snd_pcm_t *pcm, audio_pcm_sample_spec_t *sample_spec, uint8_t *use_mmap, snd_pcm_uframes_t *period_size, snd_pcm_uframes_t *buffer_size)
{
- audio_return_t ret = AUDIO_RET_OK;
+ audio_return_e ret = AUDIO_RET_OK;
snd_pcm_hw_params_t *hwparams;
int err = 0;
int dir;
return AUDIO_ERR_RESOURCE;
}
-audio_return_t _pcm_set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t avail_min, uint8_t period_event)
+audio_return_e _pcm_set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t avail_min, uint8_t period_event)
{
snd_pcm_sw_params_t *swparams;
snd_pcm_uframes_t boundary;
}
#endif
-audio_return_t _ucm_init(audio_hal_t *ah)
+audio_return_e _ucm_init(audio_hal_t *ah)
{
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return AUDIO_RET_OK;
}
-audio_return_t _ucm_deinit(audio_hal_t *ah)
+audio_return_e _ucm_deinit(audio_hal_t *ah)
{
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(ah->ucm.uc_mgr, AUDIO_ERR_PARAMETER);
return AUDIO_RET_OK;
}
-audio_return_t _ucm_get_device_name(audio_hal_t *ah, const char *use_case, audio_direction_t direction, const char **value)
+audio_return_e _ucm_get_device_name(audio_hal_t *ah, const char *use_case, audio_direction_e direction, const char **value)
{
char identifier[70] = { 0, };
2) If verb is changed
-> Reset, set new verb, enable devices & modifiers
*/
-audio_return_t _ucm_set_use_case(audio_hal_t *ah, const char *verb, const char *devices[], const char *modifiers[])
+audio_return_e _ucm_set_use_case(audio_hal_t *ah, const char *verb, const char *devices[], const char *modifiers[])
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
int is_verb_changed = 0, is_dev_changed = 0, is_mod_changed = 0;
const char *old_verb = NULL, **old_dev_list = NULL, **old_mod_list = NULL;
int old_dev_count = 0, dev_count = 0;
return audio_ret;
}
-audio_return_t _ucm_set_devices(audio_hal_t *ah, const char *verb, const char *devices[])
+audio_return_e _ucm_set_devices(audio_hal_t *ah, const char *verb, const char *devices[])
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
int is_verb_changed = 0, is_dev_changed = 0;
const char *old_verb = NULL, **old_dev_list = NULL;
int old_dev_count = 0, dev_count = 0;
}
-audio_return_t _ucm_set_modifiers(audio_hal_t *ah, const char *verb, const char *modifiers[])
+audio_return_e _ucm_set_modifiers(audio_hal_t *ah, const char *verb, const char *modifiers[])
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
int is_verb_changed = 0, is_mod_changed = 0;
const char *old_verb = NULL, **old_mod_list = NULL;
int old_mod_count = 0, mod_count = 0;
return audio_ret;
}
-audio_return_t _ucm_get_verb(audio_hal_t *ah, const char **value)
+audio_return_e _ucm_get_verb(audio_hal_t *ah, const char **value)
{
- audio_return_t ret = AUDIO_RET_OK;
+ audio_return_e ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(ah->ucm.uc_mgr, AUDIO_ERR_PARAMETER);
return ret;
}
-audio_return_t _ucm_reset_use_case(audio_hal_t *ah)
+audio_return_e _ucm_reset_use_case(audio_hal_t *ah)
{
- audio_return_t ret = AUDIO_RET_OK;
+ audio_return_e ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(ah->ucm.uc_mgr, AUDIO_ERR_PARAMETER);
*/
/* PCM */
-audio_return_t _fmradio_pcm_open(audio_hal_t *ah);
-audio_return_t _fmradio_pcm_close(audio_hal_t *ah);
-audio_return_t _voice_pcm_open(audio_hal_t *ah);
-audio_return_t _voice_pcm_close(audio_hal_t *ah, uint32_t direction);
-audio_return_t _reset_pcm_devices(audio_hal_t *ah);
-audio_return_t _pcm_open(const char *card, const char *device, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods, void **pcm_handle);
-audio_return_t _pcm_start(void *pcm_handle);
-audio_return_t _pcm_stop(void *pcm_handle);
-audio_return_t _pcm_close(void *pcm_handle);
-audio_return_t _pcm_avail(void *pcm_handle, uint32_t *avail);
-audio_return_t _pcm_write(void *pcm_handle, const void *buffer, uint32_t frames);
-audio_return_t _pcm_read(void *pcm_handle, void *buffer, uint32_t frames);
-audio_return_t _pcm_get_fd(void *pcm_handle, int *fd);
-audio_return_t _pcm_recover(void *pcm_handle, int revents);
-audio_return_t _pcm_get_params(void *pcm_handle, uint32_t direction, void **sample_spec, uint32_t *period_size, uint32_t *periods);
-audio_return_t _pcm_set_params(void *pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods);
-audio_return_t _pcm_set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t avail_min, uint8_t period_event);
-audio_return_t _pcm_set_hw_params(snd_pcm_t *pcm, audio_pcm_sample_spec_t *sample_spec, uint8_t *use_mmap, snd_pcm_uframes_t *period_size, snd_pcm_uframes_t *buffer_size);
+audio_return_e _fmradio_pcm_open(audio_hal_t *ah);
+audio_return_e _fmradio_pcm_close(audio_hal_t *ah);
+audio_return_e _voice_pcm_open(audio_hal_t *ah);
+audio_return_e _voice_pcm_close(audio_hal_t *ah, uint32_t direction);
+audio_return_e _reset_pcm_devices(audio_hal_t *ah);
+audio_return_e _pcm_open(const char *card, const char *device, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods, void **pcm_handle);
+audio_return_e _pcm_start(void *pcm_handle);
+audio_return_e _pcm_stop(void *pcm_handle);
+audio_return_e _pcm_close(void *pcm_handle);
+audio_return_e _pcm_avail(void *pcm_handle, uint32_t *avail);
+audio_return_e _pcm_write(void *pcm_handle, const void *buffer, uint32_t frames);
+audio_return_e _pcm_read(void *pcm_handle, void *buffer, uint32_t frames);
+audio_return_e _pcm_get_fd(void *pcm_handle, int *fd);
+audio_return_e _pcm_recover(void *pcm_handle, int revents);
+audio_return_e _pcm_get_params(void *pcm_handle, uint32_t direction, void **sample_spec, uint32_t *period_size, uint32_t *periods);
+audio_return_e _pcm_set_params(void *pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods);
+audio_return_e _pcm_set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t avail_min, uint8_t period_event);
+audio_return_e _pcm_set_hw_params(snd_pcm_t *pcm, audio_pcm_sample_spec_t *sample_spec, uint8_t *use_mmap, snd_pcm_uframes_t *period_size, snd_pcm_uframes_t *buffer_size);
/* Control */
#define VBC_TD_CHANNELID 0 /* cp [3g] */
#define MIXER_FMRADIO_MUTE "Digital FM Function"
#define FMRADIO_MUTE_ON 0
#define FMRADIO_MUTE_OFF 1
-audio_return_t _mixer_control_init(audio_hal_t *ah);
-audio_return_t _mixer_control_deinit(audio_hal_t *ah);
-audio_return_t _mixer_control_set_param(audio_hal_t *ah, const char* ctl_name, snd_ctl_elem_value_t* value, int size);
-audio_return_t _mixer_control_set_value(audio_hal_t *ah, const char *ctl_name, int val);
-audio_return_t _mixer_control_set_value_string(audio_hal_t *ah, const char* ctl_name, const char* value);
-audio_return_t _mixer_control_get_value(audio_hal_t *ah, const char *ctl_name, int *val);
-audio_return_t _mixer_control_get_element(audio_hal_t *ah, const char *ctl_name, snd_hctl_elem_t **elem);
+audio_return_e _mixer_control_init(audio_hal_t *ah);
+audio_return_e _mixer_control_deinit(audio_hal_t *ah);
+audio_return_e _mixer_control_set_param(audio_hal_t *ah, const char* ctl_name, snd_ctl_elem_value_t* value, int size);
+audio_return_e _mixer_control_set_value(audio_hal_t *ah, const char *ctl_name, int val);
+audio_return_e _mixer_control_set_value_string(audio_hal_t *ah, const char* ctl_name, const char* value);
+audio_return_e _mixer_control_get_value(audio_hal_t *ah, const char *ctl_name, int *val);
+audio_return_e _mixer_control_get_element(audio_hal_t *ah, const char *ctl_name, snd_hctl_elem_t **elem);
/* UCM */
-audio_return_t _ucm_init(audio_hal_t *ah);
-audio_return_t _ucm_deinit(audio_hal_t *ah);
-audio_return_t _ucm_get_device_name(audio_hal_t *ah, const char *use_case, audio_direction_t direction, const char **value);
+audio_return_e _ucm_init(audio_hal_t *ah);
+audio_return_e _ucm_deinit(audio_hal_t *ah);
+audio_return_e _ucm_get_device_name(audio_hal_t *ah, const char *use_case, audio_direction_e direction, const char **value);
#define _ucm_update_use_case _ucm_set_use_case
-audio_return_t _ucm_set_use_case(audio_hal_t *ah, const char *verb, const char *devices[], const char *modifiers[]);
-audio_return_t _ucm_set_devices(audio_hal_t *ah, const char *verb, const char *devices[]);
-audio_return_t _ucm_set_modifiers(audio_hal_t *ah, const char *verb, const char *modifiers[]);
-audio_return_t _ucm_get_verb(audio_hal_t *ah, const char **value);
-audio_return_t _ucm_reset_use_case(audio_hal_t *ah);
+audio_return_e _ucm_set_use_case(audio_hal_t *ah, const char *verb, const char *devices[], const char *modifiers[]);
+audio_return_e _ucm_set_devices(audio_hal_t *ah, const char *verb, const char *devices[]);
+audio_return_e _ucm_set_modifiers(audio_hal_t *ah, const char *verb, const char *modifiers[]);
+audio_return_e _ucm_get_verb(audio_hal_t *ah, const char **value);
+audio_return_e _ucm_reset_use_case(audio_hal_t *ah);
#endif
snd_pcm_t *fmradio_pcm_out;
pthread_mutex_t pcm_lock;
uint32_t pcm_count;
- device_info_t *init_call_devices;
+ device_info_s *init_call_devices;
uint32_t num_of_call_devices;
audio_route_mode_t mode;
uint32_t is_radio_on;
audio_hal_comm_t comm;
} audio_hal_t;
-audio_return_t _audio_ctrl_init(audio_hal_t *ah);
-audio_return_t _audio_ctrl_deinit(audio_hal_t *ah);
-audio_return_t _audio_volume_init(audio_hal_t *ah);
-audio_return_t _audio_volume_deinit(audio_hal_t *ah);
-audio_return_t _audio_routing_init(audio_hal_t *ah);
-audio_return_t _audio_routing_deinit(audio_hal_t *ah);
-audio_return_t _audio_stream_init(audio_hal_t *ah);
-audio_return_t _audio_stream_deinit(audio_hal_t *ah);
-audio_return_t _audio_pcm_init(audio_hal_t *ah);
-audio_return_t _audio_pcm_deinit(audio_hal_t *ah);
-audio_return_t _audio_modem_init(audio_hal_t *ah);
-audio_return_t _audio_modem_deinit(audio_hal_t *ah);
-audio_return_t _audio_comm_init(audio_hal_t *ah);
-audio_return_t _audio_comm_deinit(audio_hal_t *ah);
-
-audio_return_t _audio_update_route_voicecall(audio_hal_t *ah, device_info_t *devices, int32_t num_of_devices);
+audio_return_e _audio_ctrl_init(audio_hal_t *ah);
+audio_return_e _audio_ctrl_deinit(audio_hal_t *ah);
+audio_return_e _audio_volume_init(audio_hal_t *ah);
+audio_return_e _audio_volume_deinit(audio_hal_t *ah);
+audio_return_e _audio_routing_init(audio_hal_t *ah);
+audio_return_e _audio_routing_deinit(audio_hal_t *ah);
+audio_return_e _audio_stream_init(audio_hal_t *ah);
+audio_return_e _audio_stream_deinit(audio_hal_t *ah);
+audio_return_e _audio_pcm_init(audio_hal_t *ah);
+audio_return_e _audio_pcm_deinit(audio_hal_t *ah);
+audio_return_e _audio_modem_init(audio_hal_t *ah);
+audio_return_e _audio_modem_deinit(audio_hal_t *ah);
+audio_return_e _audio_comm_init(audio_hal_t *ah);
+audio_return_e _audio_comm_deinit(audio_hal_t *ah);
+
+audio_return_e _audio_update_route_voicecall(audio_hal_t *ah, device_info_s *devices, int32_t num_of_devices);
int _audio_modem_is_call_connected(audio_hal_t *ah);
-audio_return_t _audio_comm_send_message(audio_hal_t *ah, const char *name, int value);
+audio_return_e _audio_comm_send_message(audio_hal_t *ah, const char *name, int value);
typedef struct _dump_data {
char *strbuf;
static void __i2s_pin_mux_sel(audio_hal_t *ah, int type)
{
- audio_return_t ret = AUDIO_RET_OK;
+ audio_return_e ret = AUDIO_RET_OK;
audio_modem_t *modem;
if (!ah) {
static void *__vbc_control_voice_thread_run(void *args)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
vbc_parameters_head read_head;
vbc_parameters_head write_head;
int exit_thread = 0; /* make exit variable global if required to gracefully exit */
return (void*)0;
}
-static audio_return_t __vbc_control_open(audio_hal_t *ah)
+static audio_return_e __vbc_control_open(audio_hal_t *ah)
{
vbc_control_params_t *params = (vbc_control_params_t*)malloc(sizeof(vbc_control_params_t));
- audio_return_t ret = AUDIO_RET_OK;
- audio_return_t ret2 = AUDIO_RET_OK;
+ audio_return_e ret = AUDIO_RET_OK;
+ audio_return_e ret2 = AUDIO_RET_OK;
if (params == NULL) {
AUDIO_LOG_ERROR("vbc control param allocation failed");
return NULL;
}
-audio_return_t _audio_modem_init(audio_hal_t *ah)
+audio_return_e _audio_modem_init(audio_hal_t *ah)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t _audio_modem_deinit(audio_hal_t *ah)
+audio_return_e _audio_modem_deinit(audio_hal_t *ah)
{
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
#include "tizen-audio-internal.h"
#include "tizen-audio-impl.h"
-audio_return_t _audio_pcm_init(audio_hal_t *ah)
+audio_return_e _audio_pcm_init(audio_hal_t *ah)
{
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return AUDIO_RET_OK;
}
-audio_return_t _audio_pcm_deinit(audio_hal_t *ah)
+audio_return_e _audio_pcm_deinit(audio_hal_t *ah)
{
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return AUDIO_RET_OK;
}
-audio_return_t audio_pcm_open(void *audio_handle, const char *card, const char *device, uint32_t direction, void *sample_spec,
+audio_return_e audio_pcm_open(void *audio_handle, const char *card, const char *device, uint32_t direction, void *sample_spec,
uint32_t period_size, uint32_t periods, void **pcm_handle)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
audio_hal_t *ah = NULL;
AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
return AUDIO_RET_OK;
}
-audio_return_t audio_pcm_start(void *audio_handle, void *pcm_handle)
+audio_return_e audio_pcm_start(void *audio_handle, void *pcm_handle)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t audio_pcm_stop(void *audio_handle, void *pcm_handle)
+audio_return_e audio_pcm_stop(void *audio_handle, void *pcm_handle)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t audio_pcm_close(void *audio_handle, void *pcm_handle)
+audio_return_e audio_pcm_close(void *audio_handle, void *pcm_handle)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
audio_hal_t *ah = NULL;
AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t audio_pcm_avail(void *audio_handle, void *pcm_handle, uint32_t *avail)
+audio_return_e audio_pcm_avail(void *audio_handle, void *pcm_handle, uint32_t *avail)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t audio_pcm_write(void *audio_handle, void *pcm_handle, const void *buffer, uint32_t frames)
+audio_return_e audio_pcm_write(void *audio_handle, void *pcm_handle, const void *buffer, uint32_t frames)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t audio_pcm_read(void *audio_handle, void *pcm_handle, void *buffer, uint32_t frames)
+audio_return_e audio_pcm_read(void *audio_handle, void *pcm_handle, void *buffer, uint32_t frames)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t audio_pcm_get_fd(void *audio_handle, void *pcm_handle, int *fd)
+audio_return_e audio_pcm_get_fd(void *audio_handle, void *pcm_handle, int *fd)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t audio_pcm_recover(void *audio_handle, void *pcm_handle, int revents)
+audio_return_e audio_pcm_recover(void *audio_handle, void *pcm_handle, int revents)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t audio_pcm_get_params(void *audio_handle, void *pcm_handle, uint32_t direction, void **sample_spec, uint32_t *period_size, uint32_t *periods)
+audio_return_e audio_pcm_get_params(void *audio_handle, void *pcm_handle, uint32_t direction, void **sample_spec, uint32_t *period_size, uint32_t *periods)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t audio_pcm_set_params(void *audio_handle, void *pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods)
+audio_return_e audio_pcm_set_params(void *audio_handle, void *pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
return;
}
-static audio_return_t __set_devices(audio_hal_t *ah, const char *verb, device_info_t *devices, uint32_t num_of_devices)
+static audio_return_e __set_devices(audio_hal_t *ah, const char *verb, device_info_s *devices, uint32_t num_of_devices)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
uint32_t new_device = 0;
const char *active_devices[MAX_DEVICES] = {NULL,};
int i = 0, j = 0, dev_idx = 0;
return audio_ret;
}
-static audio_return_t __connect_fm_radio(audio_hal_t *ah)
+static audio_return_e __connect_fm_radio(audio_hal_t *ah)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-static audio_return_t __update_route_ap_playback_capture(audio_hal_t *ah, audio_route_info_t *route_info)
+static audio_return_e __update_route_ap_playback_capture(audio_hal_t *ah, audio_route_info_s *route_info)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
- device_info_t *devices = NULL;
+ audio_return_e audio_ret = AUDIO_RET_OK;
+ device_info_s *devices = NULL;
const char *verb = mode_to_verb_str[VERB_NORMAL];
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-static audio_return_t __update_route_voicecall(audio_hal_t *ah, device_info_t *devices, int32_t num_of_devices)
+static audio_return_e __update_route_voicecall(audio_hal_t *ah, device_info_s *devices, int32_t num_of_devices)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
const char *verb = mode_to_verb_str[VERB_VOICECALL];
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-static audio_return_t __update_route_voip(audio_hal_t *ah, device_info_t *devices, int32_t num_of_devices)
+static audio_return_e __update_route_voip(audio_hal_t *ah, device_info_s *devices, int32_t num_of_devices)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
const char *verb = mode_to_verb_str[VERB_NORMAL];
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-static audio_return_t __update_route_fmradio(audio_hal_t *ah, device_info_t *devices, int32_t num_of_devices)
+static audio_return_e __update_route_fmradio(audio_hal_t *ah, device_info_s *devices, int32_t num_of_devices)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
const char *verb = mode_to_verb_str[VERB_RADIO];
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-static audio_return_t __update_route_reset(audio_hal_t *ah, uint32_t direction)
+static audio_return_e __update_route_reset(audio_hal_t *ah, uint32_t direction)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
const char *active_devices[MAX_DEVICES] = {NULL,};
int i = 0, dev_idx = 0;
return audio_ret;
}
-audio_return_t _audio_update_route_voicecall(audio_hal_t *ah, device_info_t *devices, int32_t num_of_devices)
+audio_return_e _audio_update_route_voicecall(audio_hal_t *ah, device_info_s *devices, int32_t num_of_devices)
{
return __update_route_voicecall(ah, devices, num_of_devices);
}
-audio_return_t _audio_routing_init(audio_hal_t *ah)
+audio_return_e _audio_routing_init(audio_hal_t *ah)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t _audio_routing_deinit(audio_hal_t *ah)
+audio_return_e _audio_routing_deinit(audio_hal_t *ah)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t audio_update_route(void *audio_handle, audio_route_info_t *info)
+audio_return_e audio_update_route(void *audio_handle, audio_route_info_s *info)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
audio_hal_t *ah = (audio_hal_t *)audio_handle;
- device_info_t *devices = NULL;
+ device_info_s *devices = NULL;
uint32_t prev_size;
int32_t i;
int32_t j;
if (!ah->modem.is_connected) {
if (info->num_of_devices) {
if (!ah->device.num_of_call_devices) {
- if ((ah->device.init_call_devices = (device_info_t*)calloc(info->num_of_devices, sizeof(device_info_t)))) {
- memcpy(ah->device.init_call_devices, devices, info->num_of_devices*sizeof(device_info_t));
+ if ((ah->device.init_call_devices = (device_info_s*)calloc(info->num_of_devices, sizeof(device_info_s)))) {
+ memcpy(ah->device.init_call_devices, devices, info->num_of_devices*sizeof(device_info_s));
ah->device.num_of_call_devices = info->num_of_devices;
} else {
AUDIO_LOG_ERROR("failed to calloc");
for (j = 0; j < info->num_of_devices; j++) {
if (devices[j].direction == ah->device.init_call_devices[i].direction &&
devices[j].id != ah->device.init_call_devices[i].id)
- memcpy(&ah->device.init_call_devices[i], &devices[j], sizeof(device_info_t));
+ memcpy(&ah->device.init_call_devices[i], &devices[j], sizeof(device_info_s));
}
}
} else if (prev_size < 2) {
/* A device has already been added for call-voice routing,
* and now it is about to add a new device(input or output device). */
ah->device.num_of_call_devices += info->num_of_devices;
- if ((ah->device.init_call_devices = (device_info_t*)realloc(ah->device.init_call_devices, sizeof(device_info_t)*ah->device.num_of_call_devices))) {
- memcpy((void*)&(ah->device.init_call_devices[prev_size]), devices, info->num_of_devices*sizeof(device_info_t));
+ if ((ah->device.init_call_devices = (device_info_s*)realloc(ah->device.init_call_devices, sizeof(device_info_s)*ah->device.num_of_call_devices))) {
+ memcpy((void*)&(ah->device.init_call_devices[prev_size]), devices, info->num_of_devices*sizeof(device_info_s));
} else {
AUDIO_LOG_ERROR("failed to realloc");
audio_ret = AUDIO_ERR_RESOURCE;
return audio_ret;
}
-audio_return_t audio_update_route_option(void *audio_handle, audio_route_option_t *option)
+audio_return_e audio_update_route_option(void *audio_handle, audio_route_option_s *option)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
audio_hal_t *ah = (audio_hal_t *)audio_handle;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
#include "tizen-audio-internal.h"
-audio_return_t _audio_stream_init(audio_hal_t *ah)
+audio_return_e _audio_stream_init(audio_hal_t *ah)
{
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return AUDIO_RET_OK;
}
-audio_return_t _audio_stream_deinit(audio_hal_t *ah)
+audio_return_e _audio_stream_deinit(audio_hal_t *ah)
{
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return AUDIO_RET_OK;
}
-audio_return_t audio_notify_stream_connection_changed(void *audio_handle, audio_stream_info_t *info, uint32_t is_connected)
+audio_return_e audio_notify_stream_connection_changed(void *audio_handle, audio_stream_info_s *info, uint32_t is_connected)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
audio_hal_t *ah = (audio_hal_t *)audio_handle;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
}
-static audio_return_t __load_volume_value_table_from_ini(audio_hal_t *ah)
+static audio_return_e __load_volume_value_table_from_ini(audio_hal_t *ah)
{
dictionary * dict = NULL;
uint32_t vol_type_idx, vol_level_idx, gain_type_idx;
return AUDIO_RET_OK;
}
-static audio_return_t __load_radio_volume_table(int** volume_table, int *number_of_elements)
+static audio_return_e __load_radio_volume_table(int** volume_table, int *number_of_elements)
{
dictionary * dict = NULL;
const char delimiter[] = ", ";
return ret;
}
-static audio_return_t _audio_volume_set_ratio_radio(audio_hal_t *ah, double ratio)
+static audio_return_e _audio_volume_set_ratio_radio(audio_hal_t *ah, double ratio)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
int new_value = 0;
int prev_value = -1;
int mute = -1;
return audio_ret;
}
-audio_return_t _audio_volume_init(audio_hal_t *ah)
+audio_return_e _audio_volume_init(audio_hal_t *ah)
{
int i;
int val = 0;
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
int init_value[AUDIO_VOLUME_TYPE_MAX] = { 9, 11, 7, 11, 7, 4, 4, 7 };
int* fm_table = NULL;
return audio_ret;
}
-audio_return_t _audio_volume_deinit(audio_hal_t *ah)
+audio_return_e _audio_volume_deinit(audio_hal_t *ah)
{
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return AUDIO_RET_OK;
}
-audio_return_t audio_get_volume_level_max(void *audio_handle, audio_volume_info_t *info, uint32_t *level)
+audio_return_e audio_get_volume_level_max(void *audio_handle, audio_volume_info_s *info, uint32_t *level)
{
audio_hal_t *ah = (audio_hal_t *)audio_handle;
return AUDIO_RET_OK;
}
-audio_return_t audio_get_volume_level(void *audio_handle, audio_volume_info_t *info, uint32_t *level)
+audio_return_e audio_get_volume_level(void *audio_handle, audio_volume_info_s *info, uint32_t *level)
{
audio_hal_t *ah = (audio_hal_t *)audio_handle;
return AUDIO_RET_OK;
}
-audio_return_t audio_get_volume_value(void *audio_handle, audio_volume_info_t *info, uint32_t level, double *value)
+audio_return_e audio_get_volume_value(void *audio_handle, audio_volume_info_s *info, uint32_t level, double *value)
{
audio_hal_t *ah = (audio_hal_t *)audio_handle;
audio_volume_value_table_t *volume_value_table;
return AUDIO_RET_OK;
}
-audio_return_t audio_set_volume_level(void *audio_handle, audio_volume_info_t *info, uint32_t level)
+audio_return_e audio_set_volume_level(void *audio_handle, audio_volume_info_s *info, uint32_t level)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
audio_hal_t *ah = (audio_hal_t *)audio_handle;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t audio_get_volume_mute(void *audio_handle, audio_volume_info_t *info, uint32_t *mute)
+audio_return_e audio_get_volume_mute(void *audio_handle, audio_volume_info_s *info, uint32_t *mute)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
audio_hal_t *ah = (audio_hal_t *)audio_handle;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t audio_set_volume_mute(void *audio_handle, audio_volume_info_t *info, uint32_t mute)
+audio_return_e audio_set_volume_mute(void *audio_handle, audio_volume_info_s *info, uint32_t mute)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
audio_hal_t *ah = (audio_hal_t *)audio_handle;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
return audio_ret;
}
-audio_return_t audio_set_volume_ratio(void *audio_handle, audio_stream_info_t *info, double ratio)
+audio_return_e audio_set_volume_ratio(void *audio_handle, audio_stream_info_s *info, double ratio)
{
- audio_return_t audio_ret = AUDIO_RET_OK;
+ audio_return_e audio_ret = AUDIO_RET_OK;
audio_hal_t *ah = (audio_hal_t *)audio_handle;
AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
#include "tizen-audio-internal.h"
-audio_return_t audio_init(void **audio_handle)
+audio_return_e audio_init(void **audio_handle)
{
audio_hal_t *ah;
- audio_return_t ret = AUDIO_RET_OK;
+ audio_return_e ret = AUDIO_RET_OK;
AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
return ret;
}
-audio_return_t audio_deinit(void *audio_handle)
+audio_return_e audio_deinit(void *audio_handle)
{
audio_hal_t *ah = (audio_hal_t *)audio_handle;
#define footizenaudiofoo
#include <stdint.h>
+#include <hal/hal-audio-interface.h>
/**
* @file tizen-audio.h
*/
/**
- * @brief Enumeration for return codes.
- * @since_tizen 3.0
- */
-typedef enum audio_return {
- AUDIO_RET_OK = 0,
- AUDIO_ERR_UNDEFINED = (int32_t)0x80001000,
- AUDIO_ERR_RESOURCE = (int32_t)0x80001001,
- AUDIO_ERR_PARAMETER = (int32_t)0x80001002,
- AUDIO_ERR_IOCTL = (int32_t)0x80001003,
- AUDIO_ERR_INVALID_STATE = (int32_t)0x80001004,
- AUDIO_ERR_INTERNAL = (int32_t)0x80001005,
- /* add new enemerator here */
- AUDIO_ERR_NOT_IMPLEMENTED = (int32_t)0x80001100,
-} audio_return_t ;
-
-/**
- * @brief Enumeration for audio direction.
- * @since_tizen 3.0
- */
-typedef enum audio_direction {
- AUDIO_DIRECTION_IN, /**< Capture */
- AUDIO_DIRECTION_OUT, /**< Playback */
-} audio_direction_t;
-
-/**
- * @brief Device information including type, direction and id.
- * @since_tizen 3.0
- */
-typedef struct device_info {
- const char *type;
- uint32_t direction;
- uint32_t id;
-} device_info_t;
-
-/**
- * @brief Volume information including type, gain and direction.
- * @since_tizen 3.0
- */
-typedef struct audio_volume_info {
- const char *type;
- const char *gain;
- uint32_t direction;
-} audio_volume_info_t ;
-
-/**
- * @brief Route information including role and device.
- * @since_tizen 3.0
- */
-typedef struct audio_route_info {
- const char *role;
- device_info_t *device_infos;
- uint32_t num_of_devices;
-} audio_route_info_t;
-
-/**
- * @brief Route option including role, name and value.
- * @since_tizen 3.0
- */
-typedef struct audio_route_option {
- const char *role;
- const char *name;
- int32_t value;
-} audio_route_option_t;
-
-/**
- * @brief Stream information including role, direction and index.
- * @since_tizen 3.0
- */
-typedef struct audio_stream_info {
- const char *role;
- uint32_t direction;
- uint32_t idx;
-} audio_stream_info_t ;
-
-/**
- * @brief Called when audio hal implementation needs to send a message.
- * @since_tizen 3.0
- * @param[in] name The message name
- * @param[in] value The message value
- * @param[in] user_data The user data passed from the callback registration function
- *
- * @see audio_add_message_cb()
- * @see audio_remove_message_cb()
- */
-typedef void (*message_cb)(const char *name, int value, void *user_data);
-
-/* Overall */
-typedef struct audio_interface {
- /* Initialization & de-initialization */
- audio_return_t (*init)(void **audio_handle);
- audio_return_t (*deinit)(void *audio_handle);
- /* Volume */
- audio_return_t (*get_volume_level_max)(void *audio_handle, audio_volume_info_t *info, uint32_t *level);
- audio_return_t (*get_volume_level)(void *audio_handle, audio_volume_info_t *info, uint32_t *level);
- audio_return_t (*set_volume_level)(void *audio_handle, audio_volume_info_t *info, uint32_t level);
- audio_return_t (*get_volume_value)(void *audio_handle, audio_volume_info_t *info, uint32_t level, double *value);
- audio_return_t (*get_volume_mute)(void *audio_handle, audio_volume_info_t *info, uint32_t *mute);
- audio_return_t (*set_volume_mute)(void *audio_handle, audio_volume_info_t *info, uint32_t mute);
- audio_return_t (*set_volume_ratio)(void *audio_handle, audio_stream_info_t *info, double ratio);
- /* Routing */
- audio_return_t (*update_route)(void *audio_handle, audio_route_info_t *info);
- audio_return_t (*update_route_option)(void *audio_handle, audio_route_option_t *option);
- /* Stream */
- audio_return_t (*notify_stream_connection_changed)(void *audio_handle, audio_stream_info_t *info, uint32_t is_connected);
- /* PCM */
- audio_return_t (*pcm_open)(void *audio_handle, const char *card, const char *device, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods, void **pcm_handle);
- audio_return_t (*pcm_start)(void *audio_handle, void *pcm_handle);
- audio_return_t (*pcm_stop)(void *audio_handle, void *pcm_handle);
- audio_return_t (*pcm_close)(void *audio_handle, void *pcm_handle);
- audio_return_t (*pcm_avail)(void *audio_handle, void *pcm_handle, uint32_t *avail);
- audio_return_t (*pcm_write)(void *audio_handle, void *pcm_handle, const void *buffer, uint32_t frames);
- audio_return_t (*pcm_read)(void *audio_handle, void *pcm_handle, void *buffer, uint32_t frames);
- audio_return_t (*pcm_get_fd)(void *audio_handle, void *pcm_handle, int *fd);
- audio_return_t (*pcm_recover)(void *audio_handle, void *pcm_handle, int revents);
- audio_return_t (*pcm_get_params)(void *audio_handle, void *pcm_handle, uint32_t direction, void **sample_spec, uint32_t *period_size, uint32_t *periods);
- audio_return_t (*pcm_set_params)(void *audio_handle, void *pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods);
- /* Message callback */
- audio_return_t (*add_message_cb)(void *audio_handle, message_cb callback, void *user_data);
- audio_return_t (*remove_message_cb)(void *audio_handle, message_cb callback);
-} audio_interface_t;
-
-/**
* @brief Initializes audio hal.
* @since_tizen 3.0
* @param[out] audio_handle The audio hal handle
* @retval #AUDIO_RET_OK Success
* @see audio_deinit()
*/
-audio_return_t audio_init(void **audio_handle);
+audio_return_e audio_init(void **audio_handle);
/**
* @brief De-initializes audio hal.
* @retval #AUDIO_RET_OK Success
* @see audio_init()
*/
-audio_return_t audio_deinit(void *audio_handle);
+audio_return_e audio_deinit(void *audio_handle);
/**
* @brief Gets the maximum volume level supported for a particular volume information.
* @see audio_get_volume_level()
* @see audio_get_volume_value()
*/
-audio_return_t audio_get_volume_level_max(void *audio_handle, audio_volume_info_t *info, uint32_t *level);
+audio_return_e audio_get_volume_level_max(void *audio_handle, audio_volume_info_s *info, uint32_t *level);
/**
* @brief Gets the volume level specified for a particular volume information.
* @see audio_get_volume_level_max()
* @see audio_get_volume_value()
*/
-audio_return_t audio_get_volume_level(void *audio_handle, audio_volume_info_t *info, uint32_t *level);
+audio_return_e audio_get_volume_level(void *audio_handle, audio_volume_info_s *info, uint32_t *level);
/**
* @brief Sets the volume level specified for a particular volume information.
* @see audio_get_volume_level_max()
* @see audio_get_volume_value()
*/
-audio_return_t audio_set_volume_level(void *audio_handle, audio_volume_info_t *info, uint32_t level);
+audio_return_e audio_set_volume_level(void *audio_handle, audio_volume_info_s *info, uint32_t level);
/**
* @brief Gets the volume value specified for a particular volume information and level.
* @see audio_get_volume_level()
* @see audio_get_volume_level_max()
*/
-audio_return_t audio_get_volume_value(void *audio_handle, audio_volume_info_t *info, uint32_t level, double *value);
+audio_return_e audio_get_volume_value(void *audio_handle, audio_volume_info_s *info, uint32_t level, double *value);
/**
* @brief Gets the volume mute specified for a particular volume information.
* @retval #AUDIO_RET_OK Success
* @see audio_set_volume_mute()
*/
-audio_return_t audio_get_volume_mute(void *audio_handle, audio_volume_info_t *info, uint32_t *mute);
+audio_return_e audio_get_volume_mute(void *audio_handle, audio_volume_info_s *info, uint32_t *mute);
/**
* @brief Sets the volume mute specified for a particular volume information.
* @retval #AUDIO_RET_OK Success
* @see audio_get_volume_mute()
*/
-audio_return_t audio_set_volume_mute(void *audio_handle, audio_volume_info_t *info, uint32_t mute);
+audio_return_e audio_set_volume_mute(void *audio_handle, audio_volume_info_s *info, uint32_t mute);
+
+/**
+ * @brief Sets the volume ratio specified for a particular volume information. (optional)
+ * @since_tizen 5.5
+ * @param[in] audio_handle The audio hal handle
+ * @param[in] info The audio volume information
+ * @param[in] ratio The volume ratio to be set (Min.:0.0 ~ Max.:1.0, default:1.0)
+ *
+ * @return @c 0 on success,
+ * otherwise a negative error value
+ * @retval #AUDIO_RET_OK Success
+ */
+audio_return_e audio_set_volume_ratio(void *audio_handle, audio_stream_info_s *info, double ratio);
/**
* @brief Updates the audio routing according to audio route information.
* @retval #AUDIO_RET_OK Success
* @see audio_update_route_option()
*/
-audio_return_t audio_update_route(void *audio_handle, audio_route_info_t *info);
+audio_return_e audio_update_route(void *audio_handle, audio_route_info_s *info);
/**
* @brief Updates audio routing option according to audio route option.
* @retval #AUDIO_RET_OK Success
* @see audio_update_route()
*/
-audio_return_t audio_update_route_option(void *audio_handle, audio_route_option_t *option);
+audio_return_e audio_update_route_option(void *audio_handle, audio_route_option_s *option);
/**
* @brief Gets notified when a stream is connected and disconnected.
* otherwise a negative error value
* @retval #AUDIO_RET_OK Success
*/
-audio_return_t audio_notify_stream_connection_changed(void *audio_handle, audio_stream_info_t *info, uint32_t is_connected);
+audio_return_e audio_notify_stream_connection_changed(void *audio_handle, audio_stream_info_s *info, uint32_t is_connected);
/**
* @brief Opens a PCM device.
* @retval #AUDIO_RET_OK Success
* @see audio_pcm_close()
*/
-audio_return_t audio_pcm_open(void *audio_handle, const char *card, const char *device, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods, void **pcm_handle);
+audio_return_e audio_pcm_open(void *audio_handle, const char *card, const char *device, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods, void **pcm_handle);
/**
* @brief Starts a PCM device.
* @see audio_pcm_stop()
* @see audio_pcm_recover()
*/
-audio_return_t audio_pcm_start(void *audio_handle, void *pcm_handle);
+audio_return_e audio_pcm_start(void *audio_handle, void *pcm_handle);
/**
* @brief Stops a PCM device.
* @retval #AUDIO_RET_OK Success
* @see audio_pcm_start()
*/
-audio_return_t audio_pcm_stop(void *audio_handle, void *pcm_handle);
+audio_return_e audio_pcm_stop(void *audio_handle, void *pcm_handle);
/**
* @brief Closes a PCM device.
* @retval #AUDIO_RET_OK Success
* @see audio_pcm_open()
*/
-audio_return_t audio_pcm_close(void *audio_handle, void *pcm_handle);
+audio_return_e audio_pcm_close(void *audio_handle, void *pcm_handle);
/**
* @brief Gets available number of frames.
* @see audio_pcm_write()
* @see audio_pcm_read()
*/
-audio_return_t audio_pcm_avail(void *audio_handle, void *pcm_handle, uint32_t *avail);
+audio_return_e audio_pcm_avail(void *audio_handle, void *pcm_handle, uint32_t *avail);
/**
* @brief Writes frames to a PCM device.
* @see audio_pcm_avail()
* @see audio_pcm_recover()
*/
-audio_return_t audio_pcm_write(void *audio_handle, void *pcm_handle, const void *buffer, uint32_t frames);
+audio_return_e audio_pcm_write(void *audio_handle, void *pcm_handle, const void *buffer, uint32_t frames);
/**
* @brief Reads frames from a PCM device.
* @see audio_pcm_avail()
* @see audio_pcm_recover()
*/
-audio_return_t audio_pcm_read(void *audio_handle, void *pcm_handle, void *buffer, uint32_t frames);
+audio_return_e audio_pcm_read(void *audio_handle, void *pcm_handle, void *buffer, uint32_t frames);
/**
* @brief Gets poll descriptor for a PCM handle.
* @see audio_pcm_open()
* @see audio_pcm_recover()
*/
-audio_return_t audio_pcm_get_fd(void *audio_handle, void *pcm_handle, int *fd);
+audio_return_e audio_pcm_get_fd(void *audio_handle, void *pcm_handle, int *fd);
/**
* @brief Recovers the PCM state.
* @see audio_pcm_read()
* @see audio_pcm_get_fd()
*/
-audio_return_t audio_pcm_recover(void *audio_handle, void *pcm_handle, int revents);
+audio_return_e audio_pcm_recover(void *audio_handle, void *pcm_handle, int revents);
/**
* @brief Gets parameters of a PCM device.
* @retval #AUDIO_RET_OK Success
* @see audio_pcm_set_params()
*/
-audio_return_t audio_pcm_get_params(void *audio_handle, void *pcm_handle, uint32_t direction, void **sample_spec, uint32_t *period_size, uint32_t *periods);
+audio_return_e audio_pcm_get_params(void *audio_handle, void *pcm_handle, uint32_t direction, void **sample_spec, uint32_t *period_size, uint32_t *periods);
/**
* @brief Sets hardware and software parameters of a PCM device.
* @retval #AUDIO_RET_OK Success
* @see audio_pcm_set_params()
*/
-audio_return_t audio_pcm_set_params(void *audio_handle, void *pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods);
+audio_return_e audio_pcm_set_params(void *audio_handle, void *pcm_handle, uint32_t direction, void *sample_spec, uint32_t period_size, uint32_t periods);
/**
* @brief Adds the message callback function.
* @see message_cb()
* @see audio_remove_message_cb()
*/
-audio_return_t audio_add_message_cb(void *audio_handle, message_cb callback, void *user_data);
+audio_return_e audio_add_message_cb(void *audio_handle, message_cb callback, void *user_data);
/**
* @brief Removes the message callback function.
* @see message_cb()
* @see audio_add_message_cb()
*/
-audio_return_t audio_remove_message_cb(void *audio_handle, message_cb callback);
+audio_return_e audio_remove_message_cb(void *audio_handle, message_cb callback);
/**
* @}
projects / platform / adaptation / spreadtrum / audio-hal-sc7727.git / commitdiff