Apply Tizen coding rule and add docsubmit/tizen_common/20151229.154718submit/tizen_common/20151229.144031submit/tizen/20151211.082335accepted/tizen/wearable/20151212.073329accepted/tizen/tv/20151212.072724accepted/tizen/mobile/20151212.071232

Change-Id: Idf8b048e0b2d668ac56731a7788974fffe5ea500
Signed-off-by: Gilbok Lee <gilbok.lee@samsung.com>

6 files changed, 709 insertions, 899 deletions

diff --git a/packaging/libmm-radio.spec b/packaging/libmm-radio.spec
index 3725f2a..2ad50dd 100755
--- a/packaging/libmm-radio.spec
+++ b/packaging/libmm-radio.spec
@@ -1,7 +1,7 @@
 Name:       libmm-radio
 Summary:    Multimedia Framework Radio Library
 Version:    0.2.3
-Release:    1
+Release:    2
 Group:      System/Libraries
 License:    Apache-2.0
 Source0:    %{name}-%{version}.tar.gz
diff --git a/src/mm_radio.c b/src/mm_radio.c
index 8c1a9e6..2847ee6 100755
--- a/src/mm_radio.c
+++ b/src/mm_radio.c
@@ -22,7 +22,7 @@
 /*===========================================================================================
 |																							|
 |  INCLUDE FILES																			|
-|  																							|
+|																							|
 ========================================================================================== */
 
 #include <string.h>
