typdef postfix is changed to {enum}_e and {struct}_s

enum and structure are changed for better readability. In case of enum,
{enum}_t is changed to {enum}_'e', and {struct}_t is changed to
{struct}_'s'

[Version] 0.1.6
[Issue Type] Readability enhance

Change-Id: I71f8a5c2dcff354bb2f8164d599bfaa69eccd183
Signed-off-by: Jaechul Lee <jcsing.lee@samsung.com>

diff --git a/packaging/audio-hal-exynos9110.spec b/packaging/audio-hal-exynos9110.spec
index c2123b2..9644890 100644 (file)
--- a/packaging/audio-hal-exynos9110.spec
+++ b/packaging/audio-hal-exynos9110.spec
@@ -1,6 +1,6 @@
 Name:       audio-hal-exynos9110
 Summary:    TIZEN Audio HAL for Exynos9110(TW3)
-Version:    0.1.5
+Version:    0.1.6
 Release:    0
 Group:      System/Libraries
 License:    Apache-2.0

diff --git a/tizen-audio-comm.c b/tizen-audio-comm.c
index 50f7802..ed71126 100644 (file)
--- a/tizen-audio-comm.c
+++ b/tizen-audio-comm.c
@@ -22,7 +22,7 @@
 
 #include "tizen-audio-internal.h"
 
-static audio_return_e __set_message_callback(audio_hal_t *ah, message_cb callback, void *user_data)
+static audio_return_e __set_message_callback(audio_hal_s *ah, message_cb callback, void *user_data)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
 
@@ -37,7 +37,7 @@ static audio_return_e __set_message_callback(audio_hal_t *ah, message_cb callbac
     return audio_ret;
 }
 
-static audio_return_e __unset_message_callback(audio_hal_t *ah)
+static audio_return_e __unset_message_callback(audio_hal_s *ah)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
 
@@ -51,7 +51,7 @@ static audio_return_e __unset_message_callback(audio_hal_t *ah)
     return audio_ret;
 }
 
-audio_return_e _audio_comm_init(audio_hal_t *ah)
+audio_return_e _audio_comm_init(audio_hal_s *ah)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
 
@@ -63,7 +63,7 @@ audio_return_e _audio_comm_init(audio_hal_t *ah)
     return audio_ret;
 }
 
-audio_return_e _audio_comm_deinit(audio_hal_t *ah)
+audio_return_e _audio_comm_deinit(audio_hal_s *ah)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
 
@@ -75,7 +75,7 @@ audio_return_e _audio_comm_deinit(audio_hal_t *ah)
     return audio_ret;
 }
 
-audio_return_e _audio_comm_send_message(audio_hal_t *ah, const char *name, int value)
+audio_return_e _audio_comm_send_message(audio_hal_s *ah, const char *name, int value)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
 
@@ -99,7 +99,7 @@ audio_return_e audio_add_message_cb(void *audio_handle, message_cb callback, voi
 
     /* NOTE: Management of several callbacks could be implemented.
              But we do not care of it for now.*/
-    ret = __set_message_callback((audio_hal_t *)audio_handle, callback, user_data);
+    ret = __set_message_callback((audio_hal_s *)audio_handle, callback, user_data);
 
     return ret;
 }
@@ -111,7 +111,7 @@ audio_return_e audio_remove_message_cb(void *audio_handle, message_cb callback)
     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
     AUDIO_RETURN_VAL_IF_FAIL(callback, AUDIO_ERR_PARAMETER);
 
-    ret = __unset_message_callback((audio_hal_t *)audio_handle);
+    ret = __unset_message_callback((audio_hal_s *)audio_handle);
 
     return ret;
 }
\ No newline at end of file

diff --git a/tizen-audio-ctrl.c b/tizen-audio-ctrl.c
index 40c5d6c..b6536d8 100644 (file)
--- a/tizen-audio-ctrl.c
+++ b/tizen-audio-ctrl.c
@@ -23,7 +23,7 @@
 #include "tizen-audio-internal.h"
 #include "tizen-audio-impl.h"
 
-audio_return_e _audio_ctrl_init(audio_hal_t *ah)
+audio_return_e _audio_ctrl_init(audio_hal_s *ah)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
 
@@ -34,7 +34,7 @@ audio_return_e _audio_ctrl_init(audio_hal_t *ah)
     return audio_ret;
 }
 
-audio_return_e _audio_ctrl_deinit(audio_hal_t *ah)
+audio_return_e _audio_ctrl_deinit(audio_hal_s *ah)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
 

diff --git a/tizen-audio-impl-ctrl.c b/tizen-audio-impl-ctrl.c
index 29c7dce..7eab333 100644 (file)
--- a/tizen-audio-impl-ctrl.c
+++ b/tizen-audio-impl-ctrl.c
@@ -47,7 +47,7 @@ static void __dump_mixer_param(char *dump, long *param, int size)
 }
 #endif
 
-audio_return_e _mixer_control_init(audio_hal_t *ah)
+audio_return_e _mixer_control_init(audio_hal_s *ah)
 {
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
 
@@ -55,7 +55,7 @@ audio_return_e _mixer_control_init(audio_hal_t *ah)
     return AUDIO_RET_OK;
 }
 
-audio_return_e _mixer_control_deinit(audio_hal_t *ah)
+audio_return_e _mixer_control_deinit(audio_hal_s *ah)
 {
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
 
@@ -63,7 +63,7 @@ audio_return_e _mixer_control_deinit(audio_hal_t *ah)
     return AUDIO_RET_OK;
 }
 
