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.14
[Issue Type] Readability enhance

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

diff --git a/hal-backend-audio.c b/hal-backend-audio.c
index aa44540..564abdc 100644 (file)
--- a/hal-backend-audio.c
+++ b/hal-backend-audio.c
@@ -1,3 +1,22 @@
+/*
+ * audio-hal
+ *
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>

diff --git a/packaging/audio-hal-emul.spec b/packaging/audio-hal-emul.spec
index ef8b047..4527c01 100644 (file)
--- a/packaging/audio-hal-emul.spec
+++ b/packaging/audio-hal-emul.spec
@@ -1,6 +1,6 @@
 Name:       audio-hal-emul
 Summary:    TIZEN Audio HAL for Emulator
-Version:    0.1.13
+Version:    0.1.14
 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-impl-ctrl.c b/tizen-audio-impl-ctrl.c
index 33ee484..70dc73b 100644 (file)
--- a/tizen-audio-impl-ctrl.c
+++ b/tizen-audio-impl-ctrl.c
@@ -28,7 +28,7 @@
 
 #include "tizen-audio-internal.h"
 
-audio_return_e _control_init(audio_hal_t *ah)
+audio_return_e _control_init(audio_hal_s *ah)
 {
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
 
@@ -36,7 +36,7 @@ audio_return_e _control_init(audio_hal_t *ah)
     return AUDIO_RET_OK;
 }
 
-audio_return_e _control_deinit(audio_hal_t *ah)
+audio_return_e _control_deinit(audio_hal_s *ah)
 {
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
 
@@ -44,7 +44,7 @@ audio_return_e _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);
 
@@ -52,7 +52,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 *card, const char *ctl_name, int *val)
+audio_return_e _mixer_control_get_value(audio_hal_s *ah, const char *card, const char *ctl_name, int *val)
 {
     snd_ctl_t *handle;
     snd_ctl_elem_value_t *control;
@@ -135,7 +135,7 @@ close:
     return AUDIO_ERR_UNDEFINED;
 }
 
-audio_return_e _mixer_control_set_value(audio_hal_t *ah, const char *card, const char *ctl_name, int val)
+audio_return_e _mixer_control_set_value(audio_hal_s *ah, const char *card, const char *ctl_name, int val)
 {
     snd_ctl_t *handle;
     snd_ctl_elem_value_t *control;
@@ -215,7 +215,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);
@@ -225,7 +225,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 82d7c8a..b73c397 100644 (file)
--- a/tizen-audio-impl-pcm.c
+++ b/tizen-audio-impl-pcm.c
@@ -62,7 +62,7 @@ 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];
 }
@@ -82,7 +82,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;
@@ -167,10 +167,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) {
@@ -461,12 +461,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);
@@ -485,7 +485,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;
@@ -495,7 +495,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);
@@ -547,12 +547,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);
@@ -573,7 +573,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;
@@ -655,7 +655,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.h b/tizen-audio-impl.h
index 37a982e..1c91244 100644 (file)
--- a/tizen-audio-impl.h
+++ b/tizen-audio-impl.h
@@ -33,15 +33,15 @@ 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 _control_init(audio_hal_t *ah);
-audio_return_e _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* card, 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 *card, 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 _control_init(audio_hal_s *ah);
+audio_return_e _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* card, 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 *card, 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);
 
 #endif

diff --git a/tizen-audio-internal.h b/tizen-audio-internal.h
index 2d8b2cc..079133e 100644 (file)
--- a/tizen-audio-internal.h
+++ b/tizen-audio-internal.h
@@ -105,11 +105,6 @@ enum audio_device_type {
                                          AUDIO_DEVICE_IN_BT_SCO),
 };
 
-typedef struct device_type {
-    uint32_t type;
-    const char *name;
-} device_type_t;
-
 #define streq !strcmp
 #define strneq strcmp
 
@@ -123,12 +118,17 @@ 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;
 
 typedef struct audio_hal_device {
     uint32_t active_in;
@@ -137,7 +137,7 @@ typedef struct audio_hal_device {
     snd_pcm_t *pcm_out;
     pthread_mutex_t pcm_lock;
     uint32_t pcm_count;
-} audio_hal_device_t;
+} audio_hal_device_s;
 
 /* Volume */
 #define AUDIO_VOLUME_LEVEL_MAX 16
@@ -152,7 +152,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,
@@ -167,12 +167,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_VOLUME_DEVICE_DEFAULT,
@@ -182,8 +182,8 @@ 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;
 
 /* Mixer */
 typedef struct audio_hal_mixer {
@@ -194,7 +194,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 {
@@ -213,32 +213,32 @@ 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 */
 typedef struct audio_hal {
-    audio_hal_device_t device;
-    audio_hal_volume_t volume;
-    audio_hal_mixer_t mixer;
-    audio_hal_comm_t comm;
-} audio_hal_t;
-
-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_device_s device;
+    audio_hal_volume_s volume;
+    audio_hal_mixer_s mixer;
+    audio_hal_comm_s comm;
+} audio_hal_s;
+
+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 098e21e..a8519fb 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);
 
