From: Jaechul Lee <jcsing.lee@samsung.com>
Date: Fri, 5 Feb 2021 02:25:37 +0000 (+0900)
Subject: typdef postfix is changed to {enum}_e and {struct}_s
X-Git-Tag: submit/tizen/20210218.045157~1
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=9becc628879cc937d80a97070edac3a2bd084ff5;p=platform%2Fadaptation%2Fap_broadcom%2Faudio-hal-bcm2837.git

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

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

diff --git a/hal-backend-audio.c b/hal-backend-audio.c
index 1a14d07..3072075 100644
--- 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-bcm2837.spec b/packaging/audio-hal-bcm2837.spec
index 058ca89..b75b5a5 100644
--- a/packaging/audio-hal-bcm2837.spec
+++ b/packaging/audio-hal-bcm2837.spec
@@ -1,6 +1,6 @@
 Name:       audio-hal-bcm2837
 Summary:    TIZEN Audio HAL for BCM2837
-Version:    0.1.10
+Version:    0.1.11
 Release:    0
 Group:      System/Libraries
 License:    Apache-2.0
diff --git a/tizen-audio-ctrl.c b/tizen-audio-ctrl.c
index 40c5d6c..b6536d8 100644
--- 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 9f59871..4458cec 100644
--- 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 093ad06..131c56f 100644
--- 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];
 }
@@ -84,7 +84,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;
@@ -169,10 +169,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) {
@@ -463,12 +463,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);
@@ -487,7 +487,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;
@@ -497,7 +497,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);
@@ -549,12 +549,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);
@@ -575,7 +575,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;
@@ -657,7 +657,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 ca1bc05..17b4025 100644
--- 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 _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);
 
 #endif
diff --git a/tizen-audio-internal.h b/tizen-audio-internal.h
index 35dede3..48305d6 100644
--- 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;
-
 /* Verbs */
 #define AUDIO_USE_CASE_VERB_INACTIVE                "Inactive"
 #define AUDIO_USE_CASE_VERB_HIFI                    "HiFi"
@@ -132,17 +127,22 @@ 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,
-} audio_route_mode_t;
+} audio_route_mode_e;
 
 typedef struct audio_hal_device {
     uint32_t active_in;
@@ -151,8 +151,8 @@ typedef struct audio_hal_device {
     snd_pcm_t *pcm_out;
     pthread_mutex_t pcm_lock;
     uint32_t pcm_count;
-    audio_route_mode_t mode;
-} audio_hal_device_t;
+    audio_route_mode_e mode;
+} audio_hal_device_s;
 
 /* Volume */
 #define AUDIO_VOLUME_LEVEL_MAX 16
@@ -167,7 +167,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,
@@ -182,12 +182,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,
@@ -197,8 +197,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 {
@@ -209,7 +209,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 {
@@ -228,25 +228,25 @@ typedef enum audio_sample_format {
     AUDIO_SAMPLE_S24_32BE,
     AUDIO_SAMPLE_MAX,
     AUDIO_SAMPLE_INVALID = -1
-} audio_sample_format_t;
+} audio_sample_format_s;
 
 /* Overall */
 typedef struct audio_hal {
-    audio_hal_device_t device;
-    audio_hal_volume_t volume;
-    audio_hal_mixer_t mixer;
-} audio_hal_t;
+    audio_hal_device_s device;
+    audio_hal_volume_s volume;
+    audio_hal_mixer_s mixer;
+} audio_hal_s;
 
-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_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);
 
 typedef struct _dump_data {
     char *strbuf;
diff --git a/tizen-audio-pcm.c b/tizen-audio-pcm.c
index 098e21e..a8519fb 100644
--- 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 feeed5d..406c5d6 100644
--- a/tizen-audio-routing.c
+++ b/tizen-audio-routing.c
@@ -34,7 +34,7 @@
 
 /* #define DEBUG_TIMING */
 
-static device_type_t outDeviceTypes[] = {
+static device_type_s outDeviceTypes[] = {
     { AUDIO_DEVICE_OUT_SPEAKER, "Speaker" },
     { AUDIO_DEVICE_OUT_BT_SCO, "Bluetooth" },
     { AUDIO_DEVICE_OUT_AUX, "Line" },
@@ -42,7 +42,7 @@ static device_type_t outDeviceTypes[] = {
     { 0, 0 },
 };
 
-static device_type_t inDeviceTypes[] = {
+static device_type_s inDeviceTypes[] = {
     { AUDIO_DEVICE_IN_BT_SCO, "BT Mic" },
     { 0, 0 },
 };
@@ -80,7 +80,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, 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;
@@ -146,7 +146,7 @@ static audio_return_e __set_devices(audio_hal_t *ah, const char *verb, device_in
     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;
@@ -175,7 +175,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;
     const char *verb = mode_to_verb_str[VERB_NORMAL];
@@ -197,7 +197,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,};
@@ -245,7 +245,7 @@ static audio_return_e __update_route_reset(audio_hal_t *ah, uint32_t direction)
     return audio_ret;
 }
 
-static void __audio_routing_playback_rpi3(audio_hal_t *ah)
+static void __audio_routing_playback_rpi3(audio_hal_s *ah)
 {
     bool display_avail = false;
     int ret = SYSTEM_INFO_ERROR_NONE;
@@ -262,7 +262,7 @@ static void __audio_routing_playback_rpi3(audio_hal_t *ah)
     }
 }
 
-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;
 
@@ -278,7 +278,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;
 
@@ -290,7 +290,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);
@@ -320,7 +320,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
--- 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 d22c842..de20c87 100644
--- 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;
     }
@@ -302,7 +302,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);
 
@@ -316,7 +316,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);
@@ -332,7 +332,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);
@@ -352,8 +352,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);
@@ -377,7 +377,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);
@@ -399,7 +399,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);
@@ -413,7 +413,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 7f3866d..39da2e4 100644
--- 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;
     }
@@ -68,7 +68,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);