-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_e _mixer_control_set_param(audio_hal_s *ah, const char* ctl_name, snd_ctl_elem_value_t* param, int size)
 {
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
 
@@ -71,7 +71,7 @@ audio_return_e _mixer_control_set_param(audio_hal_t *ah, const char* ctl_name, s
     return AUDIO_RET_OK;
 }
 
-audio_return_e _mixer_control_get_value(audio_hal_t *ah, const char *ctl_name, int *val)
+audio_return_e _mixer_control_get_value(audio_hal_s *ah, const char *ctl_name, int *val)
 {
     snd_ctl_t *handle;
     snd_ctl_elem_value_t *control;
@@ -151,7 +151,7 @@ close:
     return AUDIO_ERR_UNDEFINED;
 }
 
-audio_return_e _mixer_control_set_value(audio_hal_t *ah, const char *ctl_name, int val)
+audio_return_e _mixer_control_set_value(audio_hal_s *ah, const char *ctl_name, int val)
 {
     snd_ctl_t *handle;
     snd_ctl_elem_value_t *control;
@@ -230,7 +230,7 @@ close:
     return AUDIO_ERR_UNDEFINED;
 }
 
-audio_return_e _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_s *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);
@@ -240,7 +240,7 @@ audio_return_e _mixer_control_set_value_string(audio_hal_t *ah, const char* ctl_
 }
 
 
-audio_return_e _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_s *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);

diff --git a/tizen-audio-impl-pcm.c b/tizen-audio-impl-pcm.c
index 01c1bad..c48b7d0 100644 (file)
--- a/tizen-audio-impl-pcm.c
+++ b/tizen-audio-impl-pcm.c
@@ -62,14 +62,14 @@ static const uint32_t g_format_convert_table[] = {
 };
 #endif
 
-static uint32_t __convert_format(audio_sample_format_t format)
+static uint32_t __convert_format(audio_sample_format_s format)
 {
     return g_format_convert_table[format];
 }
 
 /* #define DEBUG_TIMING */
 
-static int __pcm_device_set_params(audio_hal_t *ah, snd_pcm_t *pcm, uint32_t samplerate, uint32_t channels)
+static int __pcm_device_set_params(audio_hal_s *ah, snd_pcm_t *pcm, uint32_t samplerate, uint32_t channels)
 {
     snd_pcm_hw_params_t *params = NULL;
     int err = 0;
@@ -152,7 +152,7 @@ static int __parse_card_device_number(const char *card, const char *device, unsi
     return 0;
 }
 
-static struct pcm *__tinyalsa_open_device(const char *card, const char *device, audio_pcm_sample_spec_t *ss, size_t period_size, size_t period_count, uint32_t direction)
+static struct pcm *__tinyalsa_open_device(const char *card, const char *device, audio_pcm_sample_spec_s *ss, size_t period_size, size_t period_count, uint32_t direction)
 {
     struct pcm *pcm = NULL;
     struct pcm_config config;
@@ -212,7 +212,7 @@ static int __tinyalsa_pcm_recover(struct pcm *pcm, int err)
 }
 #endif
 
-static audio_return_e __pcm_device_open(audio_hal_t *ah, audio_pcm_devices_t *pcm_devices, const char *device, uint32_t direction, uint32_t samplerate, uint32_t channels)
+static audio_return_e __pcm_device_open(audio_hal_s *ah, audio_pcm_devices_s *pcm_devices, const char *device, uint32_t direction, uint32_t samplerate, uint32_t channels)
 {
     int err, ret = 0;
 
@@ -271,7 +271,7 @@ error:
     return ret;
 }
 
-audio_return_e _voice_pcm_open_all(audio_hal_t *ah)
+audio_return_e _voice_pcm_open_all(audio_hal_s *ah)
 {
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
 
@@ -279,7 +279,7 @@ audio_return_e _voice_pcm_open_all(audio_hal_t *ah)
                              AUDIO_DEVICE_DIRECTION_IN | AUDIO_DEVICE_DIRECTION_OUT, 48000, 2);
 }
 
-audio_return_e _bt_pcm_open_all(audio_hal_t *ah)
+audio_return_e _bt_pcm_open_all(audio_hal_s *ah)
 {
     uint32_t samplerate;
 
@@ -291,7 +291,7 @@ audio_return_e _bt_pcm_open_all(audio_hal_t *ah)
                              AUDIO_DEVICE_DIRECTION_IN | AUDIO_DEVICE_DIRECTION_OUT, samplerate, 1);
 }
 
-bool _is_voice_pcm_opened_all(audio_hal_t *ah)
+bool _is_voice_pcm_opened_all(audio_hal_s *ah)
 {
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
 
@@ -301,7 +301,7 @@ bool _is_voice_pcm_opened_all(audio_hal_t *ah)
         return false;
 }
 
-bool _is_bt_pcm_opened_all(audio_hal_t *ah)
+bool _is_bt_pcm_opened_all(audio_hal_s *ah)
 {
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
 
@@ -311,7 +311,7 @@ bool _is_bt_pcm_opened_all(audio_hal_t *ah)
         return false;
 }
 
-audio_return_e _voice_pcm_close_all(audio_hal_t *ah)
+audio_return_e _voice_pcm_close_all(audio_hal_s *ah)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
 
@@ -339,7 +339,7 @@ audio_return_e _voice_pcm_close_all(audio_hal_t *ah)
     return audio_ret;
 }
 
-audio_return_e _bt_pcm_close_all(audio_hal_t *ah)
+audio_return_e _bt_pcm_close_all(audio_hal_s *ah)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
 
@@ -367,7 +367,7 @@ audio_return_e _bt_pcm_close_all(audio_hal_t *ah)
     return audio_ret;
 }
 