@@ -36,7 +36,7 @@
 /*===========================================================================================
 |																							|
 |  LOCAL DEFINITIONS AND DECLARATIONS FOR MODULE											|
-|  																							|
+|																							|
 ========================================================================================== */
 
 /*---------------------------------------------------------------------------
@@ -78,32 +78,30 @@
 /*===========================================================================
 |																			|
 |  FUNCTION DEFINITIONS														|
-|  																			|
+|																			|
 ========================================================================== */
 
 int mm_radio_create(MMHandleType *hradio)
 {
 	int result = MM_ERROR_NONE;
-	mm_radio_t* new_radio = NULL;
+	mm_radio_t *new_radio = NULL;
 
 	MMRADIO_LOG_FENTER();
 
 	return_val_if_fail(hradio, MM_ERROR_RADIO_NOT_INITIALIZED);
 
-
 	/* alloc radio structure */
-	new_radio = (mm_radio_t*) malloc(sizeof(mm_radio_t));
-	if ( ! new_radio )
-	{
+	new_radio = (mm_radio_t *)malloc(sizeof(mm_radio_t));
+	if (!new_radio) {
 		debug_critical("cannot allocate memory for radio\n");
 		goto ERROR;
 	}
 	memset(new_radio, 0, sizeof(mm_radio_t));
 
 	/* internal creation stuffs */
-	result = _mmradio_create_radio( new_radio );
+	result = _mmradio_create_radio(new_radio);
 
-	if(result != MM_ERROR_NONE)
+	if (result != MM_ERROR_NONE)
 		goto ERROR;
 
 	*hradio = (MMHandleType)new_radio;
@@ -114,10 +112,8 @@ int mm_radio_create(MMHandleType *hradio)
 
 ERROR:
 
-	if ( new_radio )
-	{
-		MMRADIO_FREEIF( new_radio );
-	}
+	if (new_radio)
+		MMRADIO_FREEIF(new_radio);
 
 	*hradio = (MMHandleType)0;
 
@@ -127,26 +123,22 @@ ERROR:
 	return result;
 }
 
-int  mm_radio_destroy(MMHandleType hradio)
+int mm_radio_destroy(MMHandleType hradio)
 {
 	int result = MM_ERROR_NONE;
-	mm_radio_t* radio = (mm_radio_t*)hradio;
+	mm_radio_t *radio = (mm_radio_t *)hradio;
 
 	MMRADIO_LOG_FENTER();
 
 	return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 
-	result = _mmradio_destroy( radio );
+	result = _mmradio_destroy(radio);
 
-	if ( result != MM_ERROR_NONE )
-	{
+	if (result != MM_ERROR_NONE)
 		debug_error("failed to destroy radio\n");
-	}
 
 	/* free radio */
-	MMRADIO_FREEIF( radio );
-
-
+	MMRADIO_FREEIF(radio);
 
 	MMRADIO_LOG_FLEAVE();
 
@@ -156,17 +148,17 @@ int  mm_radio_destroy(MMHandleType hradio)
 int mm_radio_realize(MMHandleType hradio)
 {
 	int result = MM_ERROR_NONE;
-	mm_radio_t* radio = (mm_radio_t*)hradio;
+	mm_radio_t *radio = (mm_radio_t *)hradio;
 
 	MMRADIO_LOG_FENTER();
 
 	return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 
-	MMRADIO_CMD_LOCK( radio );
+	MMRADIO_CMD_LOCK(radio);
 
-	result = _mmradio_realize( radio );
+	result = _mmradio_realize(radio);
 
-	MMRADIO_CMD_UNLOCK( radio );
+	MMRADIO_CMD_UNLOCK(radio);
 
 	MMRADIO_LOG_FLEAVE();
 
@@ -176,7 +168,7 @@ int mm_radio_realize(MMHandleType hradio)
 int mm_radio_unrealize(MMHandleType hradio)
 {
 	int result = MM_ERROR_NONE;
-	mm_radio_t* radio = (mm_radio_t*)hradio;
+	mm_radio_t *radio = (mm_radio_t *)hradio;
 	MMRadioStateType state = 0;
 
 	MMRADIO_LOG_FENTER();
@@ -186,16 +178,14 @@ int mm_radio_unrealize(MMHandleType hradio)
 	mm_radio_get_state((hradio), &state);
 	MMRADIO_LOG_DEBUG("mm_radio_unrealize state: %d\n", state);
 
-	if(state == MM_RADIO_STATE_SCANNING)
-	{
+	if (state == MM_RADIO_STATE_SCANNING)
 		mm_radio_scan_stop(hradio);
-	}
 
-	MMRADIO_CMD_LOCK( radio );
+	MMRADIO_CMD_LOCK(radio);
 
-	result = _mmradio_unrealize( radio );
+	result = _mmradio_unrealize(radio);
 
-	MMRADIO_CMD_UNLOCK( radio );
+	MMRADIO_CMD_UNLOCK(radio);
 
 	MMRADIO_LOG_FLEAVE();
 
@@ -205,27 +195,27 @@ int mm_radio_unrealize(MMHandleType hradio)
 int mm_radio_set_message_callback(MMHandleType hradio, MMMessageCallback callback, void *user_param)
 {
 	int result = MM_ERROR_NONE;
-	mm_radio_t* radio = (mm_radio_t*)hradio;
+	mm_radio_t *radio = (mm_radio_t *)hradio;
 
 	MMRADIO_LOG_FENTER();
 
 	return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 
-	MMRADIO_CMD_LOCK( radio );
+	MMRADIO_CMD_LOCK(radio);
 
-	result = _mmradio_set_message_callback( radio, callback, user_param );
+	result = _mmradio_set_message_callback(radio, callback, user_param);
 
-	MMRADIO_CMD_UNLOCK( radio );
+	MMRADIO_CMD_UNLOCK(radio);
 
 	MMRADIO_LOG_FLEAVE();
 
 	return result;
 }
 
-int mm_radio_get_state(MMHandleType hradio, MMRadioStateType* pState)
+int mm_radio_get_state(MMHandleType hradio, MMRadioStateType *pState)
 {
 	int result = MM_ERROR_NONE;
-	mm_radio_t* radio = (mm_radio_t*)hradio;
+	mm_radio_t *radio = (mm_radio_t *)hradio;
 	int state = 0;
 
 	MMRADIO_LOG_FENTER();
@@ -233,13 +223,13 @@ int mm_radio_get_state(MMHandleType hradio, MMRadioStateType* pState)
 	return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 	return_val_if_fail(pState, MM_ERROR_COMMON_INVALID_ARGUMENT);
 
-	MMRADIO_CMD_LOCK( radio );
+	MMRADIO_CMD_LOCK(radio);
 
-	result = _mmradio_get_state( radio, &state );
+	result = _mmradio_get_state(radio, &state);
 
 	*pState = state;
 
-	MMRADIO_CMD_UNLOCK( radio );
+	MMRADIO_CMD_UNLOCK(radio);
 
 	MMRADIO_LOG_FLEAVE();
 
@@ -249,37 +239,37 @@ int mm_radio_get_state(MMHandleType hradio, MMRadioStateType* pState)
 int mm_radio_start(MMHandleType hradio)
 {
 	int result = MM_ERROR_NONE;
-	mm_radio_t* radio = (mm_radio_t*)hradio;
+	mm_radio_t *radio = (mm_radio_t *)hradio;
 
 	MMRADIO_LOG_FENTER();
 
 	return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 
-	MMRADIO_CMD_LOCK( radio );
+	MMRADIO_CMD_LOCK(radio);
 
-	result = _mmradio_start( radio );
+	result = _mmradio_start(radio);
 
-	MMRADIO_CMD_UNLOCK( radio );
+	MMRADIO_CMD_UNLOCK(radio);
 
 	MMRADIO_LOG_FLEAVE();
 
 	return result;
 }
 
-int  mm_radio_stop(MMHandleType hradio)
+int mm_radio_stop(MMHandleType hradio)
 {
 	int result = MM_ERROR_NONE;
-	mm_radio_t* radio = (mm_radio_t*)hradio;
+	mm_radio_t *radio = (mm_radio_t *)hradio;
 
 	MMRADIO_LOG_FENTER();
 
 	return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 
-	MMRADIO_CMD_LOCK( radio );
+	MMRADIO_CMD_LOCK(radio);
 
-	result = _mmradio_stop( radio );
+	result = _mmradio_stop(radio);
 
-	MMRADIO_CMD_UNLOCK( radio );
+	MMRADIO_CMD_UNLOCK(radio);
 
 	MMRADIO_LOG_FLEAVE();
 
@@ -289,20 +279,20 @@ int  mm_radio_stop(MMHandleType hradio)
 int mm_radio_seek(MMHandleType hradio, MMRadioSeekDirectionType direction)
 {
 	int result = MM_ERROR_NONE;
-	mm_radio_t* radio = (mm_radio_t*)hradio;
+	mm_radio_t *radio = (mm_radio_t *)hradio;
 
 	MMRADIO_LOG_FENTER();
 
 	return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 	return_val_if_fail(direction >= MM_RADIO_SEEK_UP && direction <= MM_RADIO_SEEK_DOWN, MM_ERROR_INVALID_ARGUMENT);
 
-	MMRADIO_CMD_LOCK( radio );
+	MMRADIO_CMD_LOCK(radio);
 
 	radio->seek_direction = direction;
 
-	result = _mmradio_seek( radio, direction );
+	result = _mmradio_seek(radio, direction);
 
-	MMRADIO_CMD_UNLOCK( radio );
+	MMRADIO_CMD_UNLOCK(radio);
 
 	MMRADIO_LOG_FLEAVE();
 
@@ -312,27 +302,27 @@ int mm_radio_seek(MMHandleType hradio, MMRadioSeekDirectionType direction)
 int mm_radio_set_frequency(MMHandleType hradio, int freq)
 {
 	int result = MM_ERROR_NONE;
-	mm_radio_t* radio = (mm_radio_t*)hradio;
+	mm_radio_t *radio = (mm_radio_t *)hradio;
 
 	MMRADIO_LOG_FENTER();
 
 	return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 
-	MMRADIO_CMD_LOCK( radio );
+	MMRADIO_CMD_LOCK(radio);
 
-	result = _mmradio_set_frequency( radio, freq );
+	result = _mmradio_set_frequency(radio, freq);
 
-	MMRADIO_CMD_UNLOCK( radio );
+	MMRADIO_CMD_UNLOCK(radio);
 
 	MMRADIO_LOG_FLEAVE();
 
 	return result;
 }
 
-int mm_radio_get_frequency(MMHandleType hradio, int* pFreq)
+int mm_radio_get_frequency(MMHandleType hradio, int *pFreq)
 {
 	int result = MM_ERROR_NONE;
-	mm_radio_t* radio = (mm_radio_t*)hradio;
+	mm_radio_t *radio = (mm_radio_t *)hradio;
 	int freq = 0;
 
 	MMRADIO_LOG_FENTER();
@@ -340,13 +330,13 @@ int mm_radio_get_frequency(MMHandleType hradio, int* pFreq)
 	return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 	return_val_if_fail(pFreq, MM_ERROR_INVALID_ARGUMENT);
 
-	MMRADIO_CMD_LOCK( radio );
+	MMRADIO_CMD_LOCK(radio);
 
-	result = _mmradio_get_frequency( radio, &freq );
+	result = _mmradio_get_frequency(radio, &freq);
 
 	*pFreq = freq;
 
-	MMRADIO_CMD_UNLOCK( radio );
+	MMRADIO_CMD_UNLOCK(radio);
 
 	MMRADIO_LOG_FLEAVE();
 
@@ -356,17 +346,17 @@ int mm_radio_get_frequency(MMHandleType hradio, int* pFreq)
 int mm_radio_scan_start(MMHandleType hradio)
 {
 	int result = MM_ERROR_NONE;
-	mm_radio_t* radio = (mm_radio_t*)hradio;
+	mm_radio_t *radio = (mm_radio_t *)hradio;
 
 	MMRADIO_LOG_FENTER();
 
 	return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 
-	MMRADIO_CMD_LOCK( radio );
+	MMRADIO_CMD_LOCK(radio);
 
-	result = _mmradio_start_scan( radio );
+	result = _mmradio_start_scan(radio);
 
-	MMRADIO_CMD_UNLOCK( radio );
+	MMRADIO_CMD_UNLOCK(radio);
 
 	MMRADIO_LOG_FLEAVE();
 
@@ -376,17 +366,17 @@ int mm_radio_scan_start(MMHandleType hradio)
 int mm_radio_scan_stop(MMHandleType hradio)
 {
 	int result = MM_ERROR_NONE;
-	mm_radio_t* radio = (mm_radio_t*)hradio;
+	mm_radio_t *radio = (mm_radio_t *)hradio;
 
 	MMRADIO_LOG_FENTER();
 
 	return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 
-	MMRADIO_CMD_LOCK( radio );
+	MMRADIO_CMD_LOCK(radio);
 
-	result = _mmradio_stop_scan( radio );
+	result = _mmradio_stop_scan(radio);
 
-	MMRADIO_CMD_UNLOCK( radio );
+	MMRADIO_CMD_UNLOCK(radio);
 
 	MMRADIO_LOG_FLEAVE();
 
@@ -396,7 +386,7 @@ int mm_radio_scan_stop(MMHandleType hradio)
 int mm_radio_set_mute(MMHandleType hradio, bool muted)
 {
 	int result = MM_ERROR_NONE;
-	mm_radio_t* radio = (mm_radio_t*)hradio;
+	mm_radio_t *radio = (mm_radio_t *)hradio;
 
 	MMRADIO_LOG_FENTER();
 
@@ -405,13 +395,9 @@ int mm_radio_set_mute(MMHandleType hradio, bool muted)
 	MMRADIO_CMD_LOCK(radio);
 
 	if (muted)
-	{
 		result = _mmradio_mute(radio);
-	}
 	else
-	{
 		result = _mmradio_unmute(radio);
-	}
 
 	MMRADIO_CMD_UNLOCK(radio);
 
@@ -429,13 +415,13 @@ int mm_radio_get_signal_strength(MMHandleType hradio, int *value)
 
 	int ret = MM_ERROR_NONE;
 
-	mm_radio_t* radio = (mm_radio_t*)hradio;
+	mm_radio_t *radio = (mm_radio_t *)hradio;
 
-	MMRADIO_CMD_LOCK( radio );
+	MMRADIO_CMD_LOCK(radio);
 
 	ret = _mm_radio_get_signal_strength(radio, value);
 
-	MMRADIO_CMD_UNLOCK( radio );
+	MMRADIO_CMD_UNLOCK(radio);
 
 	MMRADIO_LOG_DEBUG("signal strength = %d\n", *value);
 	MMRADIO_LOG_FLEAVE();
@@ -450,7 +436,7 @@ int mm_radio_get_region_type(MMHandleType hradio, MMRadioRegionType *type)
 	return_val_if_fail(type, MM_ERROR_INVALID_ARGUMENT);
 
 	int result = MM_ERROR_NONE;
-	mm_radio_t* radio = (mm_radio_t*)hradio;
+	mm_radio_t *radio = (mm_radio_t *)hradio;
 	MMRadioRegionType cur_type = MM_RADIO_REGION_GROUP_NONE;
 
 	result = _mmradio_get_region_type(radio, &cur_type);
@@ -462,7 +448,7 @@ int mm_radio_get_region_type(MMHandleType hradio, MMRadioRegionType *type)
 	return result;
 }
 
-int mm_radio_get_region_frequency_range(MMHandleType hradio, unsigned int *min, unsigned int*max)
+int mm_radio_get_region_frequency_range(MMHandleType hradio, unsigned int *min, unsigned int *max)
 {
 	MMRADIO_LOG_FENTER();
 
@@ -470,14 +456,13 @@ int mm_radio_get_region_frequency_range(MMHandleType hradio, unsigned int *min,
 	return_val_if_fail(min && max, MM_ERROR_INVALID_ARGUMENT);
 
 	int result = MM_ERROR_NONE;
-	mm_radio_t* radio = (mm_radio_t*)hradio;
+	mm_radio_t *radio = (mm_radio_t *)hradio;
 	unsigned int min_freq = 0;
 	unsigned int max_freq = 0;
 
 	result = _mmradio_get_region_frequency_range(radio, &min_freq, &max_freq);
 
-	if (result == MM_ERROR_NONE)
-	{
+	if (result == MM_ERROR_NONE) {
 		*min = min_freq;
 		*max = max_freq;
 	}
@@ -494,18 +479,14 @@ int mm_radio_get_channel_spacing(MMHandleType hradio, int *channel_spacing)
 	return_val_if_fail(channel_spacing, MM_ERROR_INVALID_ARGUMENT);
 
 	int result = MM_ERROR_NONE;
-	mm_radio_t* radio = (mm_radio_t*)hradio;
+	mm_radio_t *radio = (mm_radio_t *)hradio;
 	unsigned int ch_spacing = 0;
 
 	result = _mmradio_get_channel_spacing(radio, &ch_spacing);
 
 	if (result == MM_ERROR_NONE)
-	{
 		*channel_spacing = ch_spacing;
-	}
 
 	MMRADIO_LOG_FLEAVE();
 	return result;
 }
-
-
diff --git a/src/mm_radio_audio_focus.c b/src/mm_radio_audio_focus.c
index fba1c75..6e20751 100755
--- a/src/mm_radio_audio_focus.c
+++ b/src/mm_radio_audio_focus.c
@@ -26,7 +26,7 @@
 #include "mm_sound_focus.h"
 #include "unistd.h"
 
-int mmradio_audio_focus_register(MMRadioAudioFocus* sm, mm_sound_focus_changed_cb callback, void* param)
+int mmradio_audio_focus_register(MMRadioAudioFocus *sm, mm_sound_focus_changed_cb callback, void *param)
 {
 	/* read mm-session information */
 	int session_type = MM_SESSION_TYPE_MEDIA;
@@ -37,8 +37,7 @@ int mmradio_audio_focus_register(MMRadioAudioFocus* sm, mm_sound_focus_changed_c
 
 	MMRADIO_LOG_FENTER();
 
-	if ( !sm )
-	{
+	if (!sm) {
 		MMRADIO_LOG_ERROR("invalid session handle\n");
 		return MM_ERROR_RADIO_NOT_INITIALIZED;
 	}
@@ -46,20 +45,16 @@ int mmradio_audio_focus_register(MMRadioAudioFocus* sm, mm_sound_focus_changed_c
 
 	/* read session information */
 	errorcode = _mm_session_util_read_information(pid, &session_type, &session_flags);
-	if ( errorcode == MM_ERROR_NONE )
-	{
+	if (errorcode == MM_ERROR_NONE) {
 		debug_warning("Read Session Information success. session_type : %d flags: %d \n", session_type, session_flags);
 		sm->snd_session_flags = session_flags;
 		session_type = MM_SESSION_TYPE_MEDIA;
-	}
-	else
-	{
-		debug_warning("Read Session Information failed. skip sound focus register function. errorcode %x \n" ,errorcode);
+	} else {
+		debug_warning("Read Session Information failed. skip sound focus register function. errorcode %x \n", errorcode);
 	}
 
 	/* check if it's MEDIA type */
-	if ( session_type != MM_SESSION_TYPE_MEDIA)
-	{
+	if (session_type != MM_SESSION_TYPE_MEDIA) {
 		MMRADIO_LOG_DEBUG("session type is not MEDIA (%d)\n", session_type);
 		return MM_ERROR_RADIO_INTERNAL;
 	}
@@ -72,8 +67,7 @@ int mmradio_audio_focus_register(MMRadioAudioFocus* sm, mm_sound_focus_changed_c
 	mm_sound_focus_get_id(&handle);
 	sm->handle = handle;
 
-	if(mm_sound_register_focus_for_session(handle, pid, "radio", callback, param) != MM_ERROR_NONE)
-	{
+	if (mm_sound_register_focus_for_session(handle, pid, "radio", callback, param) != MM_ERROR_NONE) {
 		MMRADIO_LOG_DEBUG("mm_sound_register_focus_for_session is failed\n");
 		return MM_ERROR_POLICY_BLOCKED;
 	}
@@ -83,13 +77,11 @@ int mmradio_audio_focus_register(MMRadioAudioFocus* sm, mm_sound_focus_changed_c
 	return MM_ERROR_NONE;
 }
 
-
-int mmradio_audio_focus_deregister(MMRadioAudioFocus* sm)
+int mmradio_audio_focus_deregister(MMRadioAudioFocus *sm)
 {
 	MMRADIO_LOG_FENTER();
 
-	if ( !sm )
-	{
+	if (!sm) {
 		MMRADIO_LOG_ERROR("invalid session handle\n");
 		return MM_ERROR_RADIO_NOT_INITIALIZED;
 	}
@@ -97,13 +89,12 @@ int mmradio_audio_focus_deregister(MMRadioAudioFocus* sm)
 	if (MM_ERROR_NONE != mm_sound_unregister_focus(sm->handle))
 		MMRADIO_LOG_ERROR("mm_sound_unregister_focus failed\n");
 
-
 	MMRADIO_LOG_FLEAVE();
 
 	return MM_ERROR_NONE;
 }
 
-int mmradio_acquire_audio_focus(MMRadioAudioFocus* sm)
+int mmradio_acquire_audio_focus(MMRadioAudioFocus *sm)
 {
 	int ret = MM_ERROR_NONE;
 	mm_sound_focus_type_e focus_type = FOCUS_NONE;
@@ -112,33 +103,28 @@ int mmradio_acquire_audio_focus(MMRadioAudioFocus* sm)
 	MMRADIO_LOG_ERROR("mmradio_acquire_audio_focus sm->cur_focus_type : %d\n", sm->cur_focus_type);
 
 	focus_type = FOCUS_FOR_BOTH & ~(sm->cur_focus_type);
-	if (focus_type != FOCUS_NONE)
-	{
+	if (focus_type != FOCUS_NONE) {
 		ret = mm_sound_acquire_focus(sm->handle, focus_type, NULL);
-		if (ret != MM_ERROR_NONE)
-		{
+		if (ret != MM_ERROR_NONE) {
 			MMRADIO_LOG_ERROR("mm_sound_acquire_focus is failed\n");
 			return MM_ERROR_POLICY_BLOCKED;
 		}
 		sm->cur_focus_type = FOCUS_FOR_BOTH;
 	}
 
-
 	MMRADIO_LOG_FLEAVE();
-	return ret ;
+	return ret;
 }
 
-int mmradio_release_audio_focus(MMRadioAudioFocus* sm)
+int mmradio_release_audio_focus(MMRadioAudioFocus *sm)
 {
 	int ret = MM_ERROR_NONE;
 	MMRADIO_LOG_FENTER();
 
 	MMRADIO_LOG_ERROR("mmradio_release_audio_focus sm->cur_focus_type : %d\n", sm->cur_focus_type);
-	if (sm->cur_focus_type != FOCUS_NONE)
-	{
+	if (sm->cur_focus_type != FOCUS_NONE) {
 		ret = mm_sound_release_focus(sm->handle, sm->cur_focus_type, NULL);
-		if(ret != MM_ERROR_NONE)
-		{
+		if (ret != MM_ERROR_NONE) {
 			MMRADIO_LOG_ERROR("mm_sound_release_focus is failed\n");
 			return MM_ERROR_POLICY_BLOCKED;
 		}
@@ -146,7 +132,7 @@ int mmradio_release_audio_focus(MMRadioAudioFocus* sm)
 	}
 
 	MMRADIO_LOG_FLEAVE();
-	return ret ;
+	return ret;
 }
 
 #define AUDIO_FOCUS_REASON_MAX	128
@@ -156,49 +142,38 @@ void mmradio_get_audio_focus_reason(mm_sound_focus_state_e focus_state, const ch
 	MMRADIO_LOG_FENTER();
 	MMRADIO_LOG_ERROR("mmradio_get_audio_focus_reason focus_state : %d reason_for_change :%s\n", focus_state, reason_for_change);
 
-	if(0 == strncmp(reason_for_change, "call-voice", AUDIO_FOCUS_REASON_MAX)
+	if (0 == strncmp(reason_for_change, "call-voice", AUDIO_FOCUS_REASON_MAX)
 		|| (0 == strncmp(reason_for_change, "voip", AUDIO_FOCUS_REASON_MAX))
 		|| (0 == strncmp(reason_for_change, "ringtone-voip", AUDIO_FOCUS_REASON_MAX))
 		|| (0 == strncmp(reason_for_change, "ringtone-call", AUDIO_FOCUS_REASON_MAX))
-		)
-	{
-		if(focus_state == FOCUS_IS_RELEASED)
+		) {
+		if (focus_state == FOCUS_IS_RELEASED)
 			*event_source = MM_MSG_CODE_INTERRUPTED_BY_CALL_START;
-		else if(focus_state == FOCUS_IS_ACQUIRED)
+		else if (focus_state == FOCUS_IS_ACQUIRED)
 			*event_source = MM_MSG_CODE_INTERRUPTED_BY_CALL_END;
 		*postMsg = true;
-	}
-	else if(0 == strncmp(reason_for_change, "alarm", AUDIO_FOCUS_REASON_MAX))
-	{
-		if(focus_state == FOCUS_IS_RELEASED)
+	} else if (0 == strncmp(reason_for_change, "alarm", AUDIO_FOCUS_REASON_MAX)) {
+		if (focus_state == FOCUS_IS_RELEASED)
 			*event_source = MM_MSG_CODE_INTERRUPTED_BY_ALARM_START;
-		else if(focus_state == FOCUS_IS_ACQUIRED)
+		else if (focus_state == FOCUS_IS_ACQUIRED)
 			*event_source = MM_MSG_CODE_INTERRUPTED_BY_ALARM_END;
 		*postMsg = true;
-	}
-	else if(0 == strncmp(reason_for_change, "notification", AUDIO_FOCUS_REASON_MAX))
-	{
-		if(focus_state == FOCUS_IS_RELEASED)
+	} else if (0 == strncmp(reason_for_change, "notification", AUDIO_FOCUS_REASON_MAX)) {
+		if (focus_state == FOCUS_IS_RELEASED)
 			*event_source = MM_MSG_CODE_INTERRUPTED_BY_NOTIFICATION_START;
-		else if(focus_state == FOCUS_IS_ACQUIRED)
+		else if (focus_state == FOCUS_IS_ACQUIRED)
 			*event_source = MM_MSG_CODE_INTERRUPTED_BY_NOTIFICATION_END;
 		*postMsg = true;
-	}
-	else if(0 == strncmp(reason_for_change, "emergency", AUDIO_FOCUS_REASON_MAX))
-	{
-		if(focus_state == FOCUS_IS_RELEASED)
+	} else if (0 == strncmp(reason_for_change, "emergency", AUDIO_FOCUS_REASON_MAX)) {
+		if (focus_state == FOCUS_IS_RELEASED)
 			*event_source = MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_START;
-		else if(focus_state == FOCUS_IS_ACQUIRED)
+		else if (focus_state == FOCUS_IS_ACQUIRED)
 			*event_source = MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_END;
 		*postMsg = false;
-	}
-	else if(0 == strncmp(reason_for_change, "media", AUDIO_FOCUS_REASON_MAX))
-	{
+	} else if (0 == strncmp(reason_for_change, "media", AUDIO_FOCUS_REASON_MAX)) {
 		*event_source = MM_MSG_CODE_INTERRUPTED_BY_MEDIA;
 		*postMsg = false;
-	}
-	else
-	{
+	} else {
 		*event_source = MM_MSG_CODE_INTERRUPTED_BY_MEDIA;
 		*postMsg = false;
 	}
diff --git a/src/mm_radio_priv.c b/src/mm_radio_priv.c
index 7596e3f..b2fc1d2 100755
--- a/src/mm_radio_priv.c
+++ b/src/mm_radio_priv.c
@@ -22,7 +22,7 @@
 /*===========================================================================================
 |																							|
 |  INCLUDE FILES																			|
-|  																							|
+|																							|
 ========================================================================================== */
 #include <stdbool.h>
 #include <stdio.h>
@@ -70,10 +70,11 @@
 #define FREQ_FRAC				16
 #define RADIO_FREQ_FORMAT_SET(x_freq)		((x_freq) * FREQ_FRAC)
 #define RADIO_FREQ_FORMAT_GET(x_freq)		((x_freq) / FREQ_FRAC)
-#define DEFAULT_WRAP_AROUND 			1 //If non-zero, wrap around when at the end of the frequency range, else stop seeking
+/* If non-zero, wrap around when at the end of the frequency range, else stop seeking */
+#define DEFAULT_WRAP_AROUND		1
 
-#define RADIO_DEFAULT_REGION			MM_RADIO_REGION_GROUP_USA
-#define READ_MAX_BUFFER_SIZE 1024
+#define RADIO_DEFAULT_REGION	MM_RADIO_REGION_GROUP_USA
+#define READ_MAX_BUFFER_SIZE	1024
 /*---------------------------------------------------------------------------
     LOCAL CONSTANT DEFINITIONS:
 ---------------------------------------------------------------------------*/
@@ -91,45 +92,45 @@ extern int errno;
     LOCAL VARIABLE DEFINITIONS:
 ---------------------------------------------------------------------------*/
 /* radio region configuration table */
-static const MMRadioRegion_t region_table[] =
-{
-		{	/* Notrh America, South America, South Korea, Taiwan, Australia */
-			MM_RADIO_REGION_GROUP_USA,	// region type
-			MM_RADIO_DEEMPHASIS_75_US,	// de-emphasis
-			MM_RADIO_FREQ_MIN_87500_KHZ, 	// min freq.
-			MM_RADIO_FREQ_MAX_108000_KHZ,	// max freq.
-			50,
-		},
-		{	/* China, Europe, Africa, Middle East, Hong Kong, India, Indonesia, Russia, Singapore */
-			MM_RADIO_REGION_GROUP_EUROPE,
-			MM_RADIO_DEEMPHASIS_50_US,
-			MM_RADIO_FREQ_MIN_87500_KHZ,
-			MM_RADIO_FREQ_MAX_108000_KHZ,
-			50,
-		},
-		{
-			MM_RADIO_REGION_GROUP_JAPAN,
-			MM_RADIO_DEEMPHASIS_50_US,
-			MM_RADIO_FREQ_MIN_76100_KHZ,
-			MM_RADIO_FREQ_MAX_89900_KHZ,
-			50,
-		},
+static const MMRadioRegion_t region_table[] = {
+	{							/* Notrh America, South America, South Korea, Taiwan, Australia */
+	 MM_RADIO_REGION_GROUP_USA,	/* region type */
+	 MM_RADIO_DEEMPHASIS_75_US,	/* de-emphasis */
+	 MM_RADIO_FREQ_MIN_87500_KHZ,	/* min freq. */
+	 MM_RADIO_FREQ_MAX_108000_KHZ,	/* max freq. */
+	 50,
+	 },
+	{							/* China, Europe, Africa, Middle East, Hong Kong, India, Indonesia, Russia, Singapore */
+	 MM_RADIO_REGION_GROUP_EUROPE,
+	 MM_RADIO_DEEMPHASIS_50_US,
+	 MM_RADIO_FREQ_MIN_87500_KHZ,
+	 MM_RADIO_FREQ_MAX_108000_KHZ,
+	 50,
+	 },
+	{
+	 MM_RADIO_REGION_GROUP_JAPAN,
+	 MM_RADIO_DEEMPHASIS_50_US,
+	 MM_RADIO_FREQ_MIN_76100_KHZ,
+	 MM_RADIO_FREQ_MAX_89900_KHZ,
+	 50,
+	 },
 };
+
 /*---------------------------------------------------------------------------
     LOCAL FUNCTION PROTOTYPES:
 ---------------------------------------------------------------------------*/
-static bool	__mmradio_post_message(mm_radio_t* radio, enum MMMessageType msgtype, MMMessageParamType* param);
-static int  		__mmradio_check_state(mm_radio_t* radio, MMRadioCommand command);
-static int		__mmradio_get_state(mm_radio_t* radio);
-static bool	__mmradio_set_state(mm_radio_t* radio, int new_state);
-static void 	__mmradio_seek_thread(mm_radio_t* radio);
-static void	__mmradio_scan_thread(mm_radio_t* radio);
-static bool 	__is_tunable_frequency(mm_radio_t* radio, int freq);
-static int 		__mmradio_set_deemphasis(mm_radio_t* radio);
-static int 		__mmradio_set_band_range(mm_radio_t* radio);
+static bool __mmradio_post_message(mm_radio_t *radio, enum MMMessageType msgtype, MMMessageParamType *param);
+static int __mmradio_check_state(mm_radio_t *radio, MMRadioCommand command);
+static int __mmradio_get_state(mm_radio_t *radio);
+static bool __mmradio_set_state(mm_radio_t *radio, int new_state);
+static void __mmradio_seek_thread(mm_radio_t *radio);
+static void __mmradio_scan_thread(mm_radio_t *radio);
+static bool __is_tunable_frequency(mm_radio_t *radio, int freq);
+static int __mmradio_set_deemphasis(mm_radio_t *radio);
+static int __mmradio_set_band_range(mm_radio_t *radio);
 static void __mmradio_sound_focus_cb(int id, mm_sound_focus_type_e focus_type,
-                             mm_sound_focus_state_e focus_state, const char *reason_for_change,
-                             const char *additional_info, void *user_data);
+	mm_sound_focus_state_e focus_state, const char *reason_for_change,
+	const char *additional_info, void *user_data);
 static void __mmradio_device_connected_cb(MMSoundDevice_t device, bool is_connected, void *user_data);
 
 /*===========================================================================
@@ -139,13 +140,12 @@ static void __mmradio_device_connected_cb(MMSoundDevice_t device, bool is_connec
  * Name   : _mmradio_apply_region()
  * Desc   : update radio region information and set values to device
  * Param  :
- *	    [in] radio : radio handle
- * 	    [in] region : region type
- *          [in] update : update region values or not
+ *		[in] radio : radio handle
+ *		[in] region : region type
+ *		[in] update : update region values or not
  * Return : zero on success, or negative value with error code
  *---------------------------------------------------------------------------*/
-int
-_mmradio_apply_region(mm_radio_t* radio, MMRadioRegionType region, bool update)
+int _mmradio_apply_region(mm_radio_t *radio, MMRadioRegionType region, bool update)
 {
 	int ret = MM_ERROR_NONE;
 	int count = 0;
@@ -153,24 +153,21 @@ _mmradio_apply_region(mm_radio_t* radio, MMRadioRegionType region, bool update)
 
 	MMRADIO_LOG_FENTER();
 
-	MMRADIO_CHECK_INSTANCE( radio );
-	MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_SET_REGION );
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_SET_REGION);
 
 	/* if needed, radio region must be updated.
-	  * Otherwise, just applying settings to device without it.
-	  */
-	if ( update )
-	{
+	 * Otherwise, just applying settings to device without it.
+	 */
+	if (update) {
 		count = ARRAY_SIZE(region_table);
 
-		//TODO: if auto is supported...get the region info. here
+		/* TODO: if auto is supported...get the region info. here */
 
 		/* update radio region settings */
-		for ( index = 0; index < count; index++ )
-		{
-			/* find the region from pre-defined table*/
-			if (region_table[index].country == region)
-			{
+		for (index = 0; index < count; index++) {
+			/* find the region from pre-defined table */
+			if (region_table[index].country == region) {
 				radio->region_setting.country = region_table[index].country;
 				radio->region_setting.deemphasis = region_table[index].deemphasis;
 				radio->region_setting.band_min = region_table[index].band_min;
@@ -180,15 +177,15 @@ _mmradio_apply_region(mm_radio_t* radio, MMRadioRegionType region, bool update)
 		}
 	}
 
-	/* chech device is opened or not. if it's not ready, skip to apply region to device now*/
-	if (radio->radio_fd < 0)
-	{
+	/* chech device is opened or not. if it's not ready, skip to apply region to device now */
+	if (radio->radio_fd < 0) {
 		MMRADIO_LOG_DEBUG("not opened device. just updating region info. \n");
 		return MM_ERROR_NONE;
 	}
 
 	MMRADIO_LOG_DEBUG("setting region - country: %d, de-emphasis: %d, band range: %d ~ %d KHz\n",
-		radio->region_setting.country, radio->region_setting.deemphasis, radio->region_setting.band_min, radio->region_setting.band_max);
+		radio->region_setting.country, radio->region_setting.deemphasis,
+		radio->region_setting.band_min, radio->region_setting.band_max);
 
 	/* set de-emphsasis to device */
 	ret = __mmradio_set_deemphasis(radio);
@@ -196,7 +193,7 @@ _mmradio_apply_region(mm_radio_t* radio, MMRadioRegionType region, bool update)
 	MMRADIO_CHECK_RETURN_IF_FAIL(ret, "set de-emphasis");
 
 	/* set band range to device */
-	ret  = __mmradio_set_band_range(radio);
+	ret = __mmradio_set_band_range(radio);
 
 	MMRADIO_CHECK_RETURN_IF_FAIL(ret, "set band range");
 
@@ -205,15 +202,14 @@ _mmradio_apply_region(mm_radio_t* radio, MMRadioRegionType region, bool update)
 	return ret;
 }
 
-int
-_mmradio_create_radio(mm_radio_t* radio)
+int _mmradio_create_radio(mm_radio_t *radio)
 {
-	int ret  = 0;
+	int ret = 0;
 
 	MMRADIO_LOG_FENTER();
 
-	MMRADIO_CHECK_INSTANCE( radio );
-	MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_CREATE );
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_CREATE);
 
 	/* set default value */
 	radio->radio_fd = -1;
@@ -222,29 +218,26 @@ _mmradio_create_radio(mm_radio_t* radio)
 	radio->subs_id = 0;
 
 	/* create command lock */
-	ret = pthread_mutex_init( &radio->cmd_lock, NULL );
-	if ( ret )
-	{
+	ret = pthread_mutex_init(&radio->cmd_lock, NULL);
+	if (ret) {
 		MMRADIO_LOG_ERROR("mutex creation failed\n");
 		return MM_ERROR_RADIO_INTERNAL;
 	}
 
-	MMRADIO_SET_STATE( radio, MM_RADIO_STATE_NULL );
+	MMRADIO_SET_STATE(radio, MM_RADIO_STATE_NULL);
 
 	/* add device conneted callback */
 	ret = mm_sound_add_device_connected_callback(MM_SOUND_DEVICE_STATE_ACTIVATED_FLAG,
-                                                (mm_sound_device_connected_cb)__mmradio_device_connected_cb,
-                                                (void *)radio, &radio->subs_id);
-	if ( ret )
-	{
+		(mm_sound_device_connected_cb)__mmradio_device_connected_cb,
+		(void *)radio, &radio->subs_id);
+	if (ret) {
 		MMRADIO_LOG_ERROR("mm_sound_add_device_connected_callback is failed\n");
 		return MM_ERROR_RADIO_INTERNAL;
 	}
 
 	/* register to audio focus */
 	ret = mmradio_audio_focus_register(&radio->sm, __mmradio_sound_focus_cb, (void *)radio);
-	if ( ret )
-	{
+	if (ret) {
 		/* NOTE : we are dealing it as an error since we cannot expect it's behavior */
 		MMRADIO_LOG_ERROR("mmradio_audio_focus_register is failed\n");
 		return MM_ERROR_RADIO_INTERNAL;
@@ -255,52 +248,46 @@ _mmradio_create_radio(mm_radio_t* radio)
 	return MM_ERROR_NONE;
 }
 
-int
-_mmradio_realize(mm_radio_t* radio)
+int _mmradio_realize(mm_radio_t *radio)
 {
 	int ret = MM_ERROR_NONE;
 	char str_error[READ_MAX_BUFFER_SIZE];
 
 	MMRADIO_LOG_FENTER();
 
-	MMRADIO_CHECK_INSTANCE( radio );
-	MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_REALIZE );
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_REALIZE);
 
 	/* open radio device */
-	if(radio->radio_fd == -1)
-	{
+	if (radio->radio_fd == -1) {
 		MMRadioRegionType region = MM_RADIO_REGION_GROUP_NONE;
 		bool update = false;
 
 		/* open device */
 		radio->radio_fd = open(DEFAULT_DEVICE, O_RDONLY);
-		if (radio->radio_fd < 0)
-		{
+		if (radio->radio_fd < 0) {
 			MMRADIO_LOG_ERROR("failed to open radio device[%s] because of %s(%d)\n",
-						DEFAULT_DEVICE, strerror_r(errno, str_error, sizeof(str_error)), errno);
+				DEFAULT_DEVICE, strerror_r(errno, str_error, sizeof(str_error)), errno);
 
 			/* check error */
-			switch (errno)
-			{
-				case ENOENT:
-					return MM_ERROR_RADIO_DEVICE_NOT_FOUND;
-				case EACCES:
-					return MM_ERROR_RADIO_PERMISSION_DENIED;
-				default:
-					return MM_ERROR_RADIO_DEVICE_NOT_OPENED;
+			switch (errno) {
+			case ENOENT:
+				return MM_ERROR_RADIO_DEVICE_NOT_FOUND;
+			case EACCES:
+				return MM_ERROR_RADIO_PERMISSION_DENIED;
+			default:
+				return MM_ERROR_RADIO_DEVICE_NOT_OPENED;
 			}
 		}
 		MMRADIO_LOG_DEBUG("radio device fd : %d\n", radio->radio_fd);
 
 		/* query radio device capabilities. */
-		if (ioctl(radio->radio_fd, VIDIOC_QUERYCAP, &(radio->vc)) < 0)
-		{
+		if (ioctl(radio->radio_fd, VIDIOC_QUERYCAP, &(radio->vc)) < 0) {
 			MMRADIO_LOG_ERROR("VIDIOC_QUERYCAP failed!\n");
 			goto error;
 		}
 
-		if ( ! ( radio->vc.capabilities & V4L2_CAP_TUNER) )
-		{
+		if (!(radio->vc.capabilities & V4L2_CAP_TUNER)) {
 			MMRADIO_LOG_ERROR("this system can't support fm-radio!\n");
 			goto error;
 		}
@@ -308,13 +295,10 @@ _mmradio_realize(mm_radio_t* radio)
 		/* set tuner audio mode */
 		ioctl(radio->radio_fd, VIDIOC_G_TUNER, &(radio->vt));
 
-		if ( ! ( (radio->vt).capability & V4L2_TUNER_CAP_STEREO) )
-		{
+		if (!((radio->vt).capability & V4L2_TUNER_CAP_STEREO)) {
 			MMRADIO_LOG_ERROR("this system can support mono!\n");
 			(radio->vt).audmode = V4L2_TUNER_MODE_MONO;
-		}
-		else
-		{
+		} else {
 			(radio->vt).audmode = V4L2_TUNER_MODE_STEREO;
 		}
 
@@ -323,14 +307,12 @@ _mmradio_realize(mm_radio_t* radio)
 		ioctl(radio->radio_fd, VIDIOC_S_TUNER, &(radio->vt));
 
 		/* check region country type if it's updated or not */
-		if ( radio->region_setting.country == MM_RADIO_REGION_GROUP_NONE)
-		{
+		if (radio->region_setting.country == MM_RADIO_REGION_GROUP_NONE) {
 			/* not initialized  yet. set it with default region */
 			region = RADIO_DEFAULT_REGION;
 			update = true;
-		}
-		else // already initialized by application
-		{
+		} else {
+			/* already initialized by application */
 			region = radio->region_setting.country;
 		}
 
@@ -340,13 +322,13 @@ _mmradio_realize(mm_radio_t* radio)
 	}
 
 	/* ready but nosound */
-	if( _mmradio_mute(radio) != MM_ERROR_NONE)
+	if (_mmradio_mute(radio) != MM_ERROR_NONE)
 		goto error;
 
-	MMRADIO_SET_STATE( radio, MM_RADIO_STATE_READY );
+	MMRADIO_SET_STATE(radio, MM_RADIO_STATE_READY);
 #ifdef USE_GST_PIPELINE
 	ret = _mmradio_realize_pipeline(radio);
-	if ( ret ) {
+	if (ret) {
 		debug_error("_mmradio_realize_pipeline is failed\n");
 		return ret;
 	}
@@ -356,8 +338,7 @@ _mmradio_realize(mm_radio_t* radio)
 	return MM_ERROR_NONE;
 
 error:
-	if (radio->radio_fd >= 0)
-	{
+	if (radio->radio_fd >= 0) {
 		close(radio->radio_fd);
 		radio->radio_fd = -1;
 	}
@@ -367,37 +348,34 @@ error:
 	return MM_ERROR_RADIO_INTERNAL;
 }
 
-int
-_mmradio_unrealize(mm_radio_t* radio)
+int _mmradio_unrealize(mm_radio_t *radio)
 {
 	int ret = MM_ERROR_NONE;
 
 	MMRADIO_LOG_FENTER();
 
-	MMRADIO_CHECK_INSTANCE( radio );
-	MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_UNREALIZE );
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_UNREALIZE);
 
-	if( _mmradio_mute(radio) != MM_ERROR_NONE)
+	if (_mmradio_mute(radio) != MM_ERROR_NONE)
 		return MM_ERROR_RADIO_NOT_INITIALIZED;
 
 	/* close radio device here !!!! */
-	if (radio->radio_fd >= 0)
-	{
+	if (radio->radio_fd >= 0) {
 		close(radio->radio_fd);
 		radio->radio_fd = -1;
 	}
 
-	MMRADIO_SET_STATE( radio, MM_RADIO_STATE_NULL );
+	MMRADIO_SET_STATE(radio, MM_RADIO_STATE_NULL);
 
 	ret = mmradio_release_audio_focus(&radio->sm);
-	if (ret)
-	{
+	if (ret) {
 		MMRADIO_LOG_ERROR("mmradio_release_audio_focus is failed\n");
 		return ret;
 	}
 #ifdef USE_GST_PIPELINE
-	ret= _mmradio_destroy_pipeline(radio);
-	if ( ret ) {
+	ret = _mmradio_destroy_pipeline(radio);
+	if (ret) {
 		debug_error("_mmradio_destroy_pipeline is failed\n");
 		return ret;
 	}
@@ -408,58 +386,51 @@ _mmradio_unrealize(mm_radio_t* radio)
 	return MM_ERROR_NONE;
 }
 
-int
-_mmradio_destroy(mm_radio_t* radio)
+int _mmradio_destroy(mm_radio_t *radio)
 {
 	int ret = 0;
 	MMRADIO_LOG_FENTER();
 
-	MMRADIO_CHECK_INSTANCE( radio );
-	MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_DESTROY );
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_DESTROY);
 
 	ret = mmradio_audio_focus_deregister(&radio->sm);
-	if ( ret )
-	{
+	if (ret) {
 		MMRADIO_LOG_ERROR("failed to deregister audio focus\n");
 		return MM_ERROR_RADIO_INTERNAL;
 	}
 
 	ret = mm_sound_remove_device_connected_callback(radio->subs_id);
-	if ( ret )
-	{
+	if (ret) {
 		MMRADIO_LOG_ERROR("mm_sound_remove_device_connected_callback error %d\n", ret);
 		return MM_ERROR_RADIO_INTERNAL;
 	}
-	_mmradio_unrealize( radio );
+	_mmradio_unrealize(radio);
 
 	MMRADIO_LOG_FLEAVE();
 
 	return MM_ERROR_NONE;
 }
 
-
-int
-_mmradio_set_frequency(mm_radio_t* radio, int freq) // unit should be KHz
+/* unit should be KHz */
+int _mmradio_set_frequency(mm_radio_t *radio, int freq)
 {
 	MMRADIO_LOG_FENTER();
 
-	MMRADIO_CHECK_INSTANCE( radio );
-	MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_SET_FREQ );
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_SET_FREQ);
 
 	MMRADIO_LOG_DEBUG("Setting %d frequency\n", freq);
 
 	radio->freq = freq;
 
-	if (radio->radio_fd < 0)
-	{
+	if (radio->radio_fd < 0) {
 		MMRADIO_LOG_DEBUG("radio device is not opened yet\n");
 		return MM_ERROR_NONE;
 	}
 
 	/* check frequency range */
-	if ( freq < radio->region_setting.band_min
-		|| freq > radio->region_setting.band_max )
-	{
+	if (freq < radio->region_setting.band_min || freq > radio->region_setting.band_max) {
 		MMRADIO_LOG_ERROR("out of frequency range\n", freq);
 		return MM_ERROR_INVALID_ARGUMENT;
 	}
@@ -468,10 +439,8 @@ _mmradio_set_frequency(mm_radio_t* radio, int freq) // unit should be KHz
 	(radio->vf).tuner = 0;
 	(radio->vf).frequency = RADIO_FREQ_FORMAT_SET(freq);
 
-	if(ioctl(radio->radio_fd, VIDIOC_S_FREQUENCY, &(radio->vf))< 0)
-	{
+	if (ioctl(radio->radio_fd, VIDIOC_S_FREQUENCY, &(radio->vf)) < 0)
 		return MM_ERROR_RADIO_NOT_INITIALIZED;
-	}
 
 	MMRADIO_LOG_FLEAVE();
 
@@ -479,27 +448,24 @@ _mmradio_set_frequency(mm_radio_t* radio, int freq) // unit should be KHz
 
 }
 
-int
-_mmradio_get_frequency(mm_radio_t* radio, int* pFreq)
+int _mmradio_get_frequency(mm_radio_t *radio, int *pFreq)
 {
 	int freq = 0;
 	MMRADIO_LOG_FENTER();
 
-	MMRADIO_CHECK_INSTANCE( radio );
-	MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_GET_FREQ );
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_GET_FREQ);
 
-	return_val_if_fail( pFreq, MM_ERROR_INVALID_ARGUMENT );
+	return_val_if_fail(pFreq, MM_ERROR_INVALID_ARGUMENT);
 
 	/* just return stored frequency if radio device is not ready */
-	if ( radio->radio_fd < 0 )
-	{
+	if (radio->radio_fd < 0) {
 		MMRADIO_LOG_DEBUG("freq : %d\n", radio->freq);
 		*pFreq = radio->freq;
 		return MM_ERROR_NONE;
 	}
 
-	if (ioctl(radio->radio_fd, VIDIOC_G_FREQUENCY, &(radio->vf)) < 0)
-	{
+	if (ioctl(radio->radio_fd, VIDIOC_G_FREQUENCY, &(radio->vf)) < 0) {
 		MMRADIO_LOG_ERROR("failed to do VIDIOC_G_FREQUENCY\n");
 		return MM_ERROR_RADIO_INTERNAL;
 	}
@@ -516,26 +482,22 @@ _mmradio_get_frequency(mm_radio_t* radio, int* pFreq)
 	return MM_ERROR_NONE;
 }
 
-int
-_mmradio_mute(mm_radio_t* radio)
+int _mmradio_mute(mm_radio_t *radio)
 {
 	MMRADIO_LOG_FENTER();
 
-	MMRADIO_CHECK_INSTANCE( radio );
-	MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_MUTE );
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_MUTE);
 
 	if (radio->radio_fd < 0)
-	{
 		return MM_ERROR_RADIO_NOT_INITIALIZED;
-	}
 
 	(radio->vctrl).id = V4L2_CID_AUDIO_MUTE;
-	(radio->vctrl).value = 1; //mute
+	/* mute */
+	(radio->vctrl).value = 1;
 
 	if (ioctl(radio->radio_fd, VIDIOC_S_CTRL, &(radio->vctrl)) < 0)
-	{
 		return MM_ERROR_RADIO_NOT_INITIALIZED;
-	}
 
 	MMRADIO_LOG_FLEAVE();
 
@@ -543,22 +505,20 @@ _mmradio_mute(mm_radio_t* radio)
 
 }
 
-int
-_mmradio_unmute(mm_radio_t* radio)
+int _mmradio_unmute(mm_radio_t *radio)
 {
 	MMRADIO_LOG_FENTER();
 
-	MMRADIO_CHECK_INSTANCE( radio );
-	MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_UNMUTE );
-	MMRADIO_CHECK_DEVICE_STATE( radio );
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_UNMUTE);
+	MMRADIO_CHECK_DEVICE_STATE(radio);
 
 	(radio->vctrl).id = V4L2_CID_AUDIO_MUTE;
-	(radio->vctrl).value = 0; //unmute
+	/* unmute */
+	(radio->vctrl).value = 0;
 
 	if (ioctl(radio->radio_fd, VIDIOC_S_CTRL, &(radio->vctrl)) < 0)
-	{
 		return MM_ERROR_RADIO_NOT_INITIALIZED;
-	}
 
 	MMRADIO_LOG_FLEAVE();
 
@@ -572,37 +532,37 @@ _mmradio_unmute(mm_radio_t* radio)
  *	    [in] radio : radio handle
  * Return : zero on success, or negative value with error code
  *---------------------------------------------------------------------------*/
-int
-__mmradio_set_deemphasis(mm_radio_t* radio)
+int __mmradio_set_deemphasis(mm_radio_t *radio)
 {
 	int value = 0;
 
 	MMRADIO_LOG_FENTER();
 
-	MMRADIO_CHECK_INSTANCE( radio );
+	MMRADIO_CHECK_INSTANCE(radio);
 
 	/* get de-emphasis */
-	switch (radio->region_setting.deemphasis)
-	{
-		case MM_RADIO_DEEMPHASIS_50_US:
-			value = 1;//V4L2_DEEMPHASIS_50_uS;
-			break;
+	switch (radio->region_setting.deemphasis) {
+	case MM_RADIO_DEEMPHASIS_50_US:
+		/* V4L2_DEEMPHASIS_50_uS; */
+		value = 1;
+		break;
 
-		case MM_RADIO_DEEMPHASIS_75_US:
-			value = 2;//V4L2_DEEMPHASIS_75_uS;
-			break;
+	case MM_RADIO_DEEMPHASIS_75_US:
+		/* V4L2_DEEMPHASIS_75_uS; */
+		value = 2;
+		break;
 
-		default:
-			MMRADIO_LOG_ERROR("not availabe de-emphasis value\n");
-			return MM_ERROR_COMMON_INVALID_ARGUMENT;
+	default:
+		MMRADIO_LOG_ERROR("not availabe de-emphasis value\n");
+		return MM_ERROR_COMMON_INVALID_ARGUMENT;
 	}
 
 	/* set it to device */
-	(radio->vctrl).id = (0x009d0000 | 0x900) +1;//V4L2_CID_TUNE_DEEMPHASIS;
+	/* V4L2_CID_TUNE_DEEMPHASIS; */
+	(radio->vctrl).id = (0x009d0000 | 0x900) + 1;
 	(radio->vctrl).value = value;
 
-	if (ioctl(radio->radio_fd, VIDIOC_S_CTRL, &(radio->vctrl)) < 0)
-	{
+	if (ioctl(radio->radio_fd, VIDIOC_S_CTRL, &(radio->vctrl)) < 0) {
 		MMRADIO_LOG_ERROR("failed to set de-emphasis\n");
 		return MM_ERROR_RADIO_INTERNAL;
 	}
@@ -619,20 +579,18 @@ __mmradio_set_deemphasis(mm_radio_t* radio)
  *	    [in] radio : radio handle
  * Return : zero on success, or negative value with error code
  *---------------------------------------------------------------------------*/
-int
-__mmradio_set_band_range(mm_radio_t* radio)
+int __mmradio_set_band_range(mm_radio_t *radio)
 {
 	MMRADIO_LOG_FENTER();
 
-	MMRADIO_CHECK_INSTANCE( radio );
+	MMRADIO_CHECK_INSTANCE(radio);
 
 	/* get min and max freq. */
 	(radio->vt).rangelow = RADIO_FREQ_FORMAT_SET(radio->region_setting.band_min);
 	(radio->vt).rangehigh = RADIO_FREQ_FORMAT_SET(radio->region_setting.band_max);
 
 	/* set it to device */
-	if (ioctl(radio->radio_fd, VIDIOC_S_TUNER, &(radio->vt)) < 0 )
-	{
+	if (ioctl(radio->radio_fd, VIDIOC_S_TUNER, &(radio->vt)) < 0) {
 		MMRADIO_LOG_ERROR("failed to set band range\n");
 		return MM_ERROR_RADIO_INTERNAL;
 	}
@@ -642,34 +600,33 @@ __mmradio_set_band_range(mm_radio_t* radio)
 	return MM_ERROR_NONE;
 }
 
-int
-_mmradio_set_message_callback(mm_radio_t* radio, MMMessageCallback callback, void *user_param)
+int _mmradio_set_message_callback(mm_radio_t *radio, MMMessageCallback callback, void *user_param)
 {
 	MMRADIO_LOG_FENTER();
 
-	MMRADIO_CHECK_INSTANCE( radio );
+	MMRADIO_CHECK_INSTANCE(radio);
 
 	radio->msg_cb = callback;
 	radio->msg_cb_param = user_param;
 
-	MMRADIO_LOG_DEBUG("msg_cb : 0x%x msg_cb_param : 0x%x\n", (unsigned int)callback, (unsigned int)user_param);
+	MMRADIO_LOG_DEBUG("msg_cb : 0x%x msg_cb_param : 0x%x\n",
+		(unsigned int)callback, (unsigned int)user_param);
 
 	MMRADIO_LOG_FLEAVE();
 
 	return MM_ERROR_NONE;
 }
 
-int
-_mmradio_get_state(mm_radio_t* radio, int* pState)
+int _mmradio_get_state(mm_radio_t *radio, int *pState)
 {
 	int state = 0;
 
 	MMRADIO_LOG_FENTER();
 
-	MMRADIO_CHECK_INSTANCE( radio );
-	return_val_if_fail( pState, MM_ERROR_INVALID_ARGUMENT );
+	MMRADIO_CHECK_INSTANCE(radio);
+	return_val_if_fail(pState, MM_ERROR_INVALID_ARGUMENT);
 
-	state = __mmradio_get_state( radio );
+	state = __mmradio_get_state(radio);
 
 	*pState = state;
 
@@ -678,36 +635,34 @@ _mmradio_get_state(mm_radio_t* radio, int* pState)
 	return MM_ERROR_NONE;
 }
 
-int
-_mmradio_start(mm_radio_t* radio)
+int _mmradio_start(mm_radio_t *radio)
 {
 	int ret = MM_ERROR_NONE;
 
 	MMRADIO_LOG_FENTER();
 
-	MMRADIO_CHECK_INSTANCE( radio );
-	MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_START );
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_START);
 
 	MMRADIO_LOG_DEBUG("now tune to frequency : %d\n", radio->freq);
 
 	ret = mmradio_acquire_audio_focus(&radio->sm);
-	if ( ret )
-	{
+	if (ret) {
 		MMRADIO_LOG_ERROR("failed to set audio focus\n");
 		return ret;
 	}
 
 	/* set stored frequency */
-	_mmradio_set_frequency( radio, radio->freq );
+	_mmradio_set_frequency(radio, radio->freq);
 
 	/* unmute */
-	if( _mmradio_unmute(radio) != MM_ERROR_NONE)
+	if (_mmradio_unmute(radio) != MM_ERROR_NONE)
 		return MM_ERROR_RADIO_NOT_INITIALIZED;
 
-	MMRADIO_SET_STATE( radio, MM_RADIO_STATE_PLAYING );
+	MMRADIO_SET_STATE(radio, MM_RADIO_STATE_PLAYING);
 #ifdef USE_GST_PIPELINE
-	ret = _mmradio_start_pipeline( radio );
-	if ( ret ) {
+	ret = _mmradio_start_pipeline(radio);
+	if (ret) {
 		debug_error("_mmradio_start_pipeline is failed\n");
 		return ret;
 	}
@@ -718,24 +673,23 @@ _mmradio_start(mm_radio_t* radio)
 	return ret;
 }
 
-int
-_mmradio_stop(mm_radio_t* radio)
+int _mmradio_stop(mm_radio_t *radio)
 {
 	int ret = MM_ERROR_NONE;
 
 	MMRADIO_LOG_FENTER();
 
-	MMRADIO_CHECK_INSTANCE( radio );
-	MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_STOP );
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_STOP);
 
-	if( _mmradio_mute(radio) != MM_ERROR_NONE)
+	if (_mmradio_mute(radio) != MM_ERROR_NONE)
 		return MM_ERROR_RADIO_NOT_INITIALIZED;
 
-	MMRADIO_SET_STATE( radio, MM_RADIO_STATE_READY );
+	MMRADIO_SET_STATE(radio, MM_RADIO_STATE_READY);
 
 #ifdef USE_GST_PIPELINE
-	ret= _mmradio_stop_pipeline( radio );
-	if ( ret ) {
+	ret = _mmradio_stop_pipeline(radio);
+	if (ret) {
 		debug_error("_mmradio_stop_pipeline is failed\n");
 		return ret;
 	}
@@ -747,63 +701,57 @@ _mmradio_stop(mm_radio_t* radio)
 }
 
 #ifdef USE_GST_PIPELINE
-int
-_mmradio_realize_pipeline(mm_radio_t* radio)
+int _mmradio_realize_pipeline(mm_radio_t *radio)
 {
 	int ret = MM_ERROR_NONE;
 
-	gst_init (NULL, NULL);
-	radio->pGstreamer_s = g_new0 (mm_radio_gstreamer_s, 1);
+	gst_init(NULL, NULL);
+	radio->pGstreamer_s = g_new0(mm_radio_gstreamer_s, 1);
 
-	radio->pGstreamer_s->pipeline= gst_pipeline_new ("fmradio");
+	radio->pGstreamer_s->pipeline = gst_pipeline_new("fmradio");
 
-	radio->pGstreamer_s->audiosrc= gst_element_factory_make("pulsesrc","fm audio src");
-	radio->pGstreamer_s->queue2= gst_element_factory_make("queue2","queue2");
-	radio->pGstreamer_s->audiosink= gst_element_factory_make("pulsesink","audio sink");
+	radio->pGstreamer_s->audiosrc = gst_element_factory_make("pulsesrc", "fm audio src");
+	radio->pGstreamer_s->queue2 = gst_element_factory_make("queue2", "queue2");
+	radio->pGstreamer_s->audiosink = gst_element_factory_make("pulsesink", "audio sink");
 
-//	g_object_set(radio->pGstreamer_s->audiosrc, "latency", 2, NULL);
+	/* g_object_set(radio->pGstreamer_s->audiosrc, "latency", 2, NULL); */
 	g_object_set(radio->pGstreamer_s->audiosink, "sync", false, NULL);
 
-	if (!radio->pGstreamer_s->pipeline || !radio->pGstreamer_s->audiosrc || !radio->pGstreamer_s->queue2 || !radio->pGstreamer_s->audiosink) {
+	if (!radio->pGstreamer_s->pipeline || !radio->pGstreamer_s->audiosrc ||
+		!radio->pGstreamer_s->queue2 || !radio->pGstreamer_s->audiosink) {
 		debug_error("[%s][%05d] One element could not be created. Exiting.\n", __func__, __LINE__);
 		return MM_ERROR_RADIO_NOT_INITIALIZED;
 	}
 
 	gst_bin_add_many(GST_BIN(radio->pGstreamer_s->pipeline),
-			radio->pGstreamer_s->audiosrc,
-			radio->pGstreamer_s->queue2,
-			radio->pGstreamer_s->audiosink,
-			NULL);
-	if(!gst_element_link_many(
-			radio->pGstreamer_s->audiosrc,
-			radio->pGstreamer_s->queue2,
-			radio->pGstreamer_s->audiosink,
-			NULL)) {
+		radio->pGstreamer_s->audiosrc, radio->pGstreamer_s->queue2,
+		radio->pGstreamer_s->audiosink, NULL);
+	if (!gst_element_link_many(radio->pGstreamer_s->audiosrc,
+		radio->pGstreamer_s->queue2, radio->pGstreamer_s->audiosink, NULL)) {
 		debug_error("[%s][%05d] Fail to link b/w appsrc and ffmpeg in rotate\n", __func__, __LINE__);
 		return MM_ERROR_RADIO_NOT_INITIALIZED;
 	}
 	return ret;
 }
 
-int
-_mmradio_start_pipeline(mm_radio_t* radio)
+int _mmradio_start_pipeline(mm_radio_t *radio)
 {
 	int ret = MM_ERROR_NONE;
 	GstStateChangeReturn ret_state;
 	debug_log("\n");
 
-	if(gst_element_set_state (radio->pGstreamer_s->pipeline, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE) {
+	if (gst_element_set_state(radio->pGstreamer_s->pipeline, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE) {
 		debug_error("Fail to change pipeline state");
-		gst_object_unref (radio->pGstreamer_s->pipeline);
-		g_free (radio->pGstreamer_s);
+		gst_object_unref(radio->pGstreamer_s->pipeline);
+		g_free(radio->pGstreamer_s);
 		return MM_ERROR_RADIO_INVALID_STATE;
 	}
 
-	ret_state = gst_element_get_state (radio->pGstreamer_s->pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
+	ret_state = gst_element_get_state(radio->pGstreamer_s->pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
 	if (ret_state == GST_STATE_CHANGE_FAILURE) {
 		debug_error("GST_STATE_CHANGE_FAILURE");
-		gst_object_unref (radio->pGstreamer_s->pipeline);
-		g_free (radio->pGstreamer_s);
+		gst_object_unref(radio->pGstreamer_s->pipeline);
+		g_free(radio->pGstreamer_s);
 		return MM_ERROR_RADIO_INVALID_STATE;
 	} else {
 		debug_log("[%s][%05d] GST_STATE_NULL ret_state = %d (GST_STATE_CHANGE_SUCCESS)\n", __func__, __LINE__, ret_state);
@@ -811,25 +759,24 @@ _mmradio_start_pipeline(mm_radio_t* radio)
 	return ret;
 }
 
-int
-_mmradio_stop_pipeline(mm_radio_t* radio)
+int _mmradio_stop_pipeline(mm_radio_t *radio)
 {
 	int ret = MM_ERROR_NONE;
 	GstStateChangeReturn ret_state;
 
 	debug_log("\n");
-	if(gst_element_set_state (radio->pGstreamer_s->pipeline, GST_STATE_READY) == GST_STATE_CHANGE_FAILURE) {
+	if (gst_element_set_state(radio->pGstreamer_s->pipeline, GST_STATE_READY) == GST_STATE_CHANGE_FAILURE) {
 		debug_error("Fail to change pipeline state");
-		gst_object_unref (radio->pGstreamer_s->pipeline);
-		g_free (radio->pGstreamer_s);
+		gst_object_unref(radio->pGstreamer_s->pipeline);
+		g_free(radio->pGstreamer_s);
 		return MM_ERROR_RADIO_INVALID_STATE;
 	}
 
-	ret_state = gst_element_get_state (radio->pGstreamer_s->pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
+	ret_state = gst_element_get_state(radio->pGstreamer_s->pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
 	if (ret_state == GST_STATE_CHANGE_FAILURE) {
 		debug_error("GST_STATE_CHANGE_FAILURE");
-		gst_object_unref (radio->pGstreamer_s->pipeline);
-		g_free (radio->pGstreamer_s);
+		gst_object_unref(radio->pGstreamer_s->pipeline);
+		g_free(radio->pGstreamer_s);
 		return MM_ERROR_RADIO_INVALID_STATE;
 	} else {
 		debug_log("[%s][%05d] GST_STATE_NULL ret_state = %d (GST_STATE_CHANGE_SUCCESS)\n", __func__, __LINE__, ret_state);
@@ -837,56 +784,52 @@ _mmradio_stop_pipeline(mm_radio_t* radio)
 	return ret;
 }
 
-int
-_mmradio_destroy_pipeline(mm_radio_t * radio)
+int _mmradio_destroy_pipeline(mm_radio_t *radio)
 {
 	int ret = 0;
 	GstStateChangeReturn ret_state;
 	debug_log("\n");
 
-	if(gst_element_set_state (radio->pGstreamer_s->pipeline, GST_STATE_NULL) == GST_STATE_CHANGE_FAILURE) {
+	if (gst_element_set_state(radio->pGstreamer_s->pipeline, GST_STATE_NULL) == GST_STATE_CHANGE_FAILURE) {
 		debug_error("Fail to change pipeline state");
-		gst_object_unref (radio->pGstreamer_s->pipeline);
-		g_free (radio->pGstreamer_s);
+		gst_object_unref(radio->pGstreamer_s->pipeline);
+		g_free(radio->pGstreamer_s);
 		return MM_ERROR_RADIO_INVALID_STATE;
 	}
 
-	ret_state = gst_element_get_state (radio->pGstreamer_s->pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
+	ret_state = gst_element_get_state(radio->pGstreamer_s->pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
 	if (ret_state == GST_STATE_CHANGE_FAILURE) {
 		debug_error("GST_STATE_CHANGE_FAILURE");
-		gst_object_unref (radio->pGstreamer_s->pipeline);
-		g_free (radio->pGstreamer_s);
+		gst_object_unref(radio->pGstreamer_s->pipeline);
+		g_free(radio->pGstreamer_s);
 		return MM_ERROR_RADIO_INVALID_STATE;
 	} else {
 		debug_log("[%s][%05d] GST_STATE_NULL ret_state = %d (GST_STATE_CHANGE_SUCCESS)\n", __func__, __LINE__, ret_state);
 	}
-	gst_object_unref (radio->pGstreamer_s->pipeline);
-	g_free (radio->pGstreamer_s);
+	gst_object_unref(radio->pGstreamer_s->pipeline);
+	g_free(radio->pGstreamer_s);
 	return ret;
 }
 #endif
 
-int
-_mmradio_seek(mm_radio_t* radio, MMRadioSeekDirectionType direction)
+int _mmradio_seek(mm_radio_t *radio, MMRadioSeekDirectionType direction)
 {
 	MMRADIO_LOG_FENTER();
 
-	MMRADIO_CHECK_INSTANCE( radio );
-	MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_SEEK );
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_SEEK);
 
- 	int ret = 0;
+	int ret = 0;
 
-	if( _mmradio_mute(radio) != MM_ERROR_NONE)
+	if (_mmradio_mute(radio) != MM_ERROR_NONE)
 		return MM_ERROR_RADIO_NOT_INITIALIZED;
 
 	MMRADIO_LOG_DEBUG("trying to seek. direction[0:UP/1:DOWN) %d\n", direction);
 	radio->seek_direction = direction;
 
-	ret = pthread_create(&radio->seek_thread, NULL,
-		(void *)__mmradio_seek_thread, (void *)radio);
+	ret = pthread_create(&radio->seek_thread, NULL, (void *)__mmradio_seek_thread, (void *)radio);
 
-	if ( ret )
-	{
+	if (ret) {
 		MMRADIO_LOG_DEBUG("failed create thread\n");
 		return MM_ERROR_RADIO_INTERNAL;
 	}
@@ -896,52 +839,47 @@ _mmradio_seek(mm_radio_t* radio, MMRadioSeekDirectionType direction)
 	return MM_ERROR_NONE;
 }
 
-int
-_mmradio_start_scan(mm_radio_t* radio)
+int _mmradio_start_scan(mm_radio_t *radio)
 {
 	MMRADIO_LOG_FENTER();
 
-	MMRADIO_CHECK_INSTANCE( radio );
-	MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_START_SCAN );
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_START_SCAN);
 
 	int scan_tr_id = 0;
 
 	radio->stop_scan = false;
 
-	scan_tr_id = pthread_create(&radio->scan_thread, NULL,
-		(void *)__mmradio_scan_thread, (void *)radio);
+	scan_tr_id = pthread_create(&radio->scan_thread, NULL, (void *)__mmradio_scan_thread, (void *)radio);
 
-	if (scan_tr_id != 0)
-	{
+	if (scan_tr_id != 0) {
 		MMRADIO_LOG_DEBUG("failed to create thread : scan\n");
 		return MM_ERROR_RADIO_NOT_INITIALIZED;
 	}
 
-	MMRADIO_SET_STATE( radio, MM_RADIO_STATE_SCANNING );
+	MMRADIO_SET_STATE(radio, MM_RADIO_STATE_SCANNING);
 
 	MMRADIO_LOG_FLEAVE();
 
 	return MM_ERROR_NONE;
 }
 
-int
-_mmradio_stop_scan(mm_radio_t* radio)
+int _mmradio_stop_scan(mm_radio_t *radio)
 {
 	MMRADIO_LOG_FENTER();
 
-	MMRADIO_CHECK_INSTANCE( radio );
-	MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_STOP_SCAN );
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_STOP_SCAN);
 
 	radio->stop_scan = true;
 
- 	if( radio->scan_thread > 0 )
-	{
+	if (radio->scan_thread > 0) {
 		pthread_cancel(radio->scan_thread);
 		pthread_join(radio->scan_thread, NULL);
-	 	radio->scan_thread = 0;
+		radio->scan_thread = 0;
 	}
 
- 	MMRADIO_SET_STATE( radio, MM_RADIO_STATE_READY );
+	MMRADIO_SET_STATE(radio, MM_RADIO_STATE_READY);
 	MMRADIO_POST_MSG(radio, MM_MESSAGE_RADIO_SCAN_STOP, NULL);
 
 	MMRADIO_LOG_FLEAVE();
@@ -949,77 +887,66 @@ _mmradio_stop_scan(mm_radio_t* radio)
 	return MM_ERROR_NONE;
 }
 
-int
-_mm_radio_get_signal_strength(mm_radio_t* radio, int *value)
+int _mm_radio_get_signal_strength(mm_radio_t *radio, int *value)
 {
 	MMRADIO_LOG_FENTER();
-	MMRADIO_CHECK_INSTANCE( radio );
+	MMRADIO_CHECK_INSTANCE(radio);
 
-	return_val_if_fail( value, MM_ERROR_INVALID_ARGUMENT );
+	return_val_if_fail(value, MM_ERROR_INVALID_ARGUMENT);
 
 	/* just return stored frequency if radio device is not ready */
-	if ( radio->radio_fd < 0 )
-	{
+	if (radio->radio_fd < 0) {
 		MMRADIO_LOG_DEBUG("Device not ready so sending 0\n");
 		*value = 0;
 		return MM_ERROR_NONE;
 	}
-	if (ioctl(radio->radio_fd, VIDIOC_G_TUNER, &(radio->vt)) < 0)
-	{
+	if (ioctl(radio->radio_fd, VIDIOC_G_TUNER, &(radio->vt)) < 0) {
 		debug_error("ioctl VIDIOC_G_TUNER error\n");
 		return MM_ERROR_RADIO_INTERNAL;
 	}
-        *value = radio->vt.signal;
+	*value = radio->vt.signal;
 	MMRADIO_LOG_FLEAVE();
 	return MM_ERROR_NONE;
 }
 
-void
-__mmradio_scan_thread(mm_radio_t* radio)
+void __mmradio_scan_thread(mm_radio_t *radio)
 {
 	int ret = 0;
 	int prev_freq = 0;
 	char str_error[READ_MAX_BUFFER_SIZE];
 
-	struct v4l2_hw_freq_seek vs = {0,};
+	struct v4l2_hw_freq_seek vs = { 0, };
 	vs.tuner = TUNER_INDEX;
 	vs.type = V4L2_TUNER_RADIO;
-	vs.wrap_around = 0; /* around:1 not around:0 */
-	vs.seek_upward = 1; /* up : 1	------- down : 0 */
+	vs.wrap_around = 0;			/* around:1 not around:0 */
+	vs.seek_upward = 1;			/* up : 1   ------- down : 0 */
 
 	MMRADIO_LOG_FENTER();
-	MMRADIO_CHECK_INSTANCE_RETURN_VOID( radio );
-	if( _mmradio_mute(radio) != MM_ERROR_NONE)
+	MMRADIO_CHECK_INSTANCE_RETURN_VOID(radio);
+	if (_mmradio_mute(radio) != MM_ERROR_NONE)
 		goto FINISHED;
 
-	if( _mmradio_set_frequency(radio, radio->region_setting.band_min) != MM_ERROR_NONE)
+	if (_mmradio_set_frequency(radio, radio->region_setting.band_min) != MM_ERROR_NONE)
 		goto FINISHED;
 
 	MMRADIO_POST_MSG(radio, MM_MESSAGE_RADIO_SCAN_START, NULL);
-	MMRADIO_SET_STATE( radio, MM_RADIO_STATE_SCANNING );
+	MMRADIO_SET_STATE(radio, MM_RADIO_STATE_SCANNING);
 
-	while( ! radio->stop_scan )
-	{
+	while (!radio->stop_scan) {
 		int freq = 0;
-		MMMessageParamType param = {0,};
+		MMMessageParamType param = { 0, };
 
 		MMRADIO_LOG_DEBUG("scanning....\n");
 		ret = ioctl(radio->radio_fd, VIDIOC_S_HW_FREQ_SEEK, &vs);
 
-		if( ret == -1 )
-		{
-			if ( errno == EAGAIN )
-			{
+		if (ret == -1) {
+			if (errno == EAGAIN) {
 				MMRADIO_LOG_ERROR("scanning timeout\n");
 				continue;
-			}
-			else if ( errno == EINVAL )
-			{
+			} else if (errno == EINVAL) {
 				MMRADIO_LOG_ERROR("The tuner index is out of bounds or the value in the type field is wrong.");
 				break;
-			}
-			else
-			{
+			} else {
 				MMRADIO_LOG_ERROR("Error: %s, %d\n", strerror_r(errno, str_error, sizeof(str_error)), errno);
 				break;
 			}
@@ -1027,48 +954,45 @@ __mmradio_scan_thread(mm_radio_t* radio)
 
 		/* now we can get new frequency from radio device */
 
-		if ( radio->stop_scan ) break;
+		if (radio->stop_scan)
+			break;
 
 		ret = _mmradio_get_frequency(radio, &freq);
-		if ( ret )
-		{
+		if (ret) {
 			MMRADIO_LOG_ERROR("failed to get current frequency\n");
-		}
-		else
-		{
-			if ( freq < prev_freq )
-			{
+		} else {
+			if (freq < prev_freq) {
 				MMRADIO_LOG_DEBUG("scanning wrapped around. stopping scan\n");
 				break;
 			}
 
-			if ( freq == prev_freq)
+			if (freq == prev_freq)
 				continue;
 
 			prev_freq = param.radio_scan.frequency = freq;
 			MMRADIO_LOG_DEBUG("scanning : new frequency : [%d]\n", param.radio_scan.frequency);
 
 			/* drop if max freq is scanned */
-			if (param.radio_scan.frequency == radio->region_setting.band_max )
-			{
+			if (param.radio_scan.frequency == radio->region_setting.band_max) {
 				MMRADIO_LOG_DEBUG("%d freq is dropping...and stopping scan\n", param.radio_scan.frequency);
 				break;
 			}
 
-			if ( radio->stop_scan ) break; // doesn't need to post
+			if (radio->stop_scan) {
+				/* doesn't need to post */
+				break;
+			}
 
 			MMRADIO_POST_MSG(radio, MM_MESSAGE_RADIO_SCAN_INFO, &param);
 		}
 	}
-FINISHED:
+ FINISHED:
 	radio->scan_thread = 0;
 
-	MMRADIO_SET_STATE( radio, MM_RADIO_STATE_READY );
+	MMRADIO_SET_STATE(radio, MM_RADIO_STATE_READY);
 
-	if ( ! radio->stop_scan )
-	{
+	if (!radio->stop_scan)
 		MMRADIO_POST_MSG(radio, MM_MESSAGE_RADIO_SCAN_FINISH, NULL);
-	}
 
 	MMRADIO_LOG_FLEAVE();
 
@@ -1077,14 +1001,13 @@ FINISHED:
 	return;
 }
 
-bool
-__is_tunable_frequency(mm_radio_t* radio, int freq)
+bool __is_tunable_frequency(mm_radio_t *radio, int freq)
 {
 	MMRADIO_LOG_FENTER();
 
-	MMRADIO_CHECK_INSTANCE( radio );
+	MMRADIO_CHECK_INSTANCE(radio);
 
-	if ( freq == radio->region_setting.band_max|| freq == radio->region_setting.band_min )
+	if (freq == radio->region_setting.band_max || freq == radio->region_setting.band_min)
 		return false;
 
 	MMRADIO_LOG_FLEAVE();
@@ -1092,57 +1015,48 @@ __is_tunable_frequency(mm_radio_t* radio, int freq)
 	return true;
 }
 
-void
-__mmradio_seek_thread(mm_radio_t* radio)
+void __mmradio_seek_thread(mm_radio_t *radio)
 {
 	int ret = 0;
 	int freq = 0;
 	char str_error[READ_MAX_BUFFER_SIZE];
 	bool seek_stop = false;
-	MMMessageParamType param = {0,};
-	struct v4l2_hw_freq_seek vs = {0,};
+	MMMessageParamType param = {0, };
+	struct v4l2_hw_freq_seek vs = {0, };
 
 	vs.tuner = TUNER_INDEX;
 	vs.type = V4L2_TUNER_RADIO;
 	vs.wrap_around = DEFAULT_WRAP_AROUND;
 
 	MMRADIO_LOG_FENTER();
-	MMRADIO_CHECK_INSTANCE_RETURN_VOID( radio );
+	MMRADIO_CHECK_INSTANCE_RETURN_VOID(radio);
 
 	/* check direction */
-	switch( radio->seek_direction )
-	{
-		case MM_RADIO_SEEK_UP:
-			vs.seek_upward = 1;
-			break;
-		default:
-			vs.seek_upward = 0;
-			break;
+	switch (radio->seek_direction) {
+	case MM_RADIO_SEEK_UP:
+		vs.seek_upward = 1;
+		break;
+	default:
+		vs.seek_upward = 0;
+		break;
 	}
 
 	MMRADIO_POST_MSG(radio, MM_MESSAGE_RADIO_SEEK_START, NULL);
 
 	MMRADIO_LOG_DEBUG("seeking....\n");
 
-	while (  ! seek_stop )
-	{
-		ret = ioctl( radio->radio_fd, VIDIOC_S_HW_FREQ_SEEK, &vs );
+	while (!seek_stop) {
+		ret = ioctl(radio->radio_fd, VIDIOC_S_HW_FREQ_SEEK, &vs);
 
-		if( ret == -1 )
-		{
-			if ( errno == EAGAIN )
-			{
+		if (ret == -1) {
+			if (errno == EAGAIN) {
 				/* FIXIT : we need retrying code here */
 				MMRADIO_LOG_ERROR("scanning timeout\n");
 				goto SEEK_FAILED;
-			}
-			else if ( errno == EINVAL )
-			{
+			} else if (errno == EINVAL) {
 				MMRADIO_LOG_ERROR("The tuner index is out of bounds or the value in the type field is wrong.");
 				goto SEEK_FAILED;
-			}
-			else
-			{
+			} else {
 				MMRADIO_LOG_ERROR("Error: %s, %d\n", strerror_r(errno, str_error, sizeof(str_error)), errno);
 				goto SEEK_FAILED;
 			}
@@ -1150,8 +1064,7 @@ __mmradio_seek_thread(mm_radio_t* radio)
 
 		/* now we can get new frequency from radio device */
 		ret = _mmradio_get_frequency(radio, &freq);
-		if ( ret )
-		{
+		if (ret) {
 			MMRADIO_LOG_ERROR("failed to get current frequency\n");
 			goto SEEK_FAILED;
 		}
@@ -1159,30 +1072,27 @@ __mmradio_seek_thread(mm_radio_t* radio)
 		MMRADIO_LOG_DEBUG("found frequency\n");
 
 		/* if same freq is found, ignore it and search next one. */
-		if ( freq == radio->prev_seek_freq )
-		{
+		if (freq == radio->prev_seek_freq) {
 			MMRADIO_LOG_DEBUG("It's same with previous found one. So, trying next one. \n");
 			continue;
 		}
 
-		if ( __is_tunable_frequency(radio, freq) ) // check if it's limit freq or not
-		{
+		/* check if it's limit freq or not */
+		if (__is_tunable_frequency(radio, freq)) {
 			/* now tune to new frequency */
 			ret = _mmradio_set_frequency(radio, freq);
-			if ( ret )
-			{
+			if (ret) {
 				MMRADIO_LOG_ERROR("failed to tune to new frequency\n");
 				goto SEEK_FAILED;
 			}
 		}
 
 		/* now turn on radio
-		  * In the case of limit freq, tuner should be unmuted.
-		  * Otherwise, sound can't output even though application set new frequency.
-		  */
+		 * In the case of limit freq, tuner should be unmuted.
+		 * Otherwise, sound can't output even though application set new frequency.
+		 */
 		ret = _mmradio_unmute(radio);
-		if ( ret )
-		{
+		if (ret) {
 			MMRADIO_LOG_ERROR("failed to tune to new frequency\n");
 			goto SEEK_FAILED;
 		}
@@ -1200,7 +1110,7 @@ __mmradio_seek_thread(mm_radio_t* radio)
 	pthread_exit(NULL);
 	return;
 
-SEEK_FAILED:
+ SEEK_FAILED:
 	/* freq -1 means it's failed to seek */
 	param.radio_scan.frequency = -1;
 	MMRADIO_POST_MSG(radio, MM_MESSAGE_RADIO_SEEK_FINISH, &param);
@@ -1208,15 +1118,13 @@ SEEK_FAILED:
 	return;
 }
 
-static bool
-__mmradio_post_message(mm_radio_t* radio, enum MMMessageType msgtype, MMMessageParamType* param)
+static bool __mmradio_post_message(mm_radio_t *radio, enum MMMessageType msgtype, MMMessageParamType *param)
 {
-	MMRADIO_CHECK_INSTANCE( radio );
+	MMRADIO_CHECK_INSTANCE(radio);
 
 	MMRADIO_LOG_FENTER();
 
-	if ( !radio->msg_cb )
-	{
+	if (!radio->msg_cb) {
 		debug_warning("failed to post a message\n");
 		return false;
 	}
@@ -1230,159 +1138,151 @@ __mmradio_post_message(mm_radio_t* radio, enum MMMessageType msgtype, MMMessageP
 	return true;
 }
 
-static int
- __mmradio_check_state(mm_radio_t* radio, MMRadioCommand command)
- {
-	 MMRadioStateType radio_state = MM_RADIO_STATE_NUM;
+static int __mmradio_check_state(mm_radio_t *radio, MMRadioCommand command)
+{
+	MMRadioStateType radio_state = MM_RADIO_STATE_NUM;
 
 	MMRADIO_LOG_FENTER();
 
- 	MMRADIO_CHECK_INSTANCE( radio );
+	MMRADIO_CHECK_INSTANCE(radio);
 
- 	radio_state = __mmradio_get_state( radio );
+	radio_state = __mmradio_get_state(radio);
 
- 	MMRADIO_LOG_DEBUG("incomming command : %d  current state : %d\n", command, radio_state);
+	MMRADIO_LOG_DEBUG("incomming command : %d  current state : %d\n", command, radio_state);
 
- 	switch( command )
- 	{
- 		case MMRADIO_COMMAND_CREATE:
- 		{
- 			if ( radio_state != 0 )
- 				goto NO_OP;
- 		}
- 		break;
+	switch (command) {
+	case MMRADIO_COMMAND_CREATE:
+		{
+			if (radio_state != 0)
+				goto NO_OP;
+		}
+		break;
 
- 		case MMRADIO_COMMAND_REALIZE:
- 		{
-			if ( radio_state == MM_RADIO_STATE_READY ||
-					radio_state == MM_RADIO_STATE_PLAYING ||
-					radio_state == MM_RADIO_STATE_SCANNING )
+	case MMRADIO_COMMAND_REALIZE:
+		{
+			if (radio_state == MM_RADIO_STATE_READY ||
+				radio_state == MM_RADIO_STATE_PLAYING ||
+				radio_state == MM_RADIO_STATE_SCANNING)
 				goto NO_OP;
 
-			if ( radio_state == 0 )
+			if (radio_state == 0)
 				goto INVALID_STATE;
- 		}
- 		break;
+		}
+		break;
 
- 		case MMRADIO_COMMAND_UNREALIZE:
- 		{
-			if ( radio_state == MM_RADIO_STATE_NULL )
+	case MMRADIO_COMMAND_UNREALIZE:
+		{
+			if (radio_state == MM_RADIO_STATE_NULL)
 				goto NO_OP;
 
 			/* we can call unrealize at any higher state */
- 		}
- 		break;
-
- 		case MMRADIO_COMMAND_START:
- 		{
- 			if ( radio_state == MM_RADIO_STATE_PLAYING )
- 				goto NO_OP;
-
- 			if ( radio_state != MM_RADIO_STATE_READY )
- 				goto INVALID_STATE;
- 		}
- 		break;
-
- 		case MMRADIO_COMMAND_STOP:
- 		{
- 			if ( radio_state == MM_RADIO_STATE_READY )
- 				goto NO_OP;
-
- 			if ( radio_state != MM_RADIO_STATE_PLAYING )
- 				goto INVALID_STATE;
- 		}
- 		break;
-
- 		case MMRADIO_COMMAND_START_SCAN:
- 		{
- 			if ( radio_state == MM_RADIO_STATE_SCANNING )
- 				goto NO_OP;
-
- 			if ( radio_state != MM_RADIO_STATE_READY )
- 				goto INVALID_STATE;
- 		}
- 		break;
-
- 		case MMRADIO_COMMAND_STOP_SCAN:
- 		{
- 			if ( radio_state == MM_RADIO_STATE_READY )
- 				goto NO_OP;
-
- 			if ( radio_state != MM_RADIO_STATE_SCANNING )
- 				goto INVALID_STATE;
- 		}
- 		break;
-
- 		case MMRADIO_COMMAND_DESTROY:
- 		case MMRADIO_COMMAND_MUTE:
- 		case MMRADIO_COMMAND_UNMUTE:
- 		case MMRADIO_COMMAND_SET_FREQ:
- 		case MMRADIO_COMMAND_GET_FREQ:
-		case MMRADIO_COMMAND_SET_REGION:
- 		{
+		}
+		break;
+
+	case MMRADIO_COMMAND_START:
+		{
+			if (radio_state == MM_RADIO_STATE_PLAYING)
+				goto NO_OP;
+
+			if (radio_state != MM_RADIO_STATE_READY)
+				goto INVALID_STATE;
+		}
+		break;
+
+	case MMRADIO_COMMAND_STOP:
+		{
+			if (radio_state == MM_RADIO_STATE_READY)
+				goto NO_OP;
+
+			if (radio_state != MM_RADIO_STATE_PLAYING)
+				goto INVALID_STATE;
+		}
+		break;
+
+	case MMRADIO_COMMAND_START_SCAN:
+		{
+			if (radio_state == MM_RADIO_STATE_SCANNING)
+				goto NO_OP;
+
+			if (radio_state != MM_RADIO_STATE_READY)
+				goto INVALID_STATE;
+		}
+		break;
+
+	case MMRADIO_COMMAND_STOP_SCAN:
+		{
+			if (radio_state == MM_RADIO_STATE_READY)
+				goto NO_OP;
+
+			if (radio_state != MM_RADIO_STATE_SCANNING)
+				goto INVALID_STATE;
+		}
+		break;
+
+	case MMRADIO_COMMAND_DESTROY:
+	case MMRADIO_COMMAND_MUTE:
+	case MMRADIO_COMMAND_UNMUTE:
+	case MMRADIO_COMMAND_SET_FREQ:
+	case MMRADIO_COMMAND_GET_FREQ:
+	case MMRADIO_COMMAND_SET_REGION:
+		{
 			/* we can do it at any state */
- 		}
- 		break;
+		}
+		break;
 
- 		case MMRADIO_COMMAND_SEEK:
- 		{
-			if ( radio_state != MM_RADIO_STATE_PLAYING )
+	case MMRADIO_COMMAND_SEEK:
+		{
+			if (radio_state != MM_RADIO_STATE_PLAYING)
 				goto INVALID_STATE;
- 		}
- 		break;
+		}
+		break;
 
-		case MMRADIO_COMMAND_GET_REGION:
+	case MMRADIO_COMMAND_GET_REGION:
 		{
-			if ( radio_state == MM_RADIO_STATE_NULL )
+			if (radio_state == MM_RADIO_STATE_NULL)
 				goto INVALID_STATE;
 		}
 		break;
 
- 		default:
- 			MMRADIO_LOG_DEBUG("not handled in FSM. don't care it\n");
- 		break;
- 	}
+	default:
+		MMRADIO_LOG_DEBUG("not handled in FSM. don't care it\n");
+		break;
+	}
 
- 	MMRADIO_LOG_DEBUG("status OK\n");
+	MMRADIO_LOG_DEBUG("status OK\n");
 
- 	radio->cmd = command;
+	radio->cmd = command;
 
 	MMRADIO_LOG_FLEAVE();
 
- 	return MM_ERROR_NONE;
-
+	return MM_ERROR_NONE;
 
  INVALID_STATE:
- 	debug_warning("invalid state. current : %d  command : %d\n",
- 			radio_state, command);
+	debug_warning("invalid state. current : %d  command : %d\n", radio_state, command);
 	MMRADIO_LOG_FLEAVE();
- 	return MM_ERROR_RADIO_INVALID_STATE;
-
+	return MM_ERROR_RADIO_INVALID_STATE;
 
  NO_OP:
- 	debug_warning("mm-radio is in the desired state(%d). doing noting\n", radio_state);
+	debug_warning("mm-radio is in the desired state(%d). doing noting\n", radio_state);
 	MMRADIO_LOG_FLEAVE();
- 	return MM_ERROR_RADIO_NO_OP;
+	return MM_ERROR_RADIO_NO_OP;
 
- }
+}
 
-static bool
-__mmradio_set_state(mm_radio_t* radio, int new_state)
+static bool __mmradio_set_state(mm_radio_t *radio, int new_state)
 {
-	MMMessageParamType msg = {0, };
+	MMMessageParamType msg = { 0, };
 	int msg_type = MM_MESSAGE_UNKNOWN;
 
 	MMRADIO_LOG_FENTER();
- 	MMRADIO_CHECK_INSTANCE( radio );
+	MMRADIO_CHECK_INSTANCE(radio);
 
-	if ( ! radio )
-	{
+	if (!radio) {
 		debug_warning("calling set_state with invalid radio handle\n");
 		return false;
 	}
 
-	if ( radio->current_state == new_state && radio->pending_state == 0 )
-	{
+	if (radio->current_state == new_state && radio->pending_state == 0) {
 		debug_warning("we are in same state\n");
 		return true;
 	}
@@ -1396,26 +1296,25 @@ __mmradio_set_state(mm_radio_t* radio, int new_state)
 	msg.state.current = radio->current_state;
 
 	/* post message to application */
-	switch( radio->sm.by_focus_cb )
-	{
-		case MMRADIO_FOCUS_CB_NONE:
+	switch (radio->sm.by_focus_cb) {
+	case MMRADIO_FOCUS_CB_NONE:
 		{
 			msg_type = MM_MESSAGE_STATE_CHANGED;
-			MMRADIO_POST_MSG( radio, msg_type, &msg );
+			MMRADIO_POST_MSG(radio, msg_type, &msg);
 		}
 		break;
 
-		case MMRADIO_FOCUS_CB_POSTMSG:
+	case MMRADIO_FOCUS_CB_POSTMSG:
 		{
 			msg_type = MM_MESSAGE_STATE_INTERRUPTED;
 			msg.union_type = MM_MSG_UNION_CODE;
 			msg.code = radio->sm.event_src;
-			MMRADIO_POST_MSG( radio, msg_type, &msg );
+			MMRADIO_POST_MSG(radio, msg_type, &msg);
 		}
 		break;
 
-		case MMRADIO_FOCUS_CB_SKIP_POSTMSG:
-		default:
+	case MMRADIO_FOCUS_CB_SKIP_POSTMSG:
+	default:
 		break;
 	}
 
@@ -1424,23 +1323,21 @@ __mmradio_set_state(mm_radio_t* radio, int new_state)
 	return true;
 }
 
-static int
-__mmradio_get_state(mm_radio_t* radio)
+static int __mmradio_get_state(mm_radio_t *radio)
 {
- 	MMRADIO_CHECK_INSTANCE( radio );
+	MMRADIO_CHECK_INSTANCE(radio);
 
 	MMRADIO_LOG_DEBUG("radio state : current : [%d]   old : [%d]   pending : [%d]\n",
-			radio->current_state, radio->old_state, radio->pending_state );
+		radio->current_state, radio->old_state, radio->pending_state);
 
 	return radio->current_state;
 }
 
-static void
-__mmradio_sound_focus_cb(int id, mm_sound_focus_type_e focus_type,
-                             mm_sound_focus_state_e focus_state, const char *reason_for_change,
-                             const char *additional_info, void *user_data)
+static void __mmradio_sound_focus_cb(int id, mm_sound_focus_type_e focus_type,
+	mm_sound_focus_state_e focus_state, const char *reason_for_change,
+	const char *additional_info, void *user_data)
 {
-	mm_radio_t *radio = (mm_radio_t *) user_data;
+	mm_radio_t *radio = (mm_radio_t *)user_data;
 	enum MMMessageInterruptedCode event_source;
 	int result = MM_ERROR_NONE;
 	int postMsg = false;
@@ -1452,92 +1349,84 @@ __mmradio_sound_focus_cb(int id, mm_sound_focus_type_e focus_type,
 	radio->sm.event_src = event_source;
 
 	switch (focus_state) {
-		case FOCUS_IS_RELEASED: {
-				radio->sm.cur_focus_type &= ~focus_type;
-				radio->sm.by_focus_cb = MMRADIO_FOCUS_CB_POSTMSG;
+	case FOCUS_IS_RELEASED:{
+			radio->sm.cur_focus_type &= ~focus_type;
+			radio->sm.by_focus_cb = MMRADIO_FOCUS_CB_POSTMSG;
 
-				result = _mmradio_stop(radio);
-				if (result) {
-					MMRADIO_LOG_ERROR("failed to stop radio\n");
-				}
-				MMRADIO_LOG_DEBUG("FOCUS_IS_RELEASED cur_focus_type : %d\n", radio->sm.cur_focus_type);
-			}
-			break;
+			result = _mmradio_stop(radio);
+			if (result)
+				MMRADIO_LOG_ERROR("failed to stop radio\n");
 
-		case FOCUS_IS_ACQUIRED: {
-				MMMessageParamType msg = {0,};
-				msg.union_type = MM_MSG_UNION_CODE;
-				msg.code = event_source;
+			MMRADIO_LOG_DEBUG("FOCUS_IS_RELEASED cur_focus_type : %d\n", radio->sm.cur_focus_type);
+		}
+		break;
 
-				radio->sm.cur_focus_type |= focus_type;
+	case FOCUS_IS_ACQUIRED:{
+			MMMessageParamType msg = { 0, };
+			msg.union_type = MM_MSG_UNION_CODE;
+			msg.code = event_source;
 
-				if ((postMsg) && (FOCUS_FOR_BOTH == radio->sm.cur_focus_type))
-					MMRADIO_POST_MSG(radio, MM_MESSAGE_READY_TO_RESUME, &msg);
+			radio->sm.cur_focus_type |= focus_type;
 
-				radio->sm.by_focus_cb = MMRADIO_FOCUS_CB_NONE;
+			if ((postMsg) && (FOCUS_FOR_BOTH == radio->sm.cur_focus_type))
+				MMRADIO_POST_MSG(radio, MM_MESSAGE_READY_TO_RESUME, &msg);
 
-				MMRADIO_LOG_DEBUG("FOCUS_IS_ACQUIRED cur_focus_type : %d\n", radio->sm.cur_focus_type);
-			}
-			break;
+			radio->sm.by_focus_cb = MMRADIO_FOCUS_CB_NONE;
 
-		default:
-			MMRADIO_LOG_DEBUG("Unknown focus_state\n");
-			break;
+			MMRADIO_LOG_DEBUG("FOCUS_IS_ACQUIRED cur_focus_type : %d\n", radio->sm.cur_focus_type);
+		}
+		break;
+
+	default:
+		MMRADIO_LOG_DEBUG("Unknown focus_state\n");
+		break;
 	}
 
 	MMRADIO_LOG_FLEAVE();
 }
 
-static void
-__mmradio_device_connected_cb(MMSoundDevice_t device, bool is_connected, void *user_data)
+static void __mmradio_device_connected_cb(MMSoundDevice_t device, bool is_connected, void *user_data)
 {
-	mm_radio_t *radio = (mm_radio_t *) user_data;
+	mm_radio_t *radio = (mm_radio_t *)user_data;
 	int result = MM_ERROR_NONE;
 	mm_sound_device_type_e type;
 
 	MMRADIO_LOG_FENTER();
 	MMRADIO_CHECK_INSTANCE_RETURN_VOID(radio);
 
-	if (mm_sound_get_device_type (device, &type) != MM_ERROR_NONE)
-	{
+	if (mm_sound_get_device_type(device, &type) != MM_ERROR_NONE) {
 		debug_error("getting device type failed");
-	}
-	else
-	{
-		switch (type)
-		{
-			case MM_SOUND_DEVICE_TYPE_AUDIOJACK:
-			case MM_SOUND_DEVICE_TYPE_BLUETOOTH:
-			case MM_SOUND_DEVICE_TYPE_HDMI:
-			case MM_SOUND_DEVICE_TYPE_MIRRORING:
-			case MM_SOUND_DEVICE_TYPE_USB_AUDIO:
-			if (!is_connected)
-			{
+	} else {
+		switch (type) {
+		case MM_SOUND_DEVICE_TYPE_AUDIOJACK:
+		case MM_SOUND_DEVICE_TYPE_BLUETOOTH:
+		case MM_SOUND_DEVICE_TYPE_HDMI:
+		case MM_SOUND_DEVICE_TYPE_MIRRORING:
+		case MM_SOUND_DEVICE_TYPE_USB_AUDIO:
+			if (!is_connected) {
 				MMRADIO_LOG_ERROR("sound device unplugged");
 				radio->sm.by_focus_cb = MMRADIO_FOCUS_CB_POSTMSG;
 				radio->sm.event_src = MM_MSG_CODE_INTERRUPTED_BY_EARJACK_UNPLUG;
 
 				result = _mmradio_stop(radio);
 				if (result != MM_ERROR_NONE)
-				{
 					MMRADIO_LOG_ERROR("failed to stop radio\n");
-				}
 			}
 			break;
-			default:
+		default:
 			break;
 		}
 	}
 	MMRADIO_LOG_FLEAVE();
 }
 
-int _mmradio_get_region_type(mm_radio_t*radio, MMRadioRegionType *type)
+int _mmradio_get_region_type(mm_radio_t *radio, MMRadioRegionType *type)
 {
 	MMRADIO_LOG_FENTER();
-	MMRADIO_CHECK_INSTANCE( radio );
-	MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_GET_REGION );
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_GET_REGION);
 
-	return_val_if_fail( type, MM_ERROR_INVALID_ARGUMENT );
+	return_val_if_fail(type, MM_ERROR_INVALID_ARGUMENT);
 
 	*type = radio->region_setting.country;
 
@@ -1545,13 +1434,13 @@ int _mmradio_get_region_type(mm_radio_t*radio, MMRadioRegionType *type)
 	return MM_ERROR_NONE;
 }
 
-int _mmradio_get_region_frequency_range(mm_radio_t* radio, unsigned int *min_freq, unsigned int *max_freq)
+int _mmradio_get_region_frequency_range(mm_radio_t *radio, unsigned int *min_freq, unsigned int *max_freq)
 {
 	MMRADIO_LOG_FENTER();
-	MMRADIO_CHECK_INSTANCE( radio );
-	MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_GET_REGION );
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_GET_REGION);
 
-	return_val_if_fail( min_freq && max_freq, MM_ERROR_INVALID_ARGUMENT );
+	return_val_if_fail(min_freq && max_freq, MM_ERROR_INVALID_ARGUMENT);
 
 	*min_freq = radio->region_setting.band_min;
 	*max_freq = radio->region_setting.band_max;
@@ -1560,18 +1449,16 @@ int _mmradio_get_region_frequency_range(mm_radio_t* radio, unsigned int *min_fre
 	return MM_ERROR_NONE;
 }
 
-int _mmradio_get_channel_spacing(mm_radio_t* radio, unsigned int *ch_spacing)
+int _mmradio_get_channel_spacing(mm_radio_t *radio, unsigned int *ch_spacing)
 {
 	MMRADIO_LOG_FENTER();
-	MMRADIO_CHECK_INSTANCE( radio );
-	MMRADIO_CHECK_STATE_RETURN_IF_FAIL( radio, MMRADIO_COMMAND_GET_REGION );
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_GET_REGION);
 
-	return_val_if_fail( ch_spacing, MM_ERROR_INVALID_ARGUMENT );
+	return_val_if_fail(ch_spacing, MM_ERROR_INVALID_ARGUMENT);
 
 	*ch_spacing = radio->region_setting.channel_spacing;
 
 	MMRADIO_LOG_FLEAVE();
 	return MM_ERROR_NONE;
 }
-
-
diff --git a/test/mm_radio_rt_api_test.c b/test/mm_radio_rt_api_test.c
index 1f3c9a9..cf060d4 100755
--- a/test/mm_radio_rt_api_test.c
+++ b/test/mm_radio_rt_api_test.c
@@ -27,168 +27,164 @@
 #define _MAX_INPUT_STRING_ 100
 
 static int __menu(void);
-static void __call_api( int choosen );
+static void __call_api(int choosen);
 static int __msg_rt_callback(int message, void *param, void *user_param);
 
 static MMHandleType g_my_radio = 0;
 
-void __call_api( int choosen )
+void __call_api(int choosen)
 {
 	int ret = MM_ERROR_NONE;
 
-	switch( choosen )
-	{
-		case 1:
+	switch (choosen) {
+	case 1:
 		{
-			RADIO_TEST__( mm_radio_create( &g_my_radio ); )
-			RADIO_TEST__( mm_radio_set_message_callback( g_my_radio, __msg_rt_callback, g_my_radio); )
+			RADIO_TEST__(mm_radio_create(&g_my_radio);)
+			RADIO_TEST__(mm_radio_set_message_callback(g_my_radio, __msg_rt_callback, g_my_radio);)
 		}
 		break;
 
-		case 2:
+	case 2:
 		{
-			RADIO_TEST__( mm_radio_destroy( g_my_radio ); )
+			RADIO_TEST__(mm_radio_destroy(g_my_radio);)
 			g_my_radio = 0;
 		}
 		break;
 
-		case 3:
+	case 3:
 		{
-			RADIO_TEST__( mm_radio_realize(g_my_radio ); )
+			RADIO_TEST__(mm_radio_realize(g_my_radio);)
 		}
 		break;
 
-		case 4:
+	case 4:
 		{
-			RADIO_TEST__( mm_radio_unrealize(g_my_radio ); )
+			RADIO_TEST__(mm_radio_unrealize(g_my_radio);)
 		}
 		break;
 
-		case 7:
+	case 7:
 		{
 			MMRadioStateType state = 0;
-			RADIO_TEST__( mm_radio_get_state(g_my_radio, &state); )
-
+			RADIO_TEST__(mm_radio_get_state(g_my_radio, &state);)
 			printf("state : %d\n", state);
 		}
 		break;
 
-		case 8:
+	case 8:
 		{
-			RADIO_TEST__( mm_radio_start(g_my_radio); )
+			RADIO_TEST__(mm_radio_start(g_my_radio);)
 		}
 		break;
 
-		case 9:
+	case 9:
 		{
-			RADIO_TEST__( mm_radio_stop(g_my_radio); )
+			RADIO_TEST__(mm_radio_stop(g_my_radio);)
 		}
 		break;
 
-		case 10:
+	case 10:
 		{
 			int direction = 0;
 			printf("input seek direction(0:UP/1:DOWN) : ");
 			if (scanf("%d", &direction) == 0)
 				return;
 
-			RADIO_TEST__( mm_radio_seek(g_my_radio, direction); )
+			RADIO_TEST__(mm_radio_seek(g_my_radio, direction);)
 		}
 		break;
 
-		case 11:
+	case 11:
 		{
 			int freq = 0;
 			printf("input freq : ");
 			if (scanf("%d", &freq) == 0)
 				return;
 
-			RADIO_TEST__( mm_radio_set_frequency(g_my_radio, freq); )
+			RADIO_TEST__(mm_radio_set_frequency(g_my_radio, freq);)
 		}
 		break;
 
-		case 12:
+	case 12:
 		{
 			int freq = 0;
-			RADIO_TEST__( mm_radio_get_frequency(g_my_radio, &freq ); )
-
+			RADIO_TEST__(mm_radio_get_frequency(g_my_radio, &freq);)
 			printf("freq : %d\n", freq);
 		}
 		break;
 
-		case 13:
+	case 13:
 		{
-			RADIO_TEST__( mm_radio_scan_start(g_my_radio); )
+			RADIO_TEST__(mm_radio_scan_start(g_my_radio);)
 		}
 		break;
 
-		case 14:
+	case 14:
 		{
-			RADIO_TEST__( mm_radio_scan_stop(g_my_radio); )
+			RADIO_TEST__(mm_radio_scan_stop(g_my_radio);)
 		}
 		break;
 
-		case 16:
+	case 16:
 		{
 			int muted = 0;
 			printf("select one(0:UNMUTE/1:MUTE) : ");
-			if ( scanf("%d", &muted) == 0)
+			if (scanf("%d", &muted) == 0)
 				return;
-			RADIO_TEST__( mm_radio_set_mute(g_my_radio, muted); )
+			RADIO_TEST__(mm_radio_set_mute(g_my_radio, muted);)
 		}
 		break;
 
-		case 17:
+	case 17:
 		{
 			MMRadioRegionType type = 0;
-			RADIO_TEST__( mm_radio_get_region_type(g_my_radio, &type ); )
+			RADIO_TEST__(mm_radio_get_region_type(g_my_radio, &type);)
 			printf("region type : %d\n", type);
 		}
 		break;
 
-		case 18:
+	case 18:
 		{
 			unsigned int min_freq = 0;
 			unsigned int max_freq = 0;
-			RADIO_TEST__( mm_radio_get_region_frequency_range(g_my_radio, &min_freq, &max_freq ); )
+			RADIO_TEST__(mm_radio_get_region_frequency_range(g_my_radio, &min_freq, &max_freq);)
 			printf("region band range: %d ~ %d KHz\n", min_freq, max_freq);
 		}
 		break;
-		case 19:
+	case 19:
 		{
 			int signal_strength = 0;
-			RADIO_TEST__( mm_radio_get_signal_strength(g_my_radio, &signal_strength); )
+			RADIO_TEST__(mm_radio_get_signal_strength(g_my_radio, &signal_strength);)
 			printf("signal strength is : %d \n", signal_strength);
 		}
 		break;
-		case 20:
+	case 20:
 		{
 			int channel_spacing = 0;
-			RADIO_TEST__( mm_radio_get_channel_spacing(g_my_radio, &channel_spacing); )
+			RADIO_TEST__(mm_radio_get_channel_spacing(g_my_radio, &channel_spacing);)
 			printf("channel_spacing is : %d \n", channel_spacing);
 		}
 		break;
 
-		default:
-			break;
+	default:
+		break;
 	}
 }
 
 int mm_radio_rt_api_test(void)
 {
-	while(1)
-	{
+	while (1) {
 		int choosen = 0;
 
 		choosen = __menu();
 
-		if ( choosen == -1)
+		if (choosen == -1)
 			continue;
 
-		if ( choosen == 0 )
+		if (choosen == 0)
 			break;
 
-		__call_api( choosen );
+		__call_api(choosen);
 	}
 
 	printf("radio test client finished\n");
@@ -224,37 +220,30 @@ int __menu(void)
 	printf("---------------------------------------------------------\n");
 	printf("choose one : ");
 
-	if ( scanf("%d", &menu_item) == 0)
-	{
+	if (scanf("%d", &menu_item) == 0) {
 		char temp[_MAX_INPUT_STRING_];
-        if (scanf("%99s", temp) ==0)
-        {
-            printf("Error while flushing the input buffer - but lets continue\n");
-        }
+		if (scanf("%99s", temp) == 0)
+			printf("Error while flushing the input buffer - but lets continue\n");
 		return -1;
-    }
+	}
 
-	if ( menu_item > MENU_ITEM_MAX )
+	if (menu_item > MENU_ITEM_MAX)
 		menu_item = -1;
 
 	return menu_item;
 }
 
-
 int __msg_rt_callback(int message, void *pParam, void *user_param)
 {
-	MMMessageParamType* param = (MMMessageParamType*)pParam;
-	MMHandleType radio = (MMHandleType) user_param;
+	MMMessageParamType *param = (MMMessageParamType *)pParam;
+	MMHandleType radio = (MMHandleType)user_param;
 	int ret = 0;
 
 	printf("incomming message : %d\n", message);
 
-	switch(message)
-	{
+	switch (message) {
 	case MM_MESSAGE_STATE_CHANGED:
-
-		printf("MM_MESSAGE_STATE_CHANGED: current : %d    old : %d\n"
-				, param->state.current, param->state.previous);
+		printf("MM_MESSAGE_STATE_CHANGED: current : %d    old : %d\n", param->state.current, param->state.previous);
 		break;
 	case MM_MESSAGE_RADIO_SCAN_START:
 		printf("MM_MESSAGE_RADIO_SCAN_START\n");
@@ -268,11 +257,11 @@ int __msg_rt_callback(int message, void *pParam, void *user_param)
 		break;
 	case MM_MESSAGE_RADIO_SCAN_FINISH:
 		printf("MM_MESSAGE_RADIO_SCAN_FINISHED\n");
-		RADIO_TEST__( mm_radio_scan_stop(radio); )
+		RADIO_TEST__(mm_radio_scan_stop(radio);)
 		break;
 	case MM_MESSAGE_RADIO_SEEK_START:
-			printf("MM_MESSAGE_RADIO_SEEK_START\n");
-			break;
+		printf("MM_MESSAGE_RADIO_SEEK_START\n");
+		break;
 	case MM_MESSAGE_RADIO_SEEK_FINISH:
 		printf("MM_MESSAGE_RADIO_SEEK_FINISHED : freq : %d\n", param->radio_scan.frequency);
 		break;
@@ -281,7 +270,7 @@ int __msg_rt_callback(int message, void *pParam, void *user_param)
 		break;
 	case MM_MESSAGE_READY_TO_RESUME:
 		printf("MM_MESSAGE_READY_TO_RESUME\n");
-		RADIO_TEST__( mm_radio_start(radio); )
+		RADIO_TEST__(mm_radio_start(radio);)
 		break;
 	default:
 		printf("ERROR : unknown message received!\n");
diff --git a/test/mm_radio_testsuite.c b/test/mm_radio_testsuite.c
index b798d53..fa3adbe 100755
--- a/test/mm_radio_testsuite.c
+++ b/test/mm_radio_testsuite.c
@@ -23,7 +23,6 @@
 #include <stdlib.h>
 #include <stdio.h>
 
-
 #include "mm_radio.h"
 #include "mm_radio_test_type.h"
 #include "mm_radio_rt_api_test.h"
@@ -47,66 +46,58 @@ static void __print_menu(void);
 static void __run_test(int key);
 
 /* list of tests*/
-test_item_t g_tests[100] =
-{
+test_item_t g_tests[100] = {
 	/* menu string : short string to be displayed to menu
-	     description : detailed description
-	     test function :  a pointer to a actual test function
-	     0 : to be filled with return value of test function
+	   description : detailed description
+	   test function :  a pointer to a actual test function
+	   0 : to be filled with return value of test function
 	 */
 	{
-		"init test",
-  		"check radio init function",
-  		__test_radio_init,
-      	0
-	},
+	 "init test",
+	 "check radio init function",
+	 __test_radio_init,
+	 0},
 
 	{
-		"listening gorealra",
-  		"let's listen to the gorealra!",
-  		__test_radio_listen_gorealra,
-      	0
-	},
+	 "listening gorealra",
+	 "let's listen to the gorealra!",
+	 __test_radio_listen_gorealra,
+	 0},
 
 	{
-		"repeat_init_release",
-  		"repeat init and release and check if it working and memory usage increment",
-  		__test_repeat_init_release,
-      	0
-	},
+	 "repeat_init_release",
+	 "repeat init and release and check if it working and memory usage increment",
+	 __test_repeat_init_release,
+	 0},
 
 	{
-		"repeat_start_stop",
-  		"repeat start and stop and check if it working and memory usage increment",
-  		__test_repeat_start_stop,
-      	0
-	},
+	 "repeat_start_stop",
+	 "repeat start and stop and check if it working and memory usage increment",
+	 __test_repeat_start_stop,
+	 0},
 
 	{
-		"repeat_seek",
-  		"repeat seek and check if it working and memory usage increment",
-  		__test_repeat_seek,
-      	0
-	},
+	 "repeat_seek",
+	 "repeat seek and check if it working and memory usage increment",
+	 __test_repeat_seek,
+	 0},
 
 	{
-		"repeat_whole",
-  		"repeat whole radio sequence and check if it working and memory usage increment",
-  		__test_repeat_whole,
-      	0
-	},
+	 "repeat_whole",
+	 "repeat whole radio sequence and check if it working and memory usage increment",
+	 __test_repeat_whole,
+	 0},
 
 	{
-		"manual api calling test",
-  		"mapping each api to each test manu. just like other testsuite. try to reproduce the bugs with it.",
-  		__test_manual_api_calling,
-      	0
-	},
+	 "manual api calling test",
+	 "mapping each api to each test manu. just like other testsuite. try to reproduce the bugs with it.",
+	 __test_manual_api_calling,
+	 0},
 
- 	/* add tests here*/
+	/* add tests here */
 
- 	/* NOTE : do not remove this last item */
- 	{"end", "", NULL, 0},
+	/* NOTE : do not remove this last item */
+	{"end", "", NULL, 0},
 };
 
 int g_num_of_tests = 0;
@@ -120,14 +111,13 @@ int main(int argc, char **argv)
 
 		do {
 			key = getchar();
-			
-			if ( key >= '0' && key <= '9')
-			{
-				__run_test( key - '0' );
-			}
-		}while ( key == '\n' );
-	}while(key != 'q' && key == 'Q');
-	
+
+			if (key >= '0' && key <= '9')
+				__run_test(key - '0');
+
+		} while (key == '\n');
+	} while (key != 'q' && key == 'Q');
+
 	printf("radio test client finished\n");
 
 	return 0;
@@ -140,10 +130,9 @@ void __print_menu(void)
 	printf("\n\nFMRadio testing menu\n");
 	printf("------------------------------------------\n");
 
-	for ( i = 0; g_tests[i].func; i++ )
-	{
-		printf( "[%d] %s\n", i, g_tests[i].menu_string );
-	}
+	for (i = 0; g_tests[i].func; i++)
+		printf("[%d] %s\n", i, g_tests[i].menu_string);
+
 	printf("[q] quit\n");
 
 	g_num_of_tests = i;
@@ -157,44 +146,38 @@ void __run_test(int key)
 
 	/* check index */
 	printf("#tests : %d    key : %d\n", g_num_of_tests, key);
-	if ( key >= g_num_of_tests || key < 0 )
-	{
+	if (key >= g_num_of_tests || key < 0) {
 		printf("unassigned key has pressed : %d\n", key);
 		return;
 	}
 
-	/* display description*/
-	printf( "excuting test : %s\n", g_tests[key].menu_string );
-	printf( "description : %s\n", g_tests[key].description );
+	/* display description */
+	printf("excuting test : %s\n", g_tests[key].menu_string);
+	printf("description : %s\n", g_tests[key].description);
 
-	/* calling test function*/
+	/* calling test function */
 	ret = g_tests[key].func();
 
-	g_tests[key].result =  ret;
+	g_tests[key].result = ret;
 
-	if ( ret )
-	{
-		printf( "TEST FAILED. ret code : %d\n", g_tests[key].result);
-	}
+	if (ret)
+		printf("TEST FAILED. ret code : %d\n", g_tests[key].result);
 	else
-	{
-		printf( "TEST SUCCEDED. ret code : %d\n", g_tests[key].result);
-	}
+		printf("TEST SUCCEDED. ret code : %d\n", g_tests[key].result);
 }
 
 static int __msg_callback(int message, void *pParam, void *user_param)
 {
-	MMMessageParamType* param = (MMMessageParamType*)pParam;
-	MMHandleType radio = (MMHandleType) user_param;
+	MMMessageParamType *param = (MMMessageParamType *)pParam;
+	MMHandleType radio = (MMHandleType)user_param;
 	int ret = 0;
 
 	printf("incomming message : %d\n", message);
 
-	switch(message)
-	{
+	switch (message) {
 	case MM_MESSAGE_STATE_CHANGED:
-		printf("MM_MESSAGE_STATE_CHANGED: current : %d    old : %d\n"
-				, param->state.current, param->state.previous);
+		printf("MM_MESSAGE_STATE_CHANGED: current : %d    old : %d\n",
+			param->state.current, param->state.previous);
 		break;
 	case MM_MESSAGE_RADIO_SCAN_START:
 		printf("MM_MESSAGE_RADIO_SCAN_START\n");
@@ -208,11 +191,11 @@ static int __msg_callback(int message, void *pParam, void *user_param)
 		break;
 	case MM_MESSAGE_RADIO_SCAN_FINISH:
 		printf("MM_MESSAGE_RADIO_SCAN_FINISHED\n");
-		RADIO_TEST__( mm_radio_scan_stop(radio); )
+		RADIO_TEST__(mm_radio_scan_stop(radio);)
 		break;
 	case MM_MESSAGE_RADIO_SEEK_START:
-			printf("MM_MESSAGE_RADIO_SEEK_START\n");
-			break;
+		printf("MM_MESSAGE_RADIO_SEEK_START\n");
+		break;
 	case MM_MESSAGE_RADIO_SEEK_FINISH:
 		printf("MM_MESSAGE_RADIO_SEEK_FINISHED : freq : %d KHz\n", param->radio_scan.frequency);
 		break;
@@ -221,7 +204,7 @@ static int __msg_callback(int message, void *pParam, void *user_param)
 		break;
 	case MM_MESSAGE_READY_TO_RESUME:
 		printf("MM_MESSAGE_READY_TO_RESUME\n");
-		RADIO_TEST__( mm_radio_start(radio); )
+		RADIO_TEST__(mm_radio_start(radio);)
 		break;
 	default:
 		printf("ERROR : unknown message received!\n");
@@ -239,11 +222,11 @@ int __test_radio_init(void)
 	int ret = MM_ERROR_NONE;
 	MMHandleType radio = 0;
 
-	RADIO_TEST__(	mm_radio_create(&radio);	)
-	RADIO_TEST__( mm_radio_set_message_callback( radio, (MMMessageCallback)__msg_callback, (void*)radio ); )
-	RADIO_TEST__( mm_radio_realize(radio); )
-	RADIO_TEST__( mm_radio_unrealize(radio); )
-	RADIO_TEST__( mm_radio_destroy(radio); )
+	RADIO_TEST__(mm_radio_create(&radio);)
+	RADIO_TEST__(mm_radio_set_message_callback(radio, (MMMessageCallback)__msg_callback, (void *)radio);)
+	RADIO_TEST__(mm_radio_realize(radio);)
+	RADIO_TEST__(mm_radio_unrealize(radio);)
+	RADIO_TEST__(mm_radio_destroy(radio);)
 	return ret;
 }
 
@@ -254,11 +237,11 @@ int __test_radio_listen_gorealra(void)
 	int ret = MM_ERROR_NONE;
 	MMHandleType radio = 0;
 
-	RADIO_TEST__(	mm_radio_create(&radio);	)
-	RADIO_TEST__( mm_radio_set_message_callback( radio, (MMMessageCallback)__msg_callback, (void*)radio ); )
-	RADIO_TEST__( mm_radio_realize(radio); )
-	RADIO_TEST__( mm_radio_set_frequency( radio, DEFAULT_TEST_FREQ ); )
-	RADIO_TEST__( mm_radio_start(radio); )
+	RADIO_TEST__(mm_radio_create(&radio);)
+	RADIO_TEST__(mm_radio_set_message_callback(radio, (MMMessageCallback)__msg_callback, (void *)radio);)
+	RADIO_TEST__(mm_radio_realize(radio);)
+	RADIO_TEST__(mm_radio_set_frequency(radio, DEFAULT_TEST_FREQ);)
+	RADIO_TEST__(mm_radio_start(radio);)
 	return ret;
 }
 
@@ -270,13 +253,12 @@ int __test_repeat_init_release(void)
 	int cnt = 0;
 	MMHandleType radio = 0;
 
-	while ( 1 )
-	{
-		RADIO_TEST__(	mm_radio_create(&radio);	)
-		RADIO_TEST__( mm_radio_set_message_callback( radio, (MMMessageCallback)__msg_callback, (void*)radio ); )
-		RADIO_TEST__( mm_radio_realize(radio); )
-		RADIO_TEST__( mm_radio_unrealize(radio); )
-		RADIO_TEST__( mm_radio_destroy(radio); )
+	while (1) {
+		RADIO_TEST__(mm_radio_create(&radio);)
+		RADIO_TEST__(mm_radio_set_message_callback(radio, (MMMessageCallback)__msg_callback, (void *)radio);)
+		RADIO_TEST__(mm_radio_realize(radio);)
+		RADIO_TEST__(mm_radio_unrealize(radio);)
+		RADIO_TEST__(mm_radio_destroy(radio);)
 
 		cnt++;
 
@@ -293,18 +275,15 @@ int __test_repeat_start_stop(void)
 	int cnt = 0;
 	MMHandleType radio = 0;
 
-	RADIO_TEST__(	mm_radio_create(&radio);	)
-	RADIO_TEST__( mm_radio_set_message_callback( radio, (MMMessageCallback)__msg_callback, (void*)radio ); )
-	RADIO_TEST__( mm_radio_realize(radio); )
-	RADIO_TEST__( mm_radio_set_frequency( radio, DEFAULT_TEST_FREQ ); )
-
-	while(1)
-	{
-		RADIO_TEST__( mm_radio_start(radio); )
-		RADIO_TEST__( mm_radio_stop(radio); )
+	RADIO_TEST__(mm_radio_create(&radio);)
+	RADIO_TEST__(mm_radio_set_message_callback(radio, (MMMessageCallback)__msg_callback, (void *)radio);)
+	RADIO_TEST__(mm_radio_realize(radio);)
+	RADIO_TEST__(mm_radio_set_frequency(radio, DEFAULT_TEST_FREQ);)
 
+	while (1) {
+		RADIO_TEST__(mm_radio_start(radio);)
+		RADIO_TEST__(mm_radio_stop(radio);)
 		cnt++;
-
 		printf("%s : repeat count : %d\n", __FUNCTION__, cnt);
 	}
 
@@ -330,4 +309,3 @@ int __test_manual_api_calling(void)
 
 	return 0;
 }
-