@@ -49,7 +49,7 @@ audio_return_e audio_pcm_open(void *audio_handle, const char *card, const char *
         uint32_t period_size, uint32_t periods, void **pcm_handle)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
-    audio_hal_t *ah = NULL;
+    audio_hal_s *ah = NULL;
 
     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
@@ -60,7 +60,7 @@ audio_return_e audio_pcm_open(void *audio_handle, const char *card, const char *
     if ((audio_ret = _pcm_open(card, device, direction, sample_spec, period_size, periods, pcm_handle)))
         return audio_ret;
 
-    ah = (audio_hal_t*)audio_handle;
+    ah = (audio_hal_s*)audio_handle;
     ah->device.pcm_count++;
     AUDIO_LOG_INFO("Opening PCM handle %p", *pcm_handle);
 
@@ -94,7 +94,7 @@ audio_return_e audio_pcm_stop(void *audio_handle, void *pcm_handle)
 audio_return_e audio_pcm_close(void *audio_handle, void *pcm_handle)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
-    audio_hal_t *ah = NULL;
+    audio_hal_s *ah = NULL;
 
     AUDIO_RETURN_VAL_IF_FAIL(audio_handle, AUDIO_ERR_PARAMETER);
     AUDIO_RETURN_VAL_IF_FAIL(pcm_handle, AUDIO_ERR_PARAMETER);
@@ -103,7 +103,7 @@ audio_return_e audio_pcm_close(void *audio_handle, void *pcm_handle)
         return audio_ret;
 
     pcm_handle = NULL;
-    ah = (audio_hal_t*)audio_handle;
+    ah = (audio_hal_s*)audio_handle;
     ah->device.pcm_count--;
 
     AUDIO_LOG_INFO("PCM handle close success (count:%d)", ah->device.pcm_count);

diff --git a/tizen-audio-routing.c b/tizen-audio-routing.c
index a5a572e..b7123c1 100644 (file)
--- a/tizen-audio-routing.c
+++ b/tizen-audio-routing.c
@@ -31,7 +31,7 @@
 
 /* #define DEBUG_TIMING */
 
-static device_type_t outDeviceTypes[] = {
+static device_type_s outDeviceTypes[] = {
     { AUDIO_DEVICE_OUT_SPEAKER, "Speaker" },
     { AUDIO_DEVICE_OUT_JACK, "Headphones" },
     { AUDIO_DEVICE_OUT_BT_SCO, "Bluetooth" },
@@ -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, "MainMic" },
     { AUDIO_DEVICE_IN_JACK, "HeadsetMic" },
     { AUDIO_DEVICE_IN_BT_SCO, "BT Mic" },
@@ -76,7 +76,7 @@ static uint32_t __convert_device_string_to_enum(const char* device_str, uint32_t
     return device;
 }
 
-static audio_return_e __set_devices(audio_hal_t *ah, device_info_s *devices, uint32_t num_of_devices)
+static audio_return_e __set_devices(audio_hal_s *ah, device_info_s *devices, uint32_t num_of_devices)
 {
     audio_return_e audio_ret = AUDIO_RET_OK;
     uint32_t new_device = 0;
@@ -140,7 +140,7 @@ static audio_return_e __set_devices(audio_hal_t *ah, device_info_s *devices, uin
     return audio_ret;
 }
 
-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;
@@ -161,7 +161,7 @@ static audio_return_e __update_route_ap_playback_capture(audio_hal_t *ah, audio_
     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;
 
@@ -179,7 +179,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_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,};
@@ -221,7 +221,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_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
 
@@ -231,7 +231,7 @@ audio_return_e _audio_routing_init(audio_hal_t *ah)
     return AUDIO_RET_OK;
 }
 
-audio_return_e _audio_routing_deinit(audio_hal_t *ah)
+audio_return_e _audio_routing_deinit(audio_hal_s *ah)
 {
     AUDIO_RETURN_VAL_IF_FAIL(ah, AUDIO_ERR_PARAMETER);
 
@@ -243,7 +243,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);
@@ -278,7 +278,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 820a497..d30f1e0 100644 (file)
--- a/tizen-audio-volume.c
+++ b/tizen-audio-volume.c
@@ -103,9 +103,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 */
@@ -175,11 +175,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";
@@ -261,7 +261,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;
@@ -285,7 +285,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;
     }
@@ -299,7 +299,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);
 
@@ -313,7 +313,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);
@@ -329,7 +329,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);
@@ -349,8 +349,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);
@@ -374,7 +374,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);
@@ -394,7 +394,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);
@@ -408,7 +408,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);

diff --git a/tizen-audio.c b/tizen-audio.c
index 7e103dd..60fec26 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 = malloc(sizeof(audio_hal_t)))) {
+    if (!(ah = malloc(sizeof(audio_hal_s)))) {
         AUDIO_LOG_ERROR("failed to malloc()");
         return AUDIO_ERR_RESOURCE;
     }
@@ -67,7 +67,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);