-void _reset_pcm_devices(audio_hal_t *ah)
+void _reset_pcm_devices(audio_hal_s *ah)
 {
     AUDIO_RETURN_IF_FAIL(ah);
 
@@ -400,10 +400,10 @@ audio_return_e _pcm_open(const char *card, const char *device, uint32_t directio
     AUDIO_LOG_INFO("card(%s) device(%s) direction(%u) period_size(%u) periods(%u)",
                     card, device, direction, period_size, periods);
 #ifdef __USE_TINYALSA__
-    audio_pcm_sample_spec_t *ss;
+    audio_pcm_sample_spec_s *ss;
 
-    ss = (audio_pcm_sample_spec_t *)sample_spec;
-    ss->format = __convert_format((audio_sample_format_t)ss->format);
+    ss = (audio_pcm_sample_spec_s *)sample_spec;
+    ss->format = __convert_format((audio_sample_format_s)ss->format);
 
     *pcm_handle = __tinyalsa_open_device(card, device, ss, (size_t)period_size, (size_t)periods, direction);
     if (*pcm_handle == NULL) {
@@ -694,12 +694,12 @@ 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)
 {
 #ifdef __USE_TINYALSA__
-    audio_pcm_sample_spec_t *ss;
+    audio_pcm_sample_spec_s *ss;
     unsigned int _period_size, _buffer_size, _periods, _format, _rate, _channels;
     unsigned int _start_threshold, _stop_threshold, _silence_threshold;
     struct pcm_config *config;
 
-    ss = (audio_pcm_sample_spec_t *)*sample_spec;
+    ss = (audio_pcm_sample_spec_s *)*sample_spec;
 
     /* we use an internal API of the tiny alsa library, so it causes warning message during compile */
     _pcm_config(pcm_handle, &config);
@@ -718,7 +718,7 @@ audio_return_e _pcm_get_params(void *pcm_handle, uint32_t direction, void **samp
                     pcm_handle, config->format, config->rate, config->channels, config->period_size, config->period_count, _buffer_size);
 #else  /* alsa-lib */
     int err;
-    audio_pcm_sample_spec_t *ss;
+    audio_pcm_sample_spec_s *ss;
     int dir;
     snd_pcm_uframes_t _period_size, _buffer_size;
     snd_pcm_format_t _format;
@@ -728,7 +728,7 @@ audio_return_e _pcm_get_params(void *pcm_handle, uint32_t direction, void **samp
     snd_pcm_hw_params_t *hwparams;
     snd_pcm_sw_params_t *swparams;
 
-    ss = (audio_pcm_sample_spec_t *)*sample_spec;
+    ss = (audio_pcm_sample_spec_s *)*sample_spec;
 
     snd_pcm_hw_params_alloca(&hwparams);
     snd_pcm_sw_params_alloca(&swparams);
@@ -780,12 +780,12 @@ audio_return_e _pcm_set_params(void *pcm_handle, uint32_t direction, void *sampl
     AUDIO_LOG_DEBUG("_pcm_set_params");
 #else  /* alsa-lib */
     int err;
-    audio_pcm_sample_spec_t ss;
+    audio_pcm_sample_spec_s ss;
     snd_pcm_uframes_t _buffer_size;
     snd_pcm_hw_params_t *hwparams;
     snd_pcm_sw_params_t *swparams;
 
-    ss = *(audio_pcm_sample_spec_t *)sample_spec;
+    ss = *(audio_pcm_sample_spec_s *)sample_spec;
 
     snd_pcm_hw_params_alloca(&hwparams);
     snd_pcm_sw_params_alloca(&swparams);
@@ -806,7 +806,7 @@ audio_return_e _pcm_set_params(void *pcm_handle, uint32_t direction, void *sampl
         return AUDIO_ERR_PARAMETER;
     }
 
-    ss.format = __convert_format((audio_sample_format_t)ss.format);
+    ss.format = __convert_format((audio_sample_format_s)ss.format);
     if ((err = snd_pcm_hw_params_set_format(pcm_handle, hwparams, ss.format)) < 0) {
         AUDIO_LOG_ERROR("snd_pcm_hw_params_set_format() failed : %d", err);
         return AUDIO_ERR_PARAMETER;
@@ -888,7 +888,7 @@ audio_return_e _pcm_set_params(void *pcm_handle, uint32_t direction, void *sampl
 }
 
 /* Generic snd pcm interface APIs */
-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_e _pcm_set_hw_params(snd_pcm_t *pcm, audio_pcm_sample_spec_s *sample_spec, uint8_t *use_mmap, snd_pcm_uframes_t *period_size, snd_pcm_uframes_t *buffer_size)
 {
     audio_return_e ret = AUDIO_RET_OK;
     snd_pcm_hw_params_t *hwparams;

diff --git a/tizen-audio-impl-ucm.c b/tizen-audio-impl-ucm.c
index f411637..b20f56d 100644 (file)
--- a/tizen-audio-impl-ucm.c
+++ b/tizen-audio-impl-ucm.c
@@ -96,7 +96,7 @@ static inline int __set_use_case_with_time(snd_use_case_mgr_t *uc_mgr, const cha
 }
 #endif
 
-audio_return_e _ucm_init(audio_hal_t *ah)
+audio_return_e _ucm_init(audio_hal_s *ah)
 {
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
 
@@ -109,7 +109,7 @@ audio_return_e _ucm_init(audio_hal_t *ah)
     return AUDIO_RET_OK;
 }
 
-audio_return_e _ucm_deinit(audio_hal_t *ah)
+audio_return_e _ucm_deinit(audio_hal_s *ah)
 {
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
     AUDIO_RETURN_VAL_IF_FAIL(ah->ucm.uc_mgr, AUDIO_ERR_PARAMETER);
@@ -135,7 +135,7 @@ audio_return_e _ucm_deinit(audio_hal_t *ah)
    2) If verb is changed
       -> Reset, set new verb, enable devices & modifiers
  */
-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_use_case(audio_hal_s *ah, const char *verb, const char *devices[], const char *modifiers[])
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
     int is_verb_changed = 0, is_dev_changed = 0, is_mod_changed = 0;
@@ -349,7 +349,7 @@ exit:
     return audio_ret;
 }
 
-audio_return_e _ucm_set_devices(audio_hal_t *ah, const char *verb, const char *devices[])
+audio_return_e _ucm_set_devices(audio_hal_s *ah, const char *verb, const char *devices[])
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
     int is_verb_changed = 0, is_dev_changed = 0;
@@ -496,7 +496,7 @@ exit:
 
 }
 
-audio_return_e _ucm_set_modifiers(audio_hal_t *ah, const char *verb, const char *modifiers[])
+audio_return_e _ucm_set_modifiers(audio_hal_s *ah, const char *verb, const char *modifiers[])
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
     int is_verb_changed = 0, is_mod_changed = 0;
@@ -629,7 +629,7 @@ exit:
     return audio_ret;
 }
 
-audio_return_e _ucm_get_verb(audio_hal_t *ah, const char **value)
+audio_return_e _ucm_get_verb(audio_hal_s *ah, const char **value)
 {
     audio_return_e ret = AUDIO_RET_OK;
 
@@ -645,7 +645,7 @@ audio_return_e _ucm_get_verb(audio_hal_t *ah, const char **value)
     return ret;
 }
 
-audio_return_e _ucm_reset_use_case(audio_hal_t *ah)
+audio_return_e _ucm_reset_use_case(audio_hal_s *ah)
 {
     audio_return_e ret = AUDIO_RET_OK;
 

diff --git a/tizen-audio-impl.h b/tizen-audio-impl.h
index 1c139a8..a97c842 100644 (file)
--- a/tizen-audio-impl.h
+++ b/tizen-audio-impl.h
@@ -23,13 +23,13 @@
 #include <stdbool.h>
 
 /* PCM */
-audio_return_e _voice_pcm_open_all(audio_hal_t *ah);
-audio_return_e _voice_pcm_close_all(audio_hal_t *ah);
-audio_return_e _bt_pcm_open_all(audio_hal_t *ah);
-audio_return_e _bt_pcm_close_all(audio_hal_t *ah);
-bool _is_voice_pcm_opened_all(audio_hal_t *ah);
-bool _is_bt_pcm_opened_all(audio_hal_t *ah);
-void _reset_pcm_devices(audio_hal_t *ah);
+audio_return_e _voice_pcm_open_all(audio_hal_s *ah);
+audio_return_e _voice_pcm_close_all(audio_hal_s *ah);
+audio_return_e _bt_pcm_open_all(audio_hal_s *ah);
+audio_return_e _bt_pcm_close_all(audio_hal_s *ah);
+bool _is_voice_pcm_opened_all(audio_hal_s *ah);
+bool _is_bt_pcm_opened_all(audio_hal_s *ah);
+void _reset_pcm_devices(audio_hal_s *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);
@@ -42,25 +42,25 @@ 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);
+audio_return_e _pcm_set_hw_params(snd_pcm_t *pcm, audio_pcm_sample_spec_s *sample_spec, uint8_t *use_mmap, snd_pcm_uframes_t *period_size, snd_pcm_uframes_t *buffer_size);
 
 /* Control */
-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);
+audio_return_e _mixer_control_init(audio_hal_s *ah);
+audio_return_e _mixer_control_deinit(audio_hal_s *ah);
+audio_return_e _mixer_control_set_param(audio_hal_s *ah, const char* ctl_name, snd_ctl_elem_value_t* value, int size);
+audio_return_e _mixer_control_set_value(audio_hal_s *ah, const char *ctl_name, int val);
+audio_return_e _mixer_control_set_value_string(audio_hal_s *ah, const char* ctl_name, const char* value);
+audio_return_e _mixer_control_get_value(audio_hal_s *ah, const char *ctl_name, int *val);
+audio_return_e _mixer_control_get_element(audio_hal_s *ah, const char *ctl_name, snd_hctl_elem_t **elem);
 
 /* UCM  */
-audio_return_e _ucm_init(audio_hal_t *ah);
-audio_return_e _ucm_deinit(audio_hal_t *ah);
+audio_return_e _ucm_init(audio_hal_s *ah);
+audio_return_e _ucm_deinit(audio_hal_s *ah);
 #define _ucm_update_use_case _ucm_set_use_case
-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);
+audio_return_e _ucm_set_use_case(audio_hal_s *ah, const char *verb, const char *devices[], const char *modifiers[]);
+audio_return_e _ucm_set_devices(audio_hal_s *ah, const char *verb, const char *devices[]);
+audio_return_e _ucm_set_modifiers(audio_hal_s *ah, const char *verb, const char *modifiers[]);
+audio_return_e _ucm_get_verb(audio_hal_s *ah, const char **value);
+audio_return_e _ucm_reset_use_case(audio_hal_s *ah);
 
 #endif

diff --git a/tizen-audio-internal.h b/tizen-audio-internal.h
index 8e0c03d..af274d0 100644 (file)
--- a/tizen-audio-internal.h
+++ b/tizen-audio-internal.h
@@ -76,7 +76,7 @@
     } \
 } while (0)
 /*
-static device_type_t outDeviceTypes[] = {
+static device_type_s outDeviceTypes[] = {
     { AUDIO_DEVICE_OUT_SPEAKER, "speaker" },
     { AUDIO_DEVICE_OUT_BT_SCO, "bt-sco-headset" },
     { AUDIO_DEVICE_OUT_BT_SCO_8K_NB, "bt-8k-sco-nb-headset" },
@@ -86,7 +86,7 @@ static device_type_t outDeviceTypes[] = {
     { 0, 0 },
 };
 
-static device_type_t inDeviceTypes[] = {
+static device_type_s inDeviceTypes[] = {
     { AUDIO_DEVICE_IN_MAIN_MIC, "main-mic" },
     { AUDIO_DEVICE_IN_BT_SCO, "bt-sco-mic" },
     { AUDIO_DEVICE_IN_BT_SCO_8K_NB, "bt-8k-sco-nb-mic" },
@@ -141,11 +141,6 @@ enum audio_device_type {
                                          AUDIO_DEVICE_IN_BT_SCO_16K_WB),
 };
 
-typedef struct device_type {
-    uint32_t type;
-    const char *name;
-} device_type_t;
-
 /* Verbs */
 #define AUDIO_USE_CASE_VERB_INACTIVE                "Inactive"
 #define AUDIO_USE_CASE_VERB_HIFI                    "HiFi"
@@ -167,34 +162,39 @@ typedef struct device_type {
 /* type definitions */
 typedef signed char int8_t;
 
+typedef struct device_type {
+    uint32_t type;
+    const char *name;
+} device_type_s;
+
 /* PCM */
 typedef struct {
     snd_pcm_format_t format;
     uint32_t rate;
     uint8_t channels;
-} audio_pcm_sample_spec_t;
+} audio_pcm_sample_spec_s;
 
 /* Routing */
 typedef enum audio_route_mode {
     VERB_NORMAL,
     VERB_VOICECALL,
     VERB_VOIP,
-} audio_route_mode_t;
+} audio_route_mode_e;
 
 typedef struct {
     snd_pcm_t *in;
     snd_pcm_t *out;
-} audio_pcm_devices_t;
+} audio_pcm_devices_s;
 
 typedef struct audio_hal_device {
     uint32_t active_in;
     uint32_t active_out;
-    audio_pcm_devices_t voice_pcm;
-    audio_pcm_devices_t bt_pcm;
-    audio_route_mode_t mode;
+    audio_pcm_devices_s voice_pcm;
+    audio_pcm_devices_s bt_pcm;
+    audio_route_mode_e mode;
     bool bt_wideband;
     bool bt_sco_ready;
-} audio_hal_device_t;
+} audio_hal_device_s;
 
 /* Volume */
 #define AUDIO_VOLUME_LEVEL_MAX 16
@@ -209,7 +209,7 @@ typedef enum audio_volume {
     AUDIO_VOLUME_TYPE_VOIP,             /**< VOIP volume type */
     AUDIO_VOLUME_TYPE_VOICE,            /**< Voice volume type */
     AUDIO_VOLUME_TYPE_MAX,              /**< Volume type count */
-} audio_volume_t;
+} audio_volume_e;
 
 typedef enum audio_gain {
     AUDIO_GAIN_TYPE_DEFAULT,
@@ -224,12 +224,12 @@ typedef enum audio_gain {
     AUDIO_GAIN_TYPE_VIDEO,
     AUDIO_GAIN_TYPE_TTS,
     AUDIO_GAIN_TYPE_MAX,
-} audio_gain_t;
+} audio_gain_e;
 
 typedef struct audio_volume_value_table {
     double volume[AUDIO_VOLUME_TYPE_MAX][AUDIO_VOLUME_LEVEL_MAX];
     double gain[AUDIO_GAIN_TYPE_MAX];
-} audio_volume_value_table_t;
+} audio_volume_value_table_s;
 
 enum {
     AUDIO_DEVICE_DIRECTION_IN  = 0x01,
@@ -244,13 +244,13 @@ enum {
 typedef struct audio_hal_volume {
     uint32_t volume_level_max[AUDIO_VOLUME_LEVEL_MAX];
     uint32_t volume_level[AUDIO_VOLUME_TYPE_MAX];
-    audio_volume_value_table_t *volume_value_table;
-} audio_hal_volume_t;
+    audio_volume_value_table_s *volume_value_table;
+} audio_hal_volume_s;
 
 /* UCM */
 typedef struct audio_hal_ucm {
     snd_use_case_mgr_t* uc_mgr;
-} audio_hal_ucm_t;
+} audio_hal_ucm_s;
 
 /* Mixer */
 typedef struct audio_hal_mixer {
@@ -261,7 +261,7 @@ typedef struct audio_hal_mixer {
         snd_ctl_elem_id_t *id;
         snd_ctl_elem_info_t *info;
     } control;
-} audio_hal_mixer_t;
+} audio_hal_mixer_s;
 
 /* Audio format */
 typedef enum audio_sample_format {
@@ -280,38 +280,38 @@ typedef enum audio_sample_format {
     AUDIO_SAMPLE_S24_32BE,
     AUDIO_SAMPLE_MAX,
     AUDIO_SAMPLE_INVALID = -1
-} audio_sample_format_t;
+} audio_sample_format_s;
 
 typedef struct audio_hal_comm {
     message_cb msg_cb;
     void *user_data;
-} audio_hal_comm_t;
+} audio_hal_comm_s;
 
 /* Overall */
 #define MAX_DIRECTION 2
 typedef struct audio_hal {
-    audio_hal_device_t device;
-    audio_hal_volume_t volume;
-    audio_hal_ucm_t ucm;
-    audio_hal_mixer_t mixer;
-    audio_hal_comm_t comm;
+    audio_hal_device_s device;
+    audio_hal_volume_s volume;
+    audio_hal_ucm_s ucm;
+    audio_hal_mixer_s mixer;
+    audio_hal_comm_s comm;
     audio_route_info_s *saved_route_infos[MAX_DIRECTION];
     bool call_wideband;
-} audio_hal_t;
-
-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_comm_init(audio_hal_t *ah);
-audio_return_e _audio_comm_deinit(audio_hal_t *ah);
-audio_return_e _audio_comm_send_message(audio_hal_t *ah, const char *name, int value);
+} audio_hal_s;
+
+audio_return_e _audio_ctrl_init(audio_hal_s *ah);
+audio_return_e _audio_ctrl_deinit(audio_hal_s *ah);
+audio_return_e _audio_volume_init(audio_hal_s *ah);
+audio_return_e _audio_volume_deinit(audio_hal_s *ah);
+audio_return_e _audio_routing_init(audio_hal_s *ah);
+audio_return_e _audio_routing_deinit(audio_hal_s *ah);
+audio_return_e _audio_stream_init(audio_hal_s *ah);
+audio_return_e _audio_stream_deinit(audio_hal_s *ah);
+audio_return_e _audio_pcm_init(audio_hal_s *ah);
+audio_return_e _audio_pcm_deinit(audio_hal_s *ah);
+audio_return_e _audio_comm_init(audio_hal_s *ah);
+audio_return_e _audio_comm_deinit(audio_hal_s *ah);
+audio_return_e _audio_comm_send_message(audio_hal_s *ah, const char *name, int value);
 
 typedef struct _dump_data {
     char *strbuf;

diff --git a/tizen-audio-pcm.c b/tizen-audio-pcm.c
index 0daad47..bf85ede 100644 (file)
--- a/tizen-audio-pcm.c
+++ b/tizen-audio-pcm.c
@@ -24,7 +24,7 @@
 #include "tizen-audio-internal.h"
 #include "tizen-audio-impl.h"
 
-audio_return_e _audio_pcm_init(audio_hal_t *ah)
+audio_return_e _audio_pcm_init(audio_hal_s *ah)
 {
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
 
@@ -36,7 +36,7 @@ audio_return_e _audio_pcm_init(audio_hal_t *ah)
     return AUDIO_RET_OK;
 }
 
-audio_return_e _audio_pcm_deinit(audio_hal_t *ah)
+audio_return_e _audio_pcm_deinit(audio_hal_s *ah)
 {
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
 

diff --git a/tizen-audio-routing.c b/tizen-audio-routing.c
index 67cf98c..822b445 100644 (file)
--- a/tizen-audio-routing.c
+++ b/tizen-audio-routing.c
@@ -30,7 +30,7 @@
 
 /* #define DEBUG_TIMING */
 
-static device_type_t outDeviceTypes[] = {
+static device_type_s outDeviceTypes[] = {
     { AUDIO_DEVICE_OUT_SPEAKER, "speaker" },
     { AUDIO_DEVICE_OUT_BT_SCO, "bt-sco-headset" },
     { AUDIO_DEVICE_OUT_BT_SCO_8K_NB, "bt-8k-sco-nb-headset" },
@@ -40,7 +40,7 @@ static device_type_t outDeviceTypes[] = {
     { 0, 0 },
 };
 
-static device_type_t inDeviceTypes[] = {
+static device_type_s inDeviceTypes[] = {
     { AUDIO_DEVICE_IN_MAIN_MIC, "main-mic" },
     { AUDIO_DEVICE_IN_BT_SCO, "bt-sco-mic" },
     { AUDIO_DEVICE_IN_BT_SCO_8K_NB, "bt-8k-sco-nb-mic" },
@@ -56,7 +56,7 @@ static const char* mode_to_verb_str[] = {
     AUDIO_USE_CASE_VERB_VOIP,
 };
 
-static bool __is_acive_device_bt_sco_for_call(audio_hal_t *ah)
+static bool __is_acive_device_bt_sco_for_call(audio_hal_s *ah)
 {
     if (!ah) {
         AUDIO_LOG_WARN("ah is null");
@@ -79,7 +79,7 @@ static bool __is_acive_device_bt_sco_for_call(audio_hal_t *ah)
     return false;
 }
 
-static uint32_t __convert_device_string_to_enum(audio_hal_t *ah, const char *verb, const char* device_str, uint32_t direction)
+static uint32_t __convert_device_string_to_enum(audio_hal_s *ah, const char *verb, const char* device_str, uint32_t direction)
 {
     uint32_t device = 0;
 
@@ -141,7 +141,7 @@ static uint32_t __convert_device_string_to_enum(audio_hal_t *ah, const char *ver
     return device;
 }
 
-static audio_return_e __set_devices(audio_hal_t *ah, const char *verb, device_info_s *devices, uint32_t num_of_devices)
+static audio_return_e __set_devices(audio_hal_s *ah, const char *verb, device_info_s *devices, uint32_t num_of_devices)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
     uint32_t new_device = 0;
@@ -209,7 +209,7 @@ static audio_return_e __set_devices(audio_hal_t *ah, const char *verb, device_in
     return audio_ret;
 }
 
-static audio_return_e __save_route_infos(audio_hal_t *ah, device_info_s *devices, int32_t num_of_devices)
+static audio_return_e __save_route_infos(audio_hal_s *ah, device_info_s *devices, int32_t num_of_devices)
 {
     int i = 0;
 
@@ -238,7 +238,7 @@ static audio_return_e __save_route_infos(audio_hal_t *ah, device_info_s *devices
 
 static void __reset_saved_route_infos(void *audio_handle)
 {
-    audio_hal_t *ah = (audio_hal_t *)audio_handle;
+    audio_hal_s *ah = (audio_hal_s *)audio_handle;
     int i = 0;
 
     AUDIO_RETURN_IF_FAIL(ah);
@@ -254,7 +254,7 @@ static void __reset_saved_route_infos(void *audio_handle)
     }
 }
 
-static audio_return_e __update_route_ap_playback_capture(audio_hal_t *ah, audio_route_info_s *route_info)
+static audio_return_e __update_route_ap_playback_capture(audio_hal_s *ah, audio_route_info_s *route_info)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
     device_info_s *devices = NULL;
@@ -281,7 +281,7 @@ static audio_return_e __update_route_ap_playback_capture(audio_hal_t *ah, audio_
     return audio_ret;
 }
 
-static audio_return_e __update_route_voicecall(audio_hal_t *ah, device_info_s *devices, int32_t num_of_devices)
+static audio_return_e __update_route_voicecall(audio_hal_s *ah, device_info_s *devices, int32_t num_of_devices)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
     const char *verb = mode_to_verb_str[VERB_VOICECALL];
@@ -329,7 +329,7 @@ static audio_return_e __update_route_voicecall(audio_hal_t *ah, device_info_s *d
     return audio_ret;
 }
 
-static audio_return_e __update_route_voip(audio_hal_t *ah, device_info_s *devices, int32_t num_of_devices)
+static audio_return_e __update_route_voip(audio_hal_s *ah, device_info_s *devices, int32_t num_of_devices)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
     const char *verb = mode_to_verb_str[VERB_NORMAL];
@@ -350,7 +350,7 @@ static audio_return_e __update_route_voip(audio_hal_t *ah, device_info_s *device
     return audio_ret;
 }
 
-static audio_return_e __update_route_voice_recognition(audio_hal_t *ah, device_info_s *devices, int32_t num_of_devices)
+static audio_return_e __update_route_voice_recognition(audio_hal_s *ah, device_info_s *devices, int32_t num_of_devices)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
     const char *verb = mode_to_verb_str[VERB_NORMAL];
@@ -386,7 +386,7 @@ static audio_return_e __update_route_voice_recognition(audio_hal_t *ah, device_i
     return audio_ret;
 }
 
-static audio_return_e __update_route_voice_information(audio_hal_t *ah, device_info_s *devices, int32_t num_of_devices)
+static audio_return_e __update_route_voice_information(audio_hal_s *ah, device_info_s *devices, int32_t num_of_devices)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
     const char *verb = mode_to_verb_str[VERB_NORMAL];
@@ -422,7 +422,7 @@ static audio_return_e __update_route_voice_information(audio_hal_t *ah, device_i
     return audio_ret;
 }
 
-static audio_return_e __update_route_reset(audio_hal_t *ah, uint32_t direction)
+static audio_return_e __update_route_reset(audio_hal_s *ah, uint32_t direction)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
     const char *active_devices[MAX_DEVICES] = {NULL,};
@@ -489,7 +489,7 @@ static audio_return_e __update_route_reset(audio_hal_t *ah, uint32_t direction)
     return audio_ret;
 }
 
-audio_return_e _audio_routing_init(audio_hal_t *ah)
+audio_return_e _audio_routing_init(audio_hal_s *ah)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
 
@@ -505,7 +505,7 @@ audio_return_e _audio_routing_init(audio_hal_t *ah)
     return audio_ret;
 }
 
-audio_return_e _audio_routing_deinit(audio_hal_t *ah)
+audio_return_e _audio_routing_deinit(audio_hal_s *ah)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
 
@@ -520,7 +520,7 @@ audio_return_e _audio_routing_deinit(audio_hal_t *ah)
 audio_return_e audio_update_route(void *audio_handle, audio_route_info_s *info)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
-    audio_hal_t *ah = (audio_hal_t *)audio_handle;
+    audio_hal_s *ah = (audio_hal_s *)audio_handle;
     device_info_s *devices = NULL;
 
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
@@ -563,7 +563,7 @@ audio_return_e audio_update_route(void *audio_handle, audio_route_info_s *info)
 audio_return_e audio_update_route_option(void *audio_handle, audio_route_option_s *option)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
-    audio_hal_t *ah = (audio_hal_t *)audio_handle;
+    audio_hal_s *ah = (audio_hal_s *)audio_handle;
 
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
     AUDIO_RETURN_VAL_IF_FAIL(option, AUDIO_ERR_PARAMETER);

diff --git a/tizen-audio-stream.c b/tizen-audio-stream.c
index 918ea30..a8fefec 100644 (file)
--- a/tizen-audio-stream.c
+++ b/tizen-audio-stream.c
@@ -23,14 +23,14 @@
 
 #include "tizen-audio-internal.h"
 
-audio_return_e _audio_stream_init(audio_hal_t *ah)
+audio_return_e _audio_stream_init(audio_hal_s *ah)
 {
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
 
     return AUDIO_RET_OK;
 }
 
-audio_return_e _audio_stream_deinit(audio_hal_t *ah)
+audio_return_e _audio_stream_deinit(audio_hal_s *ah)
 {
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
 
@@ -40,7 +40,7 @@ audio_return_e _audio_stream_deinit(audio_hal_t *ah)
 audio_return_e audio_notify_stream_connection_changed(void *audio_handle, audio_stream_info_s *info, uint32_t is_connected)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
-    audio_hal_t *ah = (audio_hal_t *)audio_handle;
+    audio_hal_s *ah = (audio_hal_s *)audio_handle;
 
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
     AUDIO_RETURN_VAL_IF_FAIL(info, AUDIO_ERR_PARAMETER);

diff --git a/tizen-audio-volume.c b/tizen-audio-volume.c
index de9bf47..5c1ae5d 100644 (file)
--- a/tizen-audio-volume.c
+++ b/tizen-audio-volume.c
@@ -104,9 +104,9 @@ static const char *__get_gain_type_string_by_idx(uint32_t gain_type_idx)
     }
 }
 
-static void __dump_tb(audio_hal_t *ah)
+static void __dump_tb(audio_hal_s *ah)
 {
-    audio_volume_value_table_t *volume_value_table = ah->volume.volume_value_table;
+    audio_volume_value_table_s *volume_value_table = ah->volume.volume_value_table;
     uint32_t vol_type_idx, vol_level_idx, gain_type_idx;
     const char *gain_type_str[] = {
         "def",          /* AUDIO_GAIN_TYPE_DEFAULT */
@@ -176,11 +176,11 @@ static void __dump_tb(audio_hal_t *ah)
 
 }
 
-static audio_return_e __load_volume_value_table_from_ini(audio_hal_t *ah)
+static audio_return_e __load_volume_value_table_from_ini(audio_hal_s *ah)
 {
     dictionary * dict = NULL;
     uint32_t vol_type_idx, vol_level_idx, gain_type_idx;
-    audio_volume_value_table_t *volume_value_table = ah->volume.volume_value_table;
+    audio_volume_value_table_s *volume_value_table = ah->volume.volume_value_table;
     int size = 0;
     const char delimiter[] = ", ";
     const char *table_str = "volumes";
@@ -262,7 +262,7 @@ static audio_return_e __load_volume_value_table_from_ini(audio_hal_t *ah)
     return AUDIO_RET_OK;
 }
 
-audio_return_e _audio_volume_init(audio_hal_t *ah)
+audio_return_e _audio_volume_init(audio_hal_s *ah)
 {
     int i;
     int val = 0;
@@ -286,7 +286,7 @@ audio_return_e _audio_volume_init(audio_hal_t *ah)
         ah->volume.volume_level[i] = val;
     }
 
-    if (!(ah->volume.volume_value_table = malloc(AUDIO_VOLUME_DEVICE_MAX * sizeof(audio_volume_value_table_t)))) {
+    if (!(ah->volume.volume_value_table = malloc(AUDIO_VOLUME_DEVICE_MAX * sizeof(audio_volume_value_table_s)))) {
         AUDIO_LOG_ERROR("volume_value_table malloc failed");
         return AUDIO_ERR_RESOURCE;
     }
@@ -300,7 +300,7 @@ audio_return_e _audio_volume_init(audio_hal_t *ah)
     return audio_ret;
 }
 
-audio_return_e _audio_volume_deinit(audio_hal_t *ah)
+audio_return_e _audio_volume_deinit(audio_hal_s *ah)
 {
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
 
@@ -314,7 +314,7 @@ audio_return_e _audio_volume_deinit(audio_hal_t *ah)
 
 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;
+    audio_hal_s *ah = (audio_hal_s *)audio_handle;
 
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
     AUDIO_RETURN_VAL_IF_FAIL(info, AUDIO_ERR_PARAMETER);
@@ -330,7 +330,7 @@ audio_return_e audio_get_volume_level_max(void *audio_handle, audio_volume_info_
 
 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;
+    audio_hal_s *ah = (audio_hal_s *)audio_handle;
 
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
     AUDIO_RETURN_VAL_IF_FAIL(info, AUDIO_ERR_PARAMETER);
@@ -350,8 +350,8 @@ audio_return_e audio_get_volume_level(void *audio_handle, audio_volume_info_s *i
 
 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;
+    audio_hal_s *ah = (audio_hal_s *)audio_handle;
+    audio_volume_value_table_s *volume_value_table;
     char dump_str[AUDIO_DUMP_STR_LEN] = {0,};
 
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
@@ -375,7 +375,7 @@ audio_return_e audio_get_volume_value(void *audio_handle, audio_volume_info_s *i
 audio_return_e audio_set_volume_level(void *audio_handle, audio_volume_info_s *info, uint32_t level)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
-    audio_hal_t *ah = (audio_hal_t *)audio_handle;
+    audio_hal_s *ah = (audio_hal_s *)audio_handle;
 
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
     AUDIO_RETURN_VAL_IF_FAIL(info, AUDIO_ERR_PARAMETER);
@@ -397,7 +397,7 @@ audio_return_e audio_set_volume_level(void *audio_handle, audio_volume_info_s *i
 audio_return_e audio_get_volume_mute(void *audio_handle, audio_volume_info_s *info, uint32_t *mute)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
-    audio_hal_t *ah = (audio_hal_t *)audio_handle;
+    audio_hal_s *ah = (audio_hal_s *)audio_handle;
 
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
     AUDIO_RETURN_VAL_IF_FAIL(info, AUDIO_ERR_PARAMETER);
@@ -411,7 +411,7 @@ audio_return_e audio_get_volume_mute(void *audio_handle, audio_volume_info_s *in
 audio_return_e audio_set_volume_mute(void *audio_handle, audio_volume_info_s *info, uint32_t mute)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
-    audio_hal_t *ah = (audio_hal_t *)audio_handle;
+    audio_hal_s *ah = (audio_hal_s *)audio_handle;
 
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
     AUDIO_RETURN_VAL_IF_FAIL(info, AUDIO_ERR_PARAMETER);
@@ -426,7 +426,7 @@ audio_return_e audio_set_volume_mute(void *audio_handle, audio_volume_info_s *in
 audio_return_e audio_set_volume_ratio(void *audio_handle, audio_stream_info_s *info, double ratio)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
-    audio_hal_t *ah = (audio_hal_t *)audio_handle;
+    audio_hal_s *ah = (audio_hal_s *)audio_handle;
 
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
     AUDIO_RETURN_VAL_IF_FAIL(info, AUDIO_ERR_PARAMETER);

diff --git a/tizen-audio.c b/tizen-audio.c
index fa4893b..e57e11b 100644 (file)
--- a/tizen-audio.c
+++ b/tizen-audio.c
@@ -25,12 +25,12 @@
 
 audio_return_e audio_init(void **audio_handle)
 {
-    audio_hal_t *ah;
+    audio_hal_s *ah;
     audio_return_e ret = AUDIO_RET_OK;
 
     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
 
-    if (!(ah = calloc(1, sizeof(audio_hal_t)))) {
+    if (!(ah = calloc(1, sizeof(audio_hal_s)))) {
         AUDIO_LOG_ERROR("failed to malloc()");
         return AUDIO_ERR_RESOURCE;
     }
@@ -72,7 +72,7 @@ error_exit:
 
 audio_return_e audio_deinit(void *audio_handle)
 {
-    audio_hal_t *ah = (audio_hal_t *)audio_handle;
+    audio_hal_s *ah = (audio_hal_s *)audio_handle;
 